// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ASH_GLANCEABLES_TASKS_GLANCEABLES_TASKS_VIEW_H_
#define ASH_GLANCEABLES_TASKS_GLANCEABLES_TASKS_VIEW_H_
#include <memory>
#include <optional>
#include "ash/api/tasks/tasks_client.h"
#include "ash/api/tasks/tasks_types.h"
#include "ash/ash_export.h"
#include "ash/glanceables/common/glanceables_time_management_bubble_view.h"
#include "ash/glanceables/glanceables_metrics.h"
#include "ash/glanceables/tasks/glanceables_tasks_error_type.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "google_apis/common/api_error_codes.h"
#include "ui/base/metadata/metadata_header_macros.h"
#include "ui/base/models/list_model.h"
#include "ui/gfx/animation/animation_delegate.h"
#include "ui/views/view.h"
#include "ui/views/view_model.h"
class GURL;
namespace views {
class LabelButton;
} // namespace views
namespace ash {
class GlanceablesTasksComboboxModel;
class GlanceablesTaskView;
// Glanceables view responsible for interacting with Google Tasks.
class ASH_EXPORT GlanceablesTasksView
: public GlanceablesTimeManagementBubbleView {
METADATA_HEADER(GlanceablesTasksView, GlanceablesTimeManagementBubbleView)
public:
explicit GlanceablesTasksView(const ui::ListModel<api::TaskList>* task_lists);
GlanceablesTasksView(const GlanceablesTasksView&) = delete;
GlanceablesTasksView& operator=(const GlanceablesTasksView&) = delete;
~GlanceablesTasksView() override;
// views::View:
void Layout(PassKey) override;
gfx::Size CalculatePreferredSize(
const views::SizeBounds& available_size) const override;
// GlanceablesTimeManagementBubbleView:
void AnimationEnded(const gfx::Animation* animation) override;
// Invalidates any pending tasks, or tasks lists requests. Called when the
// glanceables bubble widget starts closing to avoid unnecessary UI updates.
void CancelUpdates();
// Updates the cached task lists to `task_lists` and the tasks that are
// supposed to show.
void UpdateTaskLists(const ui::ListModel<api::TaskList>* task_lists);
void EndResizeAnimationForTest();
private:
// The context of why the current task list is shown.
enum class ListShownContext {
// The list is a cached one that will be updated later after the lists data
// are fetched.
kCachedList,
// The list that is loaded by default when users open glanceables.
kInitialList,
// The list is manually selected by the users through
// `task_list_combo_box_view_`.
kUserSelectedList
};
// GlanceablesTimeManagementBubbleView:
void OnHeaderIconPressed() override;
void OnFooterButtonPressed() override;
void SelectedListChanged() override;
void AnimateResize(ResizeAnimation::Type resize_type) override;
// Handles press behavior for `add_new_task_button_`.
void AddNewTaskButtonPressed();
// Creates a `GlanceablesTaskView` instance with bound callbacks.
std::unique_ptr<GlanceablesTaskView> CreateTaskView(
const std::string& task_list_id,
const api::Task* task);
// Handles switching between tasks lists.
void ScheduleUpdateTasks(ListShownContext context);
void RetryUpdateTasks(ListShownContext context);
void UpdateTasksInTaskList(
const std::string& task_list_id,
const std::string& task_list_title,
ListShownContext context,
bool fetch_success,
std::optional<google_apis::ApiErrorCode> http_error,
const ui::ListModel<api::Task>* tasks);
// Called as a `state_change_callback` when a task view state changes between
// "view" and "edit" state, which causes changes in the task view preferred
// size. `view_expanding` indicates whether the task view is expanding or
// collapsing in size.
void HandleTaskViewStateChange(bool view_expanding);
// Marks the specified task as completed.
void MarkTaskAsCompleted(const std::string& task_list_id,
const std::string& task_id,
bool completed);
// Handles press behavior for icons that are used to open Google Tasks in the
// browser.
void ActionButtonPressed(TasksLaunchSource source, const GURL& target_url);
// Saves the task (either creates or updates the existing one).
// `view` - individual task view which triggered this request.
// `callback` - done callback passed from an individual task view.
void SaveTask(const std::string& task_list_id,
base::WeakPtr<GlanceablesTaskView> view,
const std::string& task_id,
const std::string& title,
api::TasksClient::OnTaskSavedCallback callback);
// Handles completion of `SaveTask`.
// `view` - individual task view which triggered this request.
// `callback` - callback passed from an individual task view via `SaveTask`.
// `task` - newly created or edited task if the request completes
// successfully, `nullptr` otherwise.
void OnTaskSaved(base::WeakPtr<GlanceablesTaskView> view,
const std::string& task_id,
api::TasksClient::OnTaskSavedCallback callback,
google_apis::ApiErrorCode http_error,
const api::Task* task);
// Returns the current showing task list.
const api::TaskList* GetActiveTaskList() const;
// Creates and shows `error_message_` that depends on the `error_type` and
// `button_action_type`.
void ShowErrorMessageWithType(
GlanceablesTasksErrorType error_type,
ErrorMessageToast::ButtonActionType button_action_type);
// Returns the string to show on `error_message_` according to the
// `error_type`.
std::u16string GetErrorString(GlanceablesTasksErrorType error_type) const;
// Removes `task_view` from the tasks container.
void RemoveTaskView(base::WeakPtr<GlanceablesTaskView> task_view);
// This function should be called with `is_loading` = true if `this` is
// waiting for fetched data to be returned. After the data arrives, resets the
// states by calling with `is_loading` = false.
void SetIsLoading(bool is_loading);
// Animates visibility updates for a task view. It assumes that at most one
// task view changes visibility at the time - currently, this is exclusively
// used for task view added to the list in response to the user clicking the
// button to add a new task.
// When hiding/removing the task view, a copy of the task view layer will
// be created for the animation, so the view can be hidden/removed
// immediately.
void AnimateTaskViewVisibility(views::View* task, bool visible);
void OnTaskViewAnimationCompleted();
// Caching `combobox_model_` from GlanceablesTimeManagementBubbleView.
raw_ptr<GlanceablesTasksComboboxModel> tasks_combobox_model_;
// The number of times that the tasks list has been changed during the
// lifetime of this view.
int tasks_list_change_count_ = 0;
// Whether the first task list has been shown during the lifetime of this
// view.
bool first_task_list_shown_ = false;
// Owned by views hierarchy.
raw_ptr<views::LabelButton> add_new_task_button_ = nullptr;
// An invisible view added at the last element to the task list container to
// more easily track the offset of the bottom of the list from the target
// position mid task view state change animations. The transform will be used
// to synchronize `resize_animation_` with task view resize / task list layout
// animations - if the sentinel, i.e. the bottom of the task list is
// animating, the bubble preferred size will be "offset" by the sentinel
// transform so the bottom of the bubble tracks the bottom of the task list
// (otherwise, if the animations get slightly out of sync, animating task
// views may appear to jitter as their bottom padding changes slightly).
raw_ptr<views::View> task_list_sentinel_ = nullptr;
// Copy of a task view whose visibility is animating to "hidden". The copy
// of the layer is used so the original view can be removed from the view
// hierarchy immediately.
std::unique_ptr<ui::Layer> animating_task_view_layer_;
// The type of resize animation that is currently running.
std::optional<ResizeAnimation::Type> running_resize_animation_ = std::nullopt;
// Records the time when the bubble was about to request a task list. Used for
// metrics.
base::TimeTicks tasks_requested_time_;
// Cached to reset the value of the index of `task_list_combo_box_view_` when
// the target task list failed to be loaded.
std::optional<size_t> cached_selected_list_index_ = std::nullopt;
// Number of tasks added by the user for the currently selected task list.
// Task is considered "added" if task creation was requested via tasks API.
// The count is reset when the selected task list changes.
int added_tasks_ = 0;
// Whether the current task list was empty when it got selected.
bool task_list_initially_empty_ = false;
// Whether the user had a single task list with no tasks when the current task
// list was selected.
bool user_with_no_tasks_ = false;
// Time stamp of when the view was created.
const base::Time shown_time_;
// The model containing task views shown within the tasks bubble. Used to set
// up task view animations in response to a task view change. When animating
// task views, their transform is calculated relative to expected view bounds
// after an imminent layout. The reference/target bounds for the animation
// are cached as view ideal bounds in the model, so the transform can be
// recalculated if another task view state changes before the task list view
// layout gets updated (e.g. if the same user action causes once view to
// transition to kEdit, and another one to kView state).
views::ViewModelT<views::View> task_view_model_;
// Callback that recreates `task_list_combo_box_view_`.
base::OnceClosure recreate_combobox_callback_;
base::WeakPtrFactory<GlanceablesTasksView> weak_ptr_factory_{this};
};
} // namespace ash
#endif // ASH_GLANCEABLES_TASKS_GLANCEABLES_TASKS_VIEW_H_
Codebase Browser
chromium