1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CONTENT_RENDERER_MEDIA_ANDROID_RENDERER_MEDIA_PLAYER_MANAGER_H_
6#define CONTENT_RENDERER_MEDIA_ANDROID_RENDERER_MEDIA_PLAYER_MANAGER_H_
7
8#include <map>
9#include <string>
10#include <vector>
11
12#include "base/basictypes.h"
13#include "base/time/time.h"
14#include "content/common/media/media_player_messages_enums_android.h"
15#include "content/public/renderer/render_view_observer.h"
16#include "media/base/android/media_player_android.h"
17#include "media/base/media_keys.h"
18#include "url/gurl.h"
19
20#if defined(GOOGLE_TV)
21#include "ui/gfx/rect_f.h"
22#endif
23
24namespace blink {
25class WebFrame;
26}
27
28namespace gfx {
29class RectF;
30}
31
32namespace content {
33
34class ProxyMediaKeys;
35class WebMediaPlayerAndroid;
36
37// Class for managing all the WebMediaPlayerAndroid objects in the same
38// RenderView.
39class RendererMediaPlayerManager : public RenderViewObserver {
40 public:
41  // Constructs a RendererMediaPlayerManager object for the |render_view|.
42  RendererMediaPlayerManager(RenderView* render_view);
43  virtual ~RendererMediaPlayerManager();
44
45  // RenderViewObserver overrides.
46  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
47
48  // Initializes a MediaPlayerAndroid object in browser process.
49  void Initialize(MediaPlayerHostMsg_Initialize_Type type,
50                  int player_id,
51                  const GURL& url,
52                  const GURL& first_party_for_cookies,
53                  int demuxer_client_id);
54
55  // Starts the player.
56  void Start(int player_id);
57
58  // Pauses the player.
59  // is_media_related_action should be true if this pause is coming from an
60  // an action that explicitly pauses the video (user pressing pause, JS, etc.)
61  // Otherwise it should be false if Pause is being called due to other reasons
62  // (cleanup, freeing resources, etc.)
63  void Pause(int player_id, bool is_media_related_action);
64
65  // Performs seek on the player.
66  void Seek(int player_id, const base::TimeDelta& time);
67
68  // Sets the player volume.
69  void SetVolume(int player_id, double volume);
70
71  // Releases resources for the player.
72  void ReleaseResources(int player_id);
73
74  // Destroys the player in the browser process
75  void DestroyPlayer(int player_id);
76
77  // Requests the player to enter fullscreen.
78  void EnterFullscreen(int player_id, blink::WebFrame* frame);
79
80  // Requests the player to exit fullscreen.
81  void ExitFullscreen(int player_id);
82
83#if defined(VIDEO_HOLE)
84  // Requests an external surface for out-of-band compositing.
85  void RequestExternalSurface(int player_id, const gfx::RectF& geometry);
86
87  // RenderViewObserver overrides.
88  virtual void DidCommitCompositorFrame() OVERRIDE;
89#endif  // defined(VIDEO_HOLE)
90
91  // Encrypted media related methods.
92  void InitializeCDM(int media_keys_id,
93                     ProxyMediaKeys* media_keys,
94                     const std::vector<uint8>& uuid,
95                     const GURL& frame_url);
96  void CreateSession(int media_keys_id,
97                     uint32 session_id,
98                     const std::string& type,
99                     const std::vector<uint8>& init_data);
100  void UpdateSession(int media_keys_id,
101                     uint32 session_id,
102                     const std::vector<uint8>& response);
103  void ReleaseSession(int media_keys_id, uint32 session_id);
104
105  // Registers and unregisters a WebMediaPlayerAndroid object.
106  int RegisterMediaPlayer(WebMediaPlayerAndroid* player);
107  void UnregisterMediaPlayer(int player_id);
108
109  // Registers a ProxyMediaKeys object. There must be a WebMediaPlayerAndroid
110  // object already registered for this id, and it is unregistered when the
111  // player is unregistered. For now |media_keys_id| is the same as player_id
112  // used in other methods.
113  void RegisterMediaKeys(int media_keys_id, ProxyMediaKeys* media_keys);
114
115  // Releases the media resources managed by this object when a video
116  // is playing.
117  void ReleaseVideoResources();
118
119  // Checks whether a player can enter fullscreen.
120  bool CanEnterFullscreen(blink::WebFrame* frame);
121
122  // Called when a player entered or exited fullscreen.
123  void DidEnterFullscreen(blink::WebFrame* frame);
124  void DidExitFullscreen();
125
126  // Checks whether the Webframe is in fullscreen.
127  bool IsInFullscreen(blink::WebFrame* frame);
128
129  // True if a newly created media player should enter fullscreen.
130  bool ShouldEnterFullscreen(blink::WebFrame* frame);
131
132  // Gets the pointer to WebMediaPlayerAndroid given the |player_id|.
133  WebMediaPlayerAndroid* GetMediaPlayer(int player_id);
134
135  // Gets the pointer to ProxyMediaKeys given the |media_keys_id|.
136  ProxyMediaKeys* GetMediaKeys(int media_keys_id);
137
138#if defined(VIDEO_HOLE)
139  // Gets the list of media players with video geometry changes.
140  void RetrieveGeometryChanges(std::map<int, gfx::RectF>* changes);
141#endif  // defined(VIDEO_HOLE)
142
143 private:
144  // Message handlers.
145  void OnMediaMetadataChanged(int player_id,
146                              base::TimeDelta duration,
147                              int width,
148                              int height,
149                              bool success);
150  void OnMediaPlaybackCompleted(int player_id);
151  void OnMediaBufferingUpdate(int player_id, int percent);
152  void OnSeekRequest(int player_id, const base::TimeDelta& time_to_seek);
153  void OnSeekCompleted(int player_id, const base::TimeDelta& current_time);
154  void OnMediaError(int player_id, int error);
155  void OnVideoSizeChanged(int player_id, int width, int height);
156  void OnTimeUpdate(int player_id, base::TimeDelta current_time);
157  void OnMediaPlayerReleased(int player_id);
158  void OnConnectedToRemoteDevice(int player_id);
159  void OnDisconnectedFromRemoteDevice(int player_id);
160  void OnDidExitFullscreen(int player_id);
161  void OnDidEnterFullscreen(int player_id);
162  void OnPlayerPlay(int player_id);
163  void OnPlayerPause(int player_id);
164  void OnRequestFullscreen(int player_id);
165  void OnSessionCreated(int media_keys_id,
166                        uint32 session_id,
167                        const std::string& web_session_id);
168  void OnSessionMessage(int media_keys_id,
169                        uint32 session_id,
170                        const std::vector<uint8>& message,
171                        const std::string& destination_url);
172  void OnSessionReady(int media_keys_id, uint32 session_id);
173  void OnSessionClosed(int media_keys_id, uint32 session_id);
174  void OnSessionError(int media_keys_id,
175                      uint32 session_id,
176                      media::MediaKeys::KeyError error_code,
177                      int system_code);
178
179  // Info for all available WebMediaPlayerAndroid on a page; kept so that
180  // we can enumerate them to send updates about tab focus and visibility.
181  std::map<int, WebMediaPlayerAndroid*> media_players_;
182
183  // Info for all available ProxyMediaKeys. There must be at most one
184  // ProxyMediaKeys for each available WebMediaPlayerAndroid.
185  std::map<int, ProxyMediaKeys*> media_keys_;
186
187  int next_media_player_id_;
188
189  // WebFrame of the fullscreen video.
190  blink::WebFrame* fullscreen_frame_;
191
192  // WebFrame of pending fullscreen request.
193  blink::WebFrame* pending_fullscreen_frame_;
194
195  DISALLOW_COPY_AND_ASSIGN(RendererMediaPlayerManager);
196};
197
198}  // namespace content
199
200#endif  // CONTENT_RENDERER_MEDIA_ANDROID_RENDERER_MEDIA_PLAYER_MANAGER_H_
201