1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_MEDIA_ACTIVE_MEDIA_SESSION_CONTROLLER_H_
#define CONTENT_BROWSER_MEDIA_ACTIVE_MEDIA_SESSION_CONTROLLER_H_
#include <optional>
#include <utility>
#include <vector>
#include "base/containers/flat_set.h"
#include "base/unguessable_token.h"
#include "content/common/content_export.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "services/media_session/public/mojom/media_controller.mojom.h"
#include "ui/base/accelerators/media_keys_listener.h"
#include "ui/events/keycodes/keyboard_codes.h"
namespace content {
// Used by the system media controls to intake media events (such as media key
// presses or click events from the OS) and control a media session.
class CONTENT_EXPORT ActiveMediaSessionController
: public media_session::mojom::MediaControllerObserver,
public ui::MediaKeysListener::Delegate {
public:
// When `request_id` is non-null, creates a controller for that specific media
// session. Used for dPWAs to control each app's media session individually.
// When `request_id` is null, creates a controller that automatically follows
// and controls the "active" session. Used for the browser's media sessions,
// and all scenarios where kWebAppSystemMediaControls is NOT supported - Linux
// always, and macOS/Windows when the feature flag is off.
explicit ActiveMediaSessionController(base::UnguessableToken request_id);
ActiveMediaSessionController(const ActiveMediaSessionController&) = delete;
ActiveMediaSessionController& operator=(const ActiveMediaSessionController&) =
delete;
~ActiveMediaSessionController() override;
// media_session::mojom::MediaControllerObserver:
void MediaSessionInfoChanged(
media_session::mojom::MediaSessionInfoPtr session_info) override;
void MediaSessionMetadataChanged(
const std::optional<media_session::MediaMetadata>& metadata) override {}
void MediaSessionActionsChanged(
const std::vector<media_session::mojom::MediaSessionAction>& actions)
override;
void MediaSessionChanged(
const std::optional<base::UnguessableToken>& request_id) override {}
void MediaSessionPositionChanged(
const std::optional<media_session::MediaPosition>& position) override;
// ui::MediaKeysListener::Delegate:
void OnMediaKeysAccelerator(const ui::Accelerator& accelerator) override;
// Receives OS events from the SystemMediaControls.
void OnNext();
void OnPrevious();
void OnPlay();
void OnPause();
void OnPlayPause();
void OnStop();
void OnSeek(const base::TimeDelta& time);
void OnSeekTo(const base::TimeDelta& time);
void FlushForTesting();
void SetMediaControllerForTesting(
mojo::Remote<media_session::mojom::MediaController> controller) {
media_controller_remote_ = std::move(controller);
}
private:
// Used for converting between MediaSessionAction and KeyboardCode.
media_session::mojom::MediaSessionAction KeyCodeToMediaSessionAction(
ui::KeyboardCode key_code) const;
// Returns nullopt if the action is not supported via hardware keys (e.g.
// SeekBackward).
std::optional<ui::KeyboardCode> MediaSessionActionToKeyCode(
media_session::mojom::MediaSessionAction action) const;
void MaybePerformAction(media_session::mojom::MediaSessionAction action);
bool SupportsAction(media_session::mojom::MediaSessionAction action) const;
void PerformAction(media_session::mojom::MediaSessionAction action);
// Used to create the media controller.
mojo::Remote<media_session::mojom::MediaControllerManager>
controller_manager_remote_;
// Used to control the media session.
mojo::Remote<media_session::mojom::MediaController> media_controller_remote_;
// Used to check whether a play/pause key should play or pause (based on
// current playback state).
media_session::mojom::MediaSessionInfoPtr session_info_;
// Used to check which actions are currently supported.
base::flat_set<media_session::mojom::MediaSessionAction> actions_;
// Used to receive updates from the media session.
mojo::Receiver<media_session::mojom::MediaControllerObserver>
media_controller_observer_receiver_{this};
// Stores the current playback position.
std::optional<media_session::MediaPosition> position_;
// Stores the media session (if any) this active media session controller is
// associated with.
// Null if this controller was created to automatically follow and control
// the "active" session.
base::UnguessableToken request_id_;
};
} // namespace content
#endif // CONTENT_BROWSER_MEDIA_ACTIVE_MEDIA_SESSION_CONTROLLER_H_
|
