// 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_GAME_DASHBOARD_GAME_DASHBOARD_CONTEXT_H_
#define ASH_GAME_DASHBOARD_GAME_DASHBOARD_CONTEXT_H_
#include <memory>
#include <string>
#include "ash/ash_export.h"
#include "ash/game_dashboard/game_dashboard_metrics.h"
#include "ash/wm/window_state_observer.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/timer/timer.h"
#include "ui/events/event_handler.h"
#include "ui/views/view_observer.h"
#include "ui/views/widget/unique_widget_ptr.h"
namespace aura {
class Window;
} // namespace aura
namespace views {
class Widget;
} // namespace views
namespace ash {
class GameDashboardButton;
class GameDashboardButtonRevealController;
class GameDashboardMainMenuCursorHandler;
class GameDashboardMainMenuView;
class GameDashboardToolbarView;
// This class manages Game Dashboard related UI for a given `aura::Window`, and
// its instance is managed by the `GameDashboardController`.
class ASH_EXPORT GameDashboardContext : public ui::EventHandler,
public views::ViewObserver,
public views::WidgetObserver,
public WindowStateObserver {
public:
explicit GameDashboardContext(aura::Window* game_window);
GameDashboardContext(const GameDashboardContext&) = delete;
GameDashboardContext& operator=(const GameDashboardContext&) = delete;
~GameDashboardContext() override;
aura::Window* game_window() { return game_window_.get(); }
const std::string& app_id() const { return app_id_; }
GameDashboardMainMenuView* main_menu_view() { return main_menu_view_; }
base::WeakPtr<GameDashboardContext> GetWeakPtr() {
return weak_ptr_factory_.GetWeakPtr();
}
views::Widget* game_dashboard_button_widget() {
return game_dashboard_button_widget_.get();
}
GameDashboardToolbarSnapLocation toolbar_snap_location() const {
return toolbar_snap_location_;
}
void set_recording_from_main_menu(bool from_main_menu) {
recording_from_main_menu_ = from_main_menu;
}
// Returns true if the main menu is opened. `main_menu_widget_` is created
// only when the main menu is opened, otherwise it's null.
bool IsMainMenuOpen() const { return main_menu_widget_.get(); }
const std::u16string& GetRecordingDuration() const;
// Initializes the context. Creates and starts showing the Game Dashboard
// button. Also shows the welcome dialog, if
// `prefs::kGameDashboardShowWelcomeDialog` is true. Separating this logic
// ensures the constructor never references the context created before the
// instance is assigned. Note that this logic should be called once the
// context is created.
void Initialize();
// Stacks Game Dashboard UI widgets above `widget` if it is needed.
void MaybeStackAboveWidget(views::Widget* widget);
// Enables the Game Dashboard widgets' UI visibility if `enable` is true.
// Otherwise, hides the widgets, and uses `main_menu_toggle_method` to
// conditionally hide the toolbar.
void EnableFeatures(
bool enable,
GameDashboardMainMenuToggleMethod main_menu_toggle_method);
// Reassigns the new `toolbar_snap_location_` and performs an animation as the
// toolbar moves to its new location.
void SetGameDashboardToolbarSnapLocation(
GameDashboardToolbarSnapLocation new_location);
// Called by `GameDashboardController` when the game window bounds change.
// `from_animation` is true when window bounds are changing due to an
// animation.
void OnWindowBoundsChanged(bool from_animation);
// Updates for Game Controls flags.
void UpdateForGameControlsFlags();
// Toggles the creation/deletion of the main menu within the game window.
void ToggleMainMenuByAccelerator();
void ToggleMainMenu(GameDashboardMainMenuToggleMethod toggle_method);
// Closes the main menu. Clears `main_menu_widget_` and `main_menu_view_`.
void CloseMainMenu(GameDashboardMainMenuToggleMethod toggle_method);
// Toggles the creation/deletion of the toolbar within the game window.
// Returns the toolbar visibility state.
bool ToggleToolbar();
// Closes the toolbar. Clears `toolbar_widget_` and `toolbar_view_`.
void CloseToolbar();
// Conditionally, updates the toolbar widget's bounds and location, relative
// to the `game_window_`.
void MaybeUpdateToolbarWidgetBounds();
bool IsToolbarVisible() const;
// Returns the toolbar bounds if `IsToolbarVisible`, otherwise an empty rect.
gfx::Rect GetToolbarBoundsInScreen() const;
// Called only when `CaptureModeController` has started a recording session.
// If `is_recording_game_window` is true, then the recording session was
// initiated by the Game Dashboard and the `game_window_` is being recorded.
void OnRecordingStarted(bool is_recording_game_window);
// Called only when `CaptureModeController` has ended a recording session or
// if the recording session was aborted.
void OnRecordingEnded();
// Called when a recorded file has been finalized and fully saved, at which
// point a new recording is allowed to be started.
void OnVideoFileFinalized();
// Controls the Game Dashboard Button visibility.
void SetGameDashboardButtonVisibility(bool visible);
// Controls the Toolbar widget visibility.
void SetToolbarVisibility(bool visible);
// Conditionally, adds this context to the pre-target handler if it hasn't
// already been added.
void MaybeAddPreTargetHandler();
// Conditionally, removes this context from the pre-target handler if it
// hasn't already been removed.
void MaybeRemovePreTargetHandler();
// ui::EventHandler:
void OnEvent(ui::Event* event) override;
// views::ViewObserver:
void OnViewPreferredSizeChanged(views::View* observed_view) override;
// views::WidgetObserver:
void OnWidgetDestroyed(views::Widget* widget) override;
// WindowStateObserver:
void OnPreWindowStateTypeChange(WindowState* window_state,
chromeos::WindowStateType old_type) override;
void OnPostWindowStateTypeChange(WindowState* window_state,
chromeos::WindowStateType old_type) override;
private:
friend class GameDashboardContextTestApi;
// Registers a pretarget handler to always show the mouse cursor. Called when
// the user opens the main menu.
void AddCursorHandler();
// Unregisters the pretarget handler that always shows the mouse cursor.
// Called when the user closes the main menu.
void RemoveCursorHandler();
// Creates a Game Dashboard button widget and adds it as a sibling of the game
// window.
void CreateAndAddGameDashboardButtonWidget();
// Updates the Game Dashboard button widget's bounds and location, relative to
// the `game_window_`.
void UpdateGameDashboardButtonWidgetBounds();
// Called when `GameDashboardButton` is pressed, and toggles the main menu.
void OnGameDashboardButtonPressed();
// Shows the Game Dashboard welcome dialog, if it's enabled in the Game
// Dashboard settings.
void MaybeShowWelcomeDialog();
// Updates the Game Dashboard welcome dialog's bounds and location, relative
// to the `game_window_`.
void MaybeUpdateWelcomeDialogBounds();
// Determines the toolbar's physical location on screen based on the
// `toolbar_snap_location_` value.
const gfx::Rect CalculateToolbarWidgetBounds();
// Updates the toolbar widget's bounds and location utilizing an animation as
// it transfers from the previous location.
void AnimateToolbarWidgetBoundsChange(const gfx::Rect& target_screen_bounds);
// Shows the Game Dashboard toolbar if `prefs::kGameDashboardShowToolbar` is
// true.
void MaybeShowToolbar();
// Repeating timer callback that notifies `main_menu_view_` of the video
// recording session duration.
void OnUpdateRecordingTimer();
// Closes and deletes the Game Dashboard welcome dialog. After closing the
// dialog, if `show_toolbar` is true, call `MaybeShowToolbar`.
void CloseWelcomeDialogIfAny(bool show_toolbar = true);
// Callback when the `GameDashboardWelcomeDialog`'s timer has completed.
void OnWelcomeDialogTimerCompleted();
// Resets the `main_menu_view_`, removes the cursor handler, and updates the
// `game_dashboard_button_` UI.
void UpdateOnMainMenuClosed();
// Ensures that the main menu stacks above the toolbar.
void EnsureMainMenuAboveToolbar();
// Determines whether it's required to tab navigate from one Game Dashboard
// widget to another widget. Returns false if tab-navigating within the same
// widget.
bool ShouldNavigateToNewWidget(const ui::KeyEvent* event) const;
// Returns a list of visible Game Dashboard widgets that are available to be
// traversed.
std::vector<views::Widget*> GetTraversableWidgets() const;
// Manually moves focus to the `new_widget`. If `reverse` is true, focus will
// move backwards.
void MoveFocus(views::Widget* new_widget, ui::Event* event, bool reverse);
const raw_ptr<aura::Window> game_window_;
const std::string app_id_;
// Game Dashboard button widget for the Game Dashboard.
std::unique_ptr<views::Widget> game_dashboard_button_widget_;
// Delegate responsible for determining when to show/hide the Game Dashboard
// button when `game_window_` is in fullscreen. This a temporary scoped
// object that is around while `game_window_` is fullscreen.
std::unique_ptr<GameDashboardButtonRevealController>
game_dashboard_button_reveal_controller_;
// Expanded main menu for the Game Dashboard, which displays the main menu and
// the settings view.
views::UniqueWidgetPtr main_menu_widget_;
// The toolbar for the Game Dashboard.
std::unique_ptr<views::Widget> toolbar_widget_;
// The dialog displayed when the game window first opens.
std::unique_ptr<views::Widget> welcome_dialog_widget_;
// The indicator of the current corner that the toolbar is placed.
GameDashboardToolbarSnapLocation toolbar_snap_location_;
// The `GameDashboardButton` view in the `game_dashboard_button_widget_`.
// Owned by the views hierarchy.
raw_ptr<GameDashboardButton> game_dashboard_button_ = nullptr;
// The `GameDashboardMainMenuView` when the user presses the Game Dashboard
// button to display all Game Dashboard views. This displays the main menu and
// settings views. Owned by the views hierarchy.
raw_ptr<GameDashboardMainMenuView, DanglingUntriaged> main_menu_view_ =
nullptr;
// The `GameDashboardToolbarView` when the user makes the toolbar visible.
// Owned by the views hierarchy.
raw_ptr<GameDashboardToolbarView> toolbar_view_ = nullptr;
// Handles cursor management when the main menu is open.
std::unique_ptr<GameDashboardMainMenuCursorHandler> main_menu_cursor_handler_;
// A repeating timer to keep track of the recording session duration.
base::RepeatingTimer recording_timer_;
// Start time of when `recording_timer_` started.
base::Time recording_start_time_;
// Duration since `recording_timer_` started.
std::u16string recording_duration_;
// Indicates whether the Game Dashboard welcome dialog should be shown. This
// param ensures the welcome dialog is only shown once per game window
// startup.
bool show_welcome_dialog_ = false;
// Indicates where the recording feature starts from the main menu. It is
// false if the recording starts from the toolbar. It is null if the recording
// is started from somewhere else.
std::optional<bool> recording_from_main_menu_;
// Indicates whether this context has been added as a Shell's pre-target
// handler. This param ensures this context isn't added as a pre-target
// handler multiple times.
bool added_to_pre_target_handler_ = false;
base::ScopedObservation<WindowState, WindowStateObserver>
window_state_observation_{this};
base::WeakPtrFactory<GameDashboardContext> weak_ptr_factory_{this};
};
} // namespace ash
#endif // ASH_GAME_DASHBOARD_GAME_DASHBOARD_CONTEXT_H_
Codebase Browser
chromium