ash / game_dashboard / game_dashboard_controller.h [blame]

// 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_CONTROLLER_H_
#define ASH_GAME_DASHBOARD_GAME_DASHBOARD_CONTROLLER_H_

#include <map>
#include <memory>

#include "ash/ash_export.h"
#include "ash/capture_mode/capture_mode_observer.h"
#include "ash/game_dashboard/game_dashboard_context.h"
#include "ash/game_dashboard/game_dashboard_delegate.h"
#include "ash/game_dashboard/game_dashboard_metrics.h"
#include "ash/wm/overview/overview_observer.h"
#include "base/scoped_multi_source_observation.h"
#include "base/scoped_observation.h"
#include "ui/aura/env.h"
#include "ui/aura/env_observer.h"
#include "ui/aura/window_observer.h"
#include "ui/display/display_observer.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/wm/public/activation_change_observer.h"

class PrefRegistrySimple;

namespace aura {
class Window;
class WindowTracker;
}  // namespace aura

namespace display {
enum class TabletState;
}  // namespace display

namespace ash {

// Controls the Game Dashboard behavior on supported windows.
class ASH_EXPORT GameDashboardController : public aura::EnvObserver,
                                           public aura::WindowObserver,
                                           public CaptureModeObserver,
                                           public display::DisplayObserver,
                                           public OverviewObserver,
                                           public wm::ActivationChangeObserver {
 public:
  explicit GameDashboardController(
      std::unique_ptr<GameDashboardDelegate> delegate);
  GameDashboardController(const GameDashboardController&) = delete;
  GameDashboardController& operator=(const GameDashboardController&) = delete;
  ~GameDashboardController() override;

  // Returns the singleton instance owned by `Shell`.
  static GameDashboardController* Get();

  // Checks whether the `window` is a game.
  static bool IsGameWindow(aura::Window* window);

  // Checks whether the `window` can respond to accelerator commands.
  static bool ReadyForAccelerator(aura::Window* window);

  // Registers preferences used by this class in the provided `registry`.
  static void RegisterProfilePrefs(PrefRegistrySimple* registry);

  // Gets the app name by `app_id`.
  std::string GetArcAppName(const std::string& app_id) const;

  GameDashboardContext* active_recording_context() {
    return active_recording_context_;
  }

  // Returns a pointer to the `GameDashboardContext` if the given `window` is a
  // game window, otherwise nullptr.
  GameDashboardContext* GetGameDashboardContext(aura::Window* window) const;

  // Stacks all of the `window`'s Game Dashboard widgets on top of `widget`.
  void MaybeStackAboveWidget(aura::Window* window, views::Widget* widget);

  // Represents the start of the `context`'s game window capture session.
  // Sets `context` as the `active_recording_context_`, and requests
  // `CaptureModeController` to start a capture session for the `context`'s game
  // window. The session ends when `OnRecordingEnded` or
  // `OnRecordingStartAborted` is called.
  void StartCaptureSession(GameDashboardContext* context);

  // Shows the compat mode resize toggle menu for the given `window`.
  void ShowResizeToggleMenu(aura::Window* window);

  // Gets the UKM source id by `app_id`.
  ukm::SourceId GetUkmSourceId(const std::string& app_id) const;

  // aura::EnvObserver:
  void OnWindowInitialized(aura::Window* new_window) override;

  // aura::WindowObserver:
  void OnWindowPropertyChanged(aura::Window* window,
                               const void* key,
                               intptr_t old) override;
  void OnWindowParentChanged(aura::Window* window,
                             aura::Window* parent) override;
  void OnWindowBoundsChanged(aura::Window* window,
                             const gfx::Rect& old_bounds,
                             const gfx::Rect& new_bounds,
                             ui::PropertyChangeReason reason) override;
  void OnWindowDestroying(aura::Window* window) override;
  void OnWindowTransformed(aura::Window* window,
                           ui::PropertyChangeReason reason) override;

  // CaptureModeObserver:
  void OnRecordingStarted(aura::Window* current_root) override;
  void OnRecordingEnded() override;
  void OnVideoFileFinalized(bool user_deleted_video_file,
                            const gfx::ImageSkia& thumbnail) override;
  void OnRecordedWindowChangingRoot(aura::Window* new_root) override;
  void OnRecordingStartAborted() override;

  // display::DisplayObserver:
  void OnDisplayTabletStateChanged(display::TabletState state) override;

  // OverviewObserver:
  void OnOverviewModeWillStart() override;
  void OnOverviewModeEnded() override;

  // wm::ActivationChangeObserver:
  void OnWindowActivated(wm::ActivationChangeObserver::ActivationReason reason,
                         aura::Window* gained_active,
                         aura::Window* lost_active) override;

 private:
  friend class GameDashboardControllerTest;
  friend class GameDashboardTestBase;

  enum class WindowGameState { kGame, kNotGame, kNotYetKnown };

  using GetWindowStateCallback = base::OnceCallback<void(WindowGameState)>;

  // Creates a `GameDashboardContext` for the given `window` and
  // adds it to `game_window_contexts_`, if `GameDashboardContext` doesn't
  // exist, the given window is a game, the `window` is parented, and the
  // `window` has a valid `WindowState`. Otherwise, no object is created.
  void MaybeCreateGameDashboardContext(aura::Window* window);

  // Checks whether the given window is a game, and then calls
  // `RefreshWindowTracking`. If there's not enough information, it passes
  // `kNotYetKnown`, otherwise `kGame` or `kNotGame`, as the `game_state`.
  void GetWindowGameState(aura::Window* window);

  // Callback when `GetWindowGameState` calls `GameDashboardDelegate` to
  // retrieve the app category for the given window in `window_tracker`.
  // This function calls `RefreshWindowTracking`, as long as the window has not
  // been destroyed.
  void OnArcWindowIsGame(std::unique_ptr<aura::WindowTracker> window_tracker,
                         bool is_game);

  // Updates the window observation, dependent on `game_state`.
  void RefreshWindowTracking(aura::Window* window, WindowGameState game_state);

  // Updates the Game Dashboard button state and toolbar for a game window.
  void RefreshForGameControlsFlags(aura::Window* window);

  // Enables or disables feature entry partially depending on `enable`. In
  // addition, it needs to check
  // `game_dashboard_utils::ShouldEnableFeatures()`. It may close main menu
  // by `main_menu_toggle_method` when disabling the features.
  void MaybeEnableFeatures(
      bool enable,
      GameDashboardMainMenuToggleMethod main_menu_toggle_method);

  std::map<aura::Window*, std::unique_ptr<GameDashboardContext>>
      game_window_contexts_;

  // The delegate responsible for communicating with between Ash and the Game
  // Dashboard service in the browser.
  std::unique_ptr<GameDashboardDelegate> delegate_;

  base::ScopedObservation<aura::Env, aura::EnvObserver> env_observation_{this};

  base::ScopedMultiSourceObservation<aura::Window, aura::WindowObserver>
      window_observations_{this};

  display::ScopedDisplayObserver display_observer_{this};

  // Represents the active `GameDashboardContext`. If
  // `active_recording_context_` is non-null, then `CaptureModeController` is
  // recording the game window, or has been requested to record it. Resets
  // when the recording session ends or aborted.
  // Owned by `game_window_contexts_`.
  raw_ptr<GameDashboardContext, DanglingUntriaged> active_recording_context_ =
      nullptr;

  base::WeakPtrFactory<GameDashboardController> weak_ptr_factory_{this};
};

}  // namespace ash

#endif  // ASH_GAME_DASHBOARD_GAME_DASHBOARD_CONTROLLER_H_