// Copyright 2022 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_SYSTEM_VIDEO_CONFERENCE_VIDEO_CONFERENCE_TRAY_CONTROLLER_H_
#define ASH_SYSTEM_VIDEO_CONFERENCE_VIDEO_CONFERENCE_TRAY_CONTROLLER_H_
#include "ash/ash_export.h"
#include "ash/public/cpp/session/session_observer.h"
#include "ash/shelf/shelf.h"
#include "ash/shell_observer.h"
#include "ash/system/video_conference/effects/video_conference_tray_effects_manager.h"
#include "ash/system/video_conference/video_conference_common.h"
#include "base/observer_list_types.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "chromeos/ash/components/audio/cras_audio_handler.h"
#include "chromeos/crosapi/mojom/video_conference.mojom-forward.h"
#include "components/prefs/pref_registry_simple.h"
#include "media/capture/video/chromeos/camera_hal_dispatcher_impl.h"
namespace base {
class UnguessableToken;
} // namespace base
namespace ash {
struct AnchoredNudgeData;
class VideoConferenceTray;
using MediaApps = std::vector<crosapi::mojom::VideoConferenceMediaAppInfoPtr>;
// Controller that will act as a "bridge" between VC apps management and the VC
// UI layers. The singleton instance is constructed immediately before and
// destructed immediately after the UI, so any code that keeps a reference to
// it must be prepared to accommodate this specific lifetime in order to prevent
// any use-after-free bugs.
class ASH_EXPORT VideoConferenceTrayController
: public media::CameraPrivacySwitchObserver,
public CrasAudioHandler::AudioObserver,
public SessionObserver,
public ShellObserver {
public:
class Observer : public base::CheckedObserver {
public:
~Observer() override = default;
// Called when the state of `has_media_app` within
// `VideoConferenceMediaState` is changed.
virtual void OnHasMediaAppStateChange() = 0;
// Called when the state of camera permission is changed.
virtual void OnCameraPermissionStateChange() = 0;
// Called when the state of microphone permission is changed.
virtual void OnMicrophonePermissionStateChange() = 0;
// Called when the state of camera capturing is changed.
virtual void OnCameraCapturingStateChange(bool is_capturing) = 0;
// Called when the state of microphone capturing is changed.
virtual void OnMicrophoneCapturingStateChange(bool is_capturing) = 0;
// Called when the state of screen sharing is changed.
virtual void OnScreenSharingStateChange(bool is_capturing_screen) = 0;
// Called when the Dlc download state is changed for `feature_tile_title` if
// any DLC was registered for that effect.
virtual void OnDlcDownloadStateChanged(
bool error,
const std::u16string& feature_tile_title) = 0;
};
VideoConferenceTrayController();
VideoConferenceTrayController(const VideoConferenceTrayController&) = delete;
VideoConferenceTrayController& operator=(
const VideoConferenceTrayController&) = delete;
~VideoConferenceTrayController() override;
// Called inside ash/ash_prefs.cc to register related prefs.
static void RegisterProfilePrefs(PrefRegistrySimple* registry);
// Returns the singleton instance.
static VideoConferenceTrayController* Get();
// Adds this class as an observer for CrasAudioHandler and
// CameraHalDispatcherImpl.
// (1) We should not call this in /ash/system/* tests, because we are not
// using FakeCrasAudioClient or MockCameraHalServer. Currently, we directly
// mock the VideoConferenceTrayButtons inside
// FakeVideoConferenceTrayController; which is a simpler approach.
// (2) We need this initialization in
// ChromeBrowserMainExtraPartsAsh::PreProfileInit for production code.
void Initialize(VideoConferenceManagerBase* video_conference_manager);
// Observer functions.
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
// Whether the tray should be shown.
bool ShouldShowTray() const;
// Caches a nudge data object for nudges that attempt to show while the tray
// is animating in, so they only show once the tray animation has ended. The
// request will be run immediately if the tray is not animating.
void CreateNudgeRequest(std::unique_ptr<AnchoredNudgeData> nudge_data);
// Shows the cached `requested_nudge_data_` object, if one exists.
void MaybeRunNudgeRequest();
// Attempts showing the speak-on-mute opt-in nudge.
void MaybeShowSpeakOnMuteOptInNudge();
// Returns true if we can show the animation to help users to discover the new
// feature.
bool ShouldShowImageButtonAnimation() const;
bool ShouldShowCreateWithAiButtonAnimation() const;
// Disables showing the animation for the button from now on. Calling the
// above ShouldShow...() will return false for the current active user going
// forward.
void DismissImageButtonAnimationForever();
void DismissCreateWithAiButtonAnimationForever();
// Callback used to update prefs whenever a user opts in or out of the
// speak-on-mute feature. An `opt_in` value of false means the user opted out.
void OnSpeakOnMuteNudgeOptInAction(bool opt_in);
void OnDlcDownloadStateFetched(bool add_warning,
const std::u16string& feature_tile_title);
// Closes all nudges that are shown anchored to the VC tray, if any.
void CloseAllVcNudges();
// Returns whether `state_` indicates permissions are granted for different
// mediums.
bool GetHasCameraPermissions() const;
bool GetHasMicrophonePermissions() const;
// Returns whether `state_` indicates a capture session is in progress for
// different mediums.
bool IsCapturingScreen() const;
bool IsCapturingCamera() const;
bool IsCapturingMicrophone() const;
// Sets the state for camera mute. Virtual for testing/mocking.
virtual void SetCameraMuted(bool muted);
// Gets the state for camera mute. Virtual for testing/mocking.
virtual bool GetCameraMuted();
// Sets the state for microphone mute. Virtual for testing/mocking.
virtual void SetMicrophoneMuted(bool muted);
// Gets the state for microphone mute. Virtual for testing/mocking.
virtual bool GetMicrophoneMuted();
// Stops all screen sharing. Virtual for testing/mocking.
virtual void StopAllScreenShare();
// Returns asynchronously a vector of media apps that will be displayed in the
// "Return to app" panel of the bubble. Virtual for testing/mocking.
virtual void GetMediaApps(base::OnceCallback<void(MediaApps)> ui_callback);
// Brings the app with the given `id` to the foreground.
virtual void ReturnToApp(const base::UnguessableToken& id);
// Updates the tray UI with the given `VideoConferenceMediaState`.
void UpdateWithMediaState(VideoConferenceMediaState state);
// Returns true if any running media apps have been granted permission for
// camera/microphone.
bool HasCameraPermission() const;
bool HasMicrophonePermission() const;
// Enable or disable input stream ewma power report.
void SetEwmaPowerReportEnabled(bool enabled);
// Return the last reported ewma power.
double GetEwmaPower();
// Enable or disable sidetone.
void SetSidetoneEnabled(bool enabled);
// Gets the state for sidetone.
bool GetSidetoneEnabled() const;
// Gets whether sidetone is supported.
bool IsSidetoneSupported() const;
// Update the sidetone supported value.
// Should be called before calling IsSidetoneSupported.
void UpdateSidetoneSupportedState();
// Handles device usage from a VC app while the device is system disabled.
virtual void HandleDeviceUsedWhileDisabled(
crosapi::mojom::VideoConferenceMediaDevice device,
const std::u16string& app_name);
// media::CameraPrivacySwitchObserver:
void OnCameraHWPrivacySwitchStateChanged(
const std::string& device_id,
cros::mojom::CameraPrivacySwitchState state) override;
void OnCameraSWPrivacySwitchStateChanged(
cros::mojom::CameraPrivacySwitchState state) override;
// CrasAudioHandler::AudioObserver:
void OnInputMuteChanged(
bool mute_on,
CrasAudioHandler::InputMuteChangeMethod method) override;
// CrasAudioHandler::AudioObserver:
// Pop up a toast when speaking on mute is detected.
void OnSpeakOnMuteDetected() override;
// SessionObserver:
void OnUserSessionAdded(const AccountId& account_id) override;
// ShellObserver:
void OnShellDestroying() override;
// Handles client updates such as a change of title or addition / removal of a
// VC app. Virtual to allow mock classes to override for testing.
virtual void HandleClientUpdate(
crosapi::mojom::VideoConferenceClientUpdatePtr update);
// Handles showing the shelf when a new app is added.
void OnAppAdded();
// Gets `disable_shelf_autohide_timer_`, used for testing.
base::OneShotTimer& GetShelfAutoHideTimerForTest();
virtual VideoConferenceTrayEffectsManager& GetEffectsManager();
// Passes create background image action to `video_conference_manager_`.
void CreateBackgroundImage();
bool camera_muted_by_hardware_switch() const {
return camera_muted_by_hardware_switch_;
}
bool camera_muted_by_software_switch() const {
return camera_muted_by_software_switch_;
}
bool initialized() const { return initialized_; }
private:
// All the types of the use while disabled nudge.
enum class UsedWhileDisabledNudgeType {
kCamera = 0,
kMicrophone = 1,
kBoth = 2,
kMaxValue = kBoth
};
// Updates the state of the camera icons across all `VideoConferenceTray`.
void UpdateCameraIcons();
// Records repeated shows metric when the timer is stop.
void RecordRepeatedShows();
// Returns true if any of the VC nudges are visible on screen.
bool IsAnyVcNudgeShown();
// Displays the use while disabled nudge according to the given `type`.
void DisplayUsedWhileDisabledNudge(UsedWhileDisabledNudgeType type,
const std::u16string& app_name);
UsedWhileDisabledNudgeType GetUsedWhileDisabledNudgeType(
crosapi::mojom::VideoConferenceMediaDevice device);
// This keeps track the current VC media state. The state is being updated by
// `UpdateWithMediaState()`, calling from `VideoConferenceManagerAsh`.
VideoConferenceMediaState state_;
// This keeps track of the current Camera Privacy Switch state.
// Updated via `OnCameraHWPrivacySwitchStateChanged()` and
// `OnCameraSWPrivacySwitchStateChanged()` Fetching this would otherwise take
// an asynchronous call to `media::CameraHalDispatcherImpl`.
bool camera_muted_by_hardware_switch_ = false;
bool camera_muted_by_software_switch_ = false;
// True if microphone is muted by the hardware switch, false if the microphone
// is muted through software. If the microphone is not muted, disregards this
// value.
bool microphone_muted_by_hardware_switch_ = false;
// Timer responsible for hiding the shelf after it has been shown to alert the
// user of a new app accessing the sensors.
base::OneShotTimer disable_shelf_autohide_timer_;
// List of locks which force the shelf to show, if the shelf is autohidden.
std::list<Shelf::ScopedDisableAutoHide> disable_shelf_autohide_locks_;
// Used by the views to construct and lay out effects in the bubble.
VideoConferenceTrayEffectsManager effects_manager_;
// Registered observers.
base::ObserverList<Observer> observer_list_;
// The last time speak-on-mute nudge shown.
// The cool down periods for nudges:
// 1. No cool down for the first nudge,
// 2. 2 mins for the second nudge,
// 3. 4 mins for the third nudge,
// 4. 8 mins for the forth nudge.
base::TimeTicks last_speak_on_mute_nudge_shown_time_;
// The counter of how many time the speak-on-mute nudge has shown in the
// current session.
int speak_on_mute_nudge_shown_count_ = 0;
// `video_conference_manager_` should be valid after `initialized_`.
// Currently, `VideoConferenceTrayController` is destroyed inside
// `ChromeBrowserMainParts::PostMainMessageLoopRun()` as a chrome_extra_part;
// `VideoConferenceManagerAsh` is destroyed inside crosapi_manager_.reset()
// which is after `VideoConferenceTrayController`.
raw_ptr<VideoConferenceManagerBase> video_conference_manager_ = nullptr;
bool initialized_ = false;
// Used to record metrics of repeated shows per 100 ms.
int count_repeated_shows_ = 0;
base::DelayTimer repeated_shows_timer_;
// Due to some constraint in `VideoConferenceManagerAsh`, when both microphone
// and camera is being accessed when disabled,`HandleDeviceUsedWhileDisabled`
// will be called twice for each device. Thus, we need to wait for both 2
// calls and display one nudge for both. These are the timer and the cache
// type to make that happen.
base::OneShotTimer use_while_disabled_signal_waiter_;
UsedWhileDisabledNudgeType use_while_disabled_nudge_on_wait_;
// The contents of a nudge data object that is cached so it can be shown once
// the tray has fully animated in.
std::unique_ptr<AnchoredNudgeData> requested_nudge_data_;
base::WeakPtrFactory<VideoConferenceTrayController> weak_ptr_factory_{this};
};
} // namespace ash
#endif // ASH_SYSTEM_VIDEO_CONFERENCE_VIDEO_CONFERENCE_TRAY_CONTROLLER_H_
Codebase Browser
chromium