Links
Android Sites
Language
Results
Loading...
1
/*
2
* Copyright (C) 2013 The Android Open Source Project
3
*
4
* Licensed under the Apache License, Version 2.0 (the "License");
5
* you may not use this file except in compliance with the License.
6
* You may obtain a copy of the License at
7
*
8
* http://www.apache.org/licenses/LICENSE-2.0
9
*
10
* Unless required by applicable law or agreed to in writing, software
11
* distributed under the License is distributed on an "AS IS" BASIS,
12
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
* See the License for the specific language governing permissions and
14
* limitations under the License.
15
*/
16
17
package com.example.android.mediarouter.player;
18
19
import android.content.Context;
20
import android.content.Intent;
21
import android.os.Bundle;
22
import android.support.v7.media.MediaItemStatus;
23
import android.support.v7.media.MediaRouter.ControlRequestCallback;
24
import android.support.v7.media.MediaRouter.RouteInfo;
25
import android.support.v7.media.MediaSessionStatus;
26
import android.support.v7.media.RemotePlaybackClient;
27
import android.support.v7.media.RemotePlaybackClient.ItemActionCallback;
28
import android.support.v7.media.RemotePlaybackClient.SessionActionCallback;
29
import android.support.v7.media.RemotePlaybackClient.StatusCallback;
30
import android.util.Log;
31
32
import com.example.android.mediarouter.player.Player;
33
import com.example.android.mediarouter.player.PlaylistItem;
34
import com.example.android.mediarouter.provider.SampleMediaRouteProvider;
35
36
import java.util.ArrayList;
37
import java.util.List;
38
39
/**
40
* Handles playback of media items using a remote route.
41
*
42
* This class is used as a backend by PlaybackManager to feed media items to
43
* the remote route. When the remote route doesn't support queuing, media items
44
* are fed one-at-a-time; otherwise media items are enqueued to the remote side.
45
*/
46
public class RemotePlayer extends Player {
47
private static final String TAG = "RemotePlayer";
48
private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
49
private Context mContext;
50
private RouteInfo mRoute;
51
private boolean mEnqueuePending;
52
private String mStatsInfo = "";
53
private List<PlaylistItem> mTempQueue = new ArrayList<PlaylistItem>();
54
55
private RemotePlaybackClient mClient;
56
private StatusCallback mStatusCallback = new StatusCallback() {
57
@Override
58
public void onItemStatusChanged(Bundle data,
59
String sessionId, MediaSessionStatus sessionStatus,
60
String itemId, MediaItemStatus itemStatus) {
61
logStatus("onItemStatusChanged", sessionId, sessionStatus, itemId, itemStatus);
62
if (mCallback != null) {
63
if (itemStatus.getPlaybackState() ==
64
MediaItemStatus.PLAYBACK_STATE_FINISHED) {
65
mCallback.onCompletion();
66
} else if (itemStatus.getPlaybackState() ==
67
MediaItemStatus.PLAYBACK_STATE_ERROR) {
68
mCallback.onError();
69
}
70
}
71
}
72
73
@Override
74
public void onSessionStatusChanged(Bundle data,
75
String sessionId, MediaSessionStatus sessionStatus) {
76
logStatus("onSessionStatusChanged", sessionId, sessionStatus, null, null);
77
if (mCallback != null) {
78
mCallback.onPlaylistChanged();
79
}
80
}
81
82
@Override
83
public void onSessionChanged(String sessionId) {
84
if (DEBUG) {
85
Log.d(TAG, "onSessionChanged: sessionId=" + sessionId);
86
}
87
}
88
};
89
90
public RemotePlayer(Context context) {
91
mContext = context;
92
}
93
94
@Override
95
public boolean isRemotePlayback() {
96
return true;
97
}
98
99
@Override
100
public boolean isQueuingSupported() {
101
return mClient.isQueuingSupported();
102
}
103
104
@Override
105
public void connect(RouteInfo route) {
106
mRoute = route;
107
mClient = new RemotePlaybackClient(mContext, route);
108
mClient.setStatusCallback(mStatusCallback);
109
110
if (DEBUG) {
111
Log.d(TAG, "connected to: " + route
112
+ ", isRemotePlaybackSupported: " + mClient.isRemotePlaybackSupported()
113
+ ", isQueuingSupported: "+ mClient.isQueuingSupported());
114
}
115
}
116
117
@Override
118
public void release() {
119
mClient.release();
120
121
if (DEBUG) {
122
Log.d(TAG, "released.");
123
}
124
}
125
126
// basic playback operations that are always supported
127
@Override
128
public void play(final PlaylistItem item) {
129
if (DEBUG) {
130
Log.d(TAG, "play: item=" + item);
131
}
132
mClient.play(item.getUri(), "video/mp4", null, 0, null, new ItemActionCallback() {
133
@Override
134
public void onResult(Bundle data, String sessionId, MediaSessionStatus sessionStatus,
135
String itemId, MediaItemStatus itemStatus) {
136
logStatus("play: succeeded", sessionId, sessionStatus, itemId, itemStatus);
137
item.setRemoteItemId(itemId);
138
if (item.getPosition() > 0) {
139
seekInternal(item);
140
}
141
if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PAUSED) {
142
pause();
143
}
144
if (mCallback != null) {
145
mCallback.onPlaylistChanged();
146
}
147
}
148
149
@Override
150
public void onError(String error, int code, Bundle data) {
151
logError("play: failed", error, code);
152
}
153
});
154
}
155
156
@Override
157
public void seek(final PlaylistItem item) {
158
seekInternal(item);
159
}
160
161
@Override
162
public void getStatus(final PlaylistItem item, final boolean update) {
163
if (!mClient.hasSession() || item.getRemoteItemId() == null) {
164
// if session is not valid or item id not assigend yet.
165
// just return, it's not fatal
166
return;
167
}
168
169
if (DEBUG) {
170
Log.d(TAG, "getStatus: item=" + item + ", update=" + update);
171
}
172
mClient.getStatus(item.getRemoteItemId(), null, new ItemActionCallback() {
173
@Override
174
public void onResult(Bundle data, String sessionId, MediaSessionStatus sessionStatus,
175
String itemId, MediaItemStatus itemStatus) {
176
logStatus("getStatus: succeeded", sessionId, sessionStatus, itemId, itemStatus);
177
int state = itemStatus.getPlaybackState();
178
if (state == MediaItemStatus.PLAYBACK_STATE_PLAYING
179
|| state == MediaItemStatus.PLAYBACK_STATE_PAUSED
180
|| state == MediaItemStatus.PLAYBACK_STATE_PENDING) {
181
item.setState(state);
182
item.setPosition(itemStatus.getContentPosition());
183
item.setDuration(itemStatus.getContentDuration());
184
item.setTimestamp(itemStatus.getTimestamp());
185
}
186
if (update && mCallback != null) {
187
mCallback.onPlaylistReady();
188
}
189
}
190
191
@Override
192
public void onError(String error, int code, Bundle data) {
193
logError("getStatus: failed", error, code);
194
if (update && mCallback != null) {
195
mCallback.onPlaylistReady();
196
}
197
}
198
});
199
}
200
201
@Override
202
public void pause() {
203
if (!mClient.hasSession()) {
204
// ignore if no session
205
return;
206
}
207
if (DEBUG) {
208
Log.d(TAG, "pause");
209
}
210
mClient.pause(null, new SessionActionCallback() {
211
@Override
212
public void onResult(Bundle data, String sessionId, MediaSessionStatus sessionStatus) {
213
logStatus("pause: succeeded", sessionId, sessionStatus, null, null);
214
if (mCallback != null) {
215
mCallback.onPlaylistChanged();
216
}
217
}
218
219
@Override
220
public void onError(String error, int code, Bundle data) {
221
logError("pause: failed", error, code);
222
}
223
});
224
}
225
226
@Override
227
public void resume() {
228
if (!mClient.hasSession()) {
229
// ignore if no session
230
return;
231
}
232
if (DEBUG) {
233
Log.d(TAG, "resume");
234
}
235
mClient.resume(null, new SessionActionCallback() {
236
@Override
237
public void onResult(Bundle data, String sessionId, MediaSessionStatus sessionStatus) {
238
logStatus("resume: succeeded", sessionId, sessionStatus, null, null);
239
if (mCallback != null) {
240
mCallback.onPlaylistChanged();
241
}
242
}
243
244
@Override
245
public void onError(String error, int code, Bundle data) {
246
logError("resume: failed", error, code);
247
}
248
});
249
}
250
251
@Override
252
public void stop() {
253
if (!mClient.hasSession()) {
254
// ignore if no session
255
return;
256
}
257
if (DEBUG) {
258
Log.d(TAG, "stop");
259
}
260
mClient.stop(null, new SessionActionCallback() {
261
@Override
262
public void onResult(Bundle data, String sessionId, MediaSessionStatus sessionStatus) {
263
logStatus("stop: succeeded", sessionId, sessionStatus, null, null);
264
if (mClient.isSessionManagementSupported()) {
265
endSession();
266
}
267
if (mCallback != null) {
268
mCallback.onPlaylistChanged();
269
}
270
}
271
272
@Override
273
public void onError(String error, int code, Bundle data) {
274
logError("stop: failed", error, code);
275
}
276
});
277
}
278
279
// enqueue & remove are only supported if isQueuingSupported() returns true
280
@Override
281
public void enqueue(final PlaylistItem item) {
282
throwIfQueuingUnsupported();
283
284
if (!mClient.hasSession() && !mEnqueuePending) {
285
mEnqueuePending = true;
286
if (mClient.isSessionManagementSupported()) {
287
startSession(item);
288
} else {
289
enqueueInternal(item);
290
}
291
} else if (mEnqueuePending){
292
mTempQueue.add(item);
293
} else {
294
enqueueInternal(item);
295
}
296
}
297
298
@Override
299
public PlaylistItem remove(String itemId) {
300
throwIfNoSession();
301
throwIfQueuingUnsupported();
302
303
if (DEBUG) {
304
Log.d(TAG, "remove: itemId=" + itemId);
305
}
306
mClient.remove(itemId, null, new ItemActionCallback() {
307
@Override
308
public void onResult(Bundle data, String sessionId, MediaSessionStatus sessionStatus,
309
String itemId, MediaItemStatus itemStatus) {
310
logStatus("remove: succeeded", sessionId, sessionStatus, itemId, itemStatus);
311
}
312
313
@Override
314
public void onError(String error, int code, Bundle data) {
315
logError("remove: failed", error, code);
316
}
317
});
318
319
return null;
320
}
321
322
@Override
323
public void updateStatistics() {
324
// clear stats info first
325
mStatsInfo = "";
326
327
Intent intent = new Intent(SampleMediaRouteProvider.ACTION_GET_STATISTICS);
328
intent.addCategory(SampleMediaRouteProvider.CATEGORY_SAMPLE_ROUTE);
329
330
if (mRoute != null && mRoute.supportsControlRequest(intent)) {
331
ControlRequestCallback callback = new ControlRequestCallback() {
332
@Override
333
public void onResult(Bundle data) {
334
if (DEBUG) {
335
Log.d(TAG, "getStatistics: succeeded: data=" + data);
336
}
337
if (data != null) {
338
int playbackCount = data.getInt(
339
SampleMediaRouteProvider.DATA_PLAYBACK_COUNT, -1);
340
mStatsInfo = "Total playback count: " + playbackCount;
341
}
342
}
343
344
@Override
345
public void onError(String error, Bundle data) {
346
Log.d(TAG, "getStatistics: failed: error=" + error + ", data=" + data);
347
}
348
};
349
350
mRoute.sendControlRequest(intent, callback);
351
}
352
}
353
354
@Override
355
public String getStatistics() {
356
return mStatsInfo;
357
}
358
359
private void enqueueInternal(final PlaylistItem item) {
360
throwIfQueuingUnsupported();
361
362
if (DEBUG) {
363
Log.d(TAG, "enqueue: item=" + item);
364
}
365
mClient.enqueue(item.getUri(), "video/mp4", null, 0, null, new ItemActionCallback() {
366
@Override
367
public void onResult(Bundle data, String sessionId, MediaSessionStatus sessionStatus,
368
String itemId, MediaItemStatus itemStatus) {
369
logStatus("enqueue: succeeded", sessionId, sessionStatus, itemId, itemStatus);
370
item.setRemoteItemId(itemId);
371
if (item.getPosition() > 0) {
372
seekInternal(item);
373
}
374
if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PAUSED) {
375
pause();
376
}
377
if (mEnqueuePending) {
378
mEnqueuePending = false;
379
for (PlaylistItem item : mTempQueue) {
380
enqueueInternal(item);
381
}
382
mTempQueue.clear();
383
}
384
if (mCallback != null) {
385
mCallback.onPlaylistChanged();
386
}
387
}
388
389
@Override
390
public void onError(String error, int code, Bundle data) {
391
logError("enqueue: failed", error, code);
392
if (mCallback != null) {
393
mCallback.onPlaylistChanged();
394
}
395
}
396
});
397
}
398
399
private void seekInternal(final PlaylistItem item) {
400
throwIfNoSession();
401
402
if (DEBUG) {
403
Log.d(TAG, "seek: item=" + item);
404
}
405
mClient.seek(item.getRemoteItemId(), item.getPosition(), null, new ItemActionCallback() {
406
@Override
407
public void onResult(Bundle data, String sessionId, MediaSessionStatus sessionStatus,
408
String itemId, MediaItemStatus itemStatus) {
409
logStatus("seek: succeeded", sessionId, sessionStatus, itemId, itemStatus);
410
if (mCallback != null) {
411
mCallback.onPlaylistChanged();
412
}
413
}
414
415
@Override
416
public void onError(String error, int code, Bundle data) {
417
logError("seek: failed", error, code);
418
}
419
});
420
}
421
422
private void startSession(final PlaylistItem item) {
423
mClient.startSession(null, new SessionActionCallback() {
424
@Override
425
public void onResult(Bundle data, String sessionId, MediaSessionStatus sessionStatus) {
426
logStatus("startSession: succeeded", sessionId, sessionStatus, null, null);
427
enqueueInternal(item);
428
}
429
430
@Override
431
public void onError(String error, int code, Bundle data) {
432
logError("startSession: failed", error, code);
433
}
434
});
435
}
436
437
private void endSession() {
438
mClient.endSession(null, new SessionActionCallback() {
439
@Override
440
public void onResult(Bundle data, String sessionId, MediaSessionStatus sessionStatus) {
441
logStatus("endSession: succeeded", sessionId, sessionStatus, null, null);
442
}
443
444
@Override
445
public void onError(String error, int code, Bundle data) {
446
logError("endSession: failed", error, code);
447
}
448
});
449
}
450
451
private void logStatus(String message,
452
String sessionId, MediaSessionStatus sessionStatus,
453
String itemId, MediaItemStatus itemStatus) {
454
if (DEBUG) {
455
String result = "";
456
if (sessionId != null && sessionStatus != null) {
457
result += "sessionId=" + sessionId + ", sessionStatus=" + sessionStatus;
458
}
459
if (itemId != null & itemStatus != null) {
460
result += (result.isEmpty() ? "" : ", ")
461
+ "itemId=" + itemId + ", itemStatus=" + itemStatus;
462
}
463
Log.d(TAG, message + ": " + result);
464
}
465
}
466
467
private void logError(String message, String error, int code) {
468
Log.d(TAG, message + ": error=" + error + ", code=" + code);
469
}
470
471
private void throwIfNoSession() {
472
if (!mClient.hasSession()) {
473
throw new IllegalStateException("Session is invalid");
474
}
475
}
476
477
private void throwIfQueuingUnsupported() {
478
if (!isQueuingSupported()) {
479
throw new UnsupportedOperationException("Queuing is unsupported");
480
}
481
}
482
}