OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 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 #include "webkit/media/android/webmediaplayer_in_process_android.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/logging.h" | |
9 #include "base/utf_string_conversions.h" | |
10 #include "media/base/android/media_player_bridge.h" | |
11 #include "media/base/android/media_player_bridge_manager.h" | |
12 #include "third_party/WebKit/Source/Platform/chromium/public/WebCookieJar.h" | |
13 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h" | |
14 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h" | |
15 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerClient.
h" | |
16 #include "webkit/media/android/stream_texture_factory_android.h" | |
17 #include "webkit/media/android/webmediaplayer_manager_android.h" | |
18 | |
19 using WebKit::WebMediaPlayerClient; | |
20 using WebKit::WebMediaPlayer; | |
21 using WebKit::WebURL; | |
22 using media::MediaPlayerBridge; | |
23 | |
24 namespace webkit_media { | |
25 | |
26 InProcessMediaResourceGetter::InProcessMediaResourceGetter( | |
27 WebKit::WebCookieJar* cookie_jar) | |
28 : cookie_jar_(cookie_jar) { | |
29 } | |
30 | |
31 InProcessMediaResourceGetter::~InProcessMediaResourceGetter() {} | |
32 | |
33 void InProcessMediaResourceGetter::GetCookies( | |
34 const GURL& url, | |
35 const GURL& first_party_for_cookies, | |
36 const GetCookieCB& callback) { | |
37 std::string cookies; | |
38 if (cookie_jar_ != NULL) { | |
39 cookies = UTF16ToUTF8( | |
40 cookie_jar_->cookies(url, first_party_for_cookies)); | |
41 } | |
42 callback.Run(cookies); | |
43 } | |
44 | |
45 void InProcessMediaResourceGetter::GetPlatformPathFromFileSystemURL( | |
46 const GURL& url, const GetPlatformPathCB& callback) { | |
47 callback.Run(std::string()); | |
48 } | |
49 | |
50 WebMediaPlayerInProcessAndroid::WebMediaPlayerInProcessAndroid( | |
51 WebKit::WebFrame* frame, | |
52 WebMediaPlayerClient* client, | |
53 WebKit::WebCookieJar* cookie_jar, | |
54 WebMediaPlayerManagerAndroid* manager, | |
55 media::MediaPlayerBridgeManager* resource_manager, | |
56 StreamTextureFactory* factory, | |
57 bool disable_media_history_logging) | |
58 : WebMediaPlayerAndroid(client, manager, factory), | |
59 frame_(frame), | |
60 playback_completed_(false), | |
61 cookie_jar_(cookie_jar), | |
62 resource_manager_(resource_manager), | |
63 disable_history_logging_(disable_media_history_logging) { | |
64 } | |
65 | |
66 WebMediaPlayerInProcessAndroid::~WebMediaPlayerInProcessAndroid() {} | |
67 | |
68 void WebMediaPlayerInProcessAndroid::PlayInternal() { | |
69 if (paused()) | |
70 media_player_->Start(); | |
71 } | |
72 | |
73 void WebMediaPlayerInProcessAndroid::PauseInternal() { | |
74 if (!paused()) | |
75 media_player_->Pause(); | |
76 } | |
77 | |
78 void WebMediaPlayerInProcessAndroid::SeekInternal(base::TimeDelta time) { | |
79 playback_completed_ = false; | |
80 media_player_->SeekTo(time); | |
81 } | |
82 | |
83 bool WebMediaPlayerInProcessAndroid::paused() const { | |
84 return !media_player_->IsPlaying(); | |
85 } | |
86 | |
87 float WebMediaPlayerInProcessAndroid::GetCurrentTimeInternal() const { | |
88 // When playback is about to finish, android media player often stops | |
89 // at a time which is smaller than the duration. This makes webkit never | |
90 // know that the playback has finished. To solve this, we set the | |
91 // current time to media duration when OnPlaybackComplete() get called. | |
92 if (playback_completed_) | |
93 return duration(); | |
94 return static_cast<float>(media_player_->GetCurrentTime().InSecondsF()); | |
95 } | |
96 | |
97 void WebMediaPlayerInProcessAndroid::ReleaseResourcesInternal() { | |
98 media_player_->Release(); | |
99 } | |
100 | |
101 void WebMediaPlayerInProcessAndroid::MediaPreparedCallback( | |
102 int player_id, base::TimeDelta duration) { | |
103 OnMediaPrepared(duration); | |
104 } | |
105 | |
106 void WebMediaPlayerInProcessAndroid::PlaybackCompleteCallback(int player_id) { | |
107 // Set the current time equal to duration to let webkit know that play back | |
108 // is completed. | |
109 playback_completed_ = true; | |
110 client()->timeChanged(); | |
111 } | |
112 | |
113 void WebMediaPlayerInProcessAndroid::SeekCompleteCallback( | |
114 int player_id, base::TimeDelta current_time) { | |
115 OnSeekComplete(current_time); | |
116 } | |
117 | |
118 void WebMediaPlayerInProcessAndroid::MediaInterruptedCallback(int player_id) { | |
119 PauseInternal(); | |
120 } | |
121 | |
122 void WebMediaPlayerInProcessAndroid::MediaErrorCallback(int player_id, | |
123 int error_type) { | |
124 OnMediaError(error_type); | |
125 } | |
126 | |
127 void WebMediaPlayerInProcessAndroid::VideoSizeChangedCallback( | |
128 int player_id, int width, int height) { | |
129 OnVideoSizeChanged(width, height); | |
130 } | |
131 | |
132 void WebMediaPlayerInProcessAndroid::BufferingUpdateCallback( | |
133 int player_id, int percent) { | |
134 OnBufferingUpdate(percent); | |
135 } | |
136 | |
137 void WebMediaPlayerInProcessAndroid::SetVideoSurface(jobject j_surface) { | |
138 media_player_->SetVideoSurface(j_surface); | |
139 } | |
140 | |
141 void WebMediaPlayerInProcessAndroid::InitializeMediaPlayer(GURL url) { | |
142 GURL first_party_url = frame_->document().firstPartyForCookies(); | |
143 media_player_.reset(new MediaPlayerBridge( | |
144 player_id(), url, first_party_url, | |
145 new InProcessMediaResourceGetter(cookie_jar_), | |
146 disable_history_logging_, | |
147 resource_manager_, | |
148 base::Bind(&WebMediaPlayerInProcessAndroid::MediaErrorCallback, | |
149 base::Unretained(this)), | |
150 base::Bind(&WebMediaPlayerInProcessAndroid::VideoSizeChangedCallback, | |
151 base::Unretained(this)), | |
152 base::Bind(&WebMediaPlayerInProcessAndroid::BufferingUpdateCallback, | |
153 base::Unretained(this)), | |
154 base::Bind(&WebMediaPlayerInProcessAndroid::MediaPreparedCallback, | |
155 base::Unretained(this)), | |
156 base::Bind(&WebMediaPlayerInProcessAndroid::PlaybackCompleteCallback, | |
157 base::Unretained(this)), | |
158 base::Bind(&WebMediaPlayerInProcessAndroid::SeekCompleteCallback, | |
159 base::Unretained(this)), | |
160 base::Bind(&WebMediaPlayerInProcessAndroid::TimeUpdateCallback, | |
161 base::Unretained(this)), | |
162 base::Bind(&WebMediaPlayerInProcessAndroid::MediaInterruptedCallback, | |
163 base::Unretained(this)))); | |
164 | |
165 UpdateNetworkState(WebMediaPlayer::NetworkStateLoading); | |
166 UpdateReadyState(WebMediaPlayer::ReadyStateHaveNothing); | |
167 | |
168 // Calling Prepare() will cause android mediaplayer to start | |
169 // buffering and decoding the data. On mobile devices, this costs a lot of | |
170 // data usage and could even introduce performance issues. So we don't | |
171 // initialize the player unless it is a local file. We will start loading | |
172 // the media only when play/seek/fullsceen button is clicked. | |
173 if (url.SchemeIs("file")) { | |
174 media_player_->Prepare(); | |
175 return; | |
176 } | |
177 | |
178 // Pretend everything has been loaded so that webkit can | |
179 // still call play() and seek(). | |
180 UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata); | |
181 UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData); | |
182 } | |
183 | |
184 void WebMediaPlayerInProcessAndroid::OnTimeUpdate( | |
185 base::TimeDelta current_time) {} | |
186 | |
187 void WebMediaPlayerInProcessAndroid::Destroy() {} | |
188 | |
189 void WebMediaPlayerInProcessAndroid::RequestExternalSurface() { | |
190 NOTIMPLEMENTED(); | |
191 } | |
192 | |
193 } // namespace webkit_media | |
OLD | NEW |