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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef DOM_MEDIA_MEDIACONTROL_MEDIACONTROLLER_H_
#define DOM_MEDIA_MEDIACONTROL_MEDIACONTROLLER_H_
#include "MediaEventSource.h"
#include "MediaPlaybackStatus.h"
#include "MediaStatusManager.h"
#include "mozilla/DOMEventTargetHelper.h"
#include "mozilla/dom/MediaControllerBinding.h"
#include "mozilla/dom/MediaSession.h"
#include "mozilla/LinkedList.h"
#include "nsISupportsImpl.h"
#include "nsITimer.h"
namespace mozilla::dom {
class BrowsingContext;
/**
* IMediaController is an interface which includes control related methods and
* methods used to know its playback state.
*/
class IMediaController {
public:
NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
// Focus the window currently playing media.
virtual void Focus() = 0;
virtual void Play() = 0;
virtual void Pause() = 0;
virtual void Stop() = 0;
virtual void PrevTrack() = 0;
virtual void NextTrack() = 0;
virtual void SeekBackward() = 0;
virtual void SeekForward() = 0;
virtual void SkipAd() = 0;
virtual void SeekTo(double aSeekTime, bool aFastSeek) = 0;
// Return the ID of the top level browsing context within a tab.
virtual uint64_t Id() const = 0;
virtual bool IsAudible() const = 0;
virtual bool IsPlaying() const = 0;
virtual bool IsActive() const = 0;
};
/**
* MediaController is a class, which is used to control all media within a tab.
* It can only be used in Chrome process and the controlled media are usually
* in the content process (unless we disable e10s).
*
* Each tab would have only one media controller, they are 1-1 corresponding
* relationship, we use tab's top-level browsing context ID to initialize the
* controller and use that as its ID.
*
* The controller would be activated when its controlled media starts and
* becomes audible. After the controller is activated, then we can use its
* controlling methods, such as `Play()`, `Pause()` to control the media within
* the tab.
*
* If there is at least one controlled media playing in the tab, then we would
* say the controller is `playing`. If there is at least one controlled media is
* playing and audible, then we would say the controller is `audible`.
*
* Note that, if we don't enable audio competition, then we might have multiple
* tabs playing media at the same time, we can use the ID to query the specific
* controller from `MediaControlService`.
*/
class MediaController final : public DOMEventTargetHelper,
public IMediaController,
public LinkedListElement<RefPtr<MediaController>>,
public MediaStatusManager,
public nsITimerCallback,
public nsINamed {
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSITIMERCALLBACK
NS_DECL_NSINAMED
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(MediaController,
DOMEventTargetHelper)
explicit MediaController(uint64_t aBrowsingContextId);
// WebIDL methods
nsISupports* GetParentObject() const;
JSObject* WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) override;
void GetSupportedKeys(nsTArray<MediaControlKey>& aRetVal) const;
void GetMetadata(MediaMetadataInit& aMetadata, ErrorResult& aRv);
IMPL_EVENT_HANDLER(activated);
IMPL_EVENT_HANDLER(deactivated);
IMPL_EVENT_HANDLER(metadatachange);
IMPL_EVENT_HANDLER(supportedkeyschange);
IMPL_EVENT_HANDLER(playbackstatechange);
IMPL_EVENT_HANDLER(positionstatechange);
// IMediaController's methods
void Focus() override;
void Play() override;
void Pause() override;
void Stop() override;
void PrevTrack() override;
void NextTrack() override;
void SeekBackward() override;
void SeekForward() override;
void SkipAd() override;
void SeekTo(double aSeekTime, bool aFastSeek) override;
uint64_t Id() const override;
bool IsAudible() const override;
bool IsPlaying() const override;
bool IsActive() const override;
// IMediaInfoUpdater's methods
void NotifyMediaPlaybackChanged(uint64_t aBrowsingContextId,
MediaPlaybackState aState) override;
void NotifyMediaAudibleChanged(uint64_t aBrowsingContextId,
MediaAudibleState aState) override;
void SetIsInPictureInPictureMode(uint64_t aBrowsingContextId,
bool aIsInPictureInPictureMode) override;
void NotifyMediaFullScreenState(uint64_t aBrowsingContextId,
bool aIsInFullScreen) override;
// Calling this method explicitly would mark this controller as deprecated,
// then calling any its method won't take any effect.
void Shutdown();
// This event would be notified media controller's supported media keys
// change.
MediaEventSource<nsTArray<MediaControlKey>>& SupportedKeysChangedEvent() {
return mSupportedKeysChangedEvent;
}
MediaEventSource<bool>& FullScreenChangedEvent() {
return mFullScreenChangedEvent;
}
MediaEventSource<bool>& PictureInPictureModeChangedEvent() {
return mPictureInPictureModeChangedEvent;
}
CopyableTArray<MediaControlKey> GetSupportedMediaKeys() const;
bool IsBeingUsedInPIPModeOrFullscreen() const;
// These methods are used to select/unselect the media controller as a main
// controller.
void Select() const;
void Unselect() const;
private:
~MediaController();
void HandleActualPlaybackStateChanged();
void UpdateMediaControlActionToContentMediaIfNeeded(
const MediaControlAction& aAction);
void HandleSupportedMediaSessionActionsChanged(
const nsTArray<MediaSessionAction>& aSupportedAction);
void HandlePositionStateChanged(const Maybe<PositionState>& aState);
void HandleMetadataChanged(const MediaMetadataBase& aMetadata);
// This would register controller to the media control service that takes a
// responsibility to manage all active controllers.
void Activate();
// This would unregister controller from the media control service.
void Deactivate();
void UpdateActivatedStateIfNeeded();
bool ShouldActivateController() const;
bool ShouldDeactivateController() const;
void UpdateDeactivationTimerIfNeeded();
void DispatchAsyncEvent(const nsAString& aName);
void DispatchAsyncEvent(already_AddRefed<Event> aEvent);
bool IsMainController() const;
void ForceToBecomeMainControllerIfNeeded();
bool ShouldRequestForMainController() const;
bool ShouldPropagateActionToAllContexts(
const MediaControlAction& aAction) const;
bool mIsActive = false;
bool mShutdown = false;
bool mIsInPictureInPictureMode = false;
bool mIsInFullScreenMode = false;
// We would monitor the change of media session actions and convert them to
// the media keys, then determine the supported media keys.
MediaEventListener mSupportedActionsChangedListener;
MediaEventProducer<nsTArray<MediaControlKey>> mSupportedKeysChangedEvent;
MediaEventListener mPlaybackChangedListener;
MediaEventListener mPositionStateChangedListener;
MediaEventListener mMetadataChangedListener;
MediaEventProducer<bool> mFullScreenChangedEvent;
MediaEventProducer<bool> mPictureInPictureModeChangedEvent;
// Use copyable array so that we can use the result as a parameter for the
// media event.
CopyableTArray<MediaControlKey> mSupportedKeys;
// Timer to deactivate the controller if the time of being paused exceeds the
// threshold of time.
nsCOMPtr<nsITimer> mDeactivationTimer;
};
} // namespace mozilla::dom
#endif
|
