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