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.app.PendingIntent;
20
import android.net.Uri;
21
import android.support.v7.media.MediaItemStatus;
22
import android.support.v7.media.MediaSessionStatus;
23
import android.util.Log;
24
25
import com.example.android.mediarouter.player.Player.Callback;
26
27
import java.util.ArrayList;
28
import java.util.List;
29
30
/**
31
* SessionManager manages a media session as a queue. It supports common
32
* queuing behaviors such as enqueue/remove of media items, pause/resume/stop,
33
* etc.
34
*
35
* Actual playback of a single media item is abstracted into a Player interface,
36
* and is handled outside this class.
37
*/
38
public class SessionManager implements Callback {
39
private static final String TAG = "SessionManager";
40
private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
41
42
private String mName;
43
private int mSessionId;
44
private int mItemId;
45
private boolean mPaused;
46
private boolean mSessionValid;
47
private Player mPlayer;
48
private Callback mCallback;
49
private List<PlaylistItem> mPlaylist = new ArrayList<PlaylistItem>();
50
51
public SessionManager(String name) {
52
mName = name;
53
}
54
55
public boolean hasSession() {
56
return mSessionValid;
57
}
58
59
public String getSessionId() {
60
return mSessionValid ? Integer.toString(mSessionId) : null;
61
}
62
63
public PlaylistItem getCurrentItem() {
64
return mPlaylist.isEmpty() ? null : mPlaylist.get(0);
65
}
66
67
// Get the cached statistic info from the player (will not update it)
68
public String getStatistics() {
69
checkPlayer();
70
return mPlayer.getStatistics();
71
}
72
73
// Returns the cached playlist (note this is not responsible for updating it)
74
public List<PlaylistItem> getPlaylist() {
75
return mPlaylist;
76
}
77
78
// Updates the playlist asynchronously, calls onPlaylistReady() when finished.
79
public void updateStatus() {
80
if (DEBUG) {
81
log("updateStatus");
82
}
83
checkPlayer();
84
// update the statistics first, so that the stats string is valid when
85
// onPlaylistReady() gets called in the end
86
mPlayer.updateStatistics();
87
88
if (mPlaylist.isEmpty()) {
89
// If queue is empty, don't forget to call onPlaylistReady()!
90
onPlaylistReady();
91
} else if (mPlayer.isQueuingSupported()) {
92
// If player supports queuing, get status of each item. Player is
93
// responsible to call onPlaylistReady() after last getStatus().
94
// (update=1 requires player to callback onPlaylistReady())
95
for (int i = 0; i < mPlaylist.size(); i++) {
96
PlaylistItem item = mPlaylist.get(i);
97
mPlayer.getStatus(item, (i == mPlaylist.size() - 1) /* update */);
98
}
99
} else {
100
// Otherwise, only need to get status for current item. Player is
101
// responsible to call onPlaylistReady() when finished.
102
mPlayer.getStatus(getCurrentItem(), true /* update */);
103
}
104
}
105
106
public PlaylistItem add(Uri uri, String mime) {
107
return add(uri, mime, null);
108
}
109
110
public PlaylistItem add(Uri uri, String mime, PendingIntent receiver) {
111
if (DEBUG) {
112
log("add: uri=" + uri + ", receiver=" + receiver);
113
}
114
// create new session if needed
115
startSession();
116
checkPlayerAndSession();
117
118
// append new item with initial status PLAYBACK_STATE_PENDING
119
PlaylistItem item = new PlaylistItem(
120
Integer.toString(mSessionId), Integer.toString(mItemId), uri, mime, receiver);
121
mPlaylist.add(item);
122
mItemId++;
123
124
// if player supports queuing, enqueue the item now
125
if (mPlayer.isQueuingSupported()) {
126
mPlayer.enqueue(item);
127
}
128
updatePlaybackState();
129
return item;
130
}
131
132
public PlaylistItem remove(String iid) {
133
if (DEBUG) {
134
log("remove: iid=" + iid);
135
}
136
checkPlayerAndSession();
137
return removeItem(iid, MediaItemStatus.PLAYBACK_STATE_CANCELED);
138
}
139
140
public PlaylistItem seek(String iid, long pos) {
141
if (DEBUG) {
142
log("seek: iid=" + iid +", pos=" + pos);
143
}
144
checkPlayerAndSession();
145
// seeking on pending items are not yet supported
146
checkItemCurrent(iid);
147
148
PlaylistItem item = getCurrentItem();
149
if (pos != item.getPosition()) {
150
item.setPosition(pos);
151
if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PLAYING
152
|| item.getState() == MediaItemStatus.PLAYBACK_STATE_PAUSED) {
153
mPlayer.seek(item);
154
}
155
}
156
return item;
157
}
158
159
public PlaylistItem getStatus(String iid) {
160
checkPlayerAndSession();
161
162
// This should only be called for local player. Remote player is
163
// asynchronous, need to use updateStatus() instead.
164
if (mPlayer.isRemotePlayback()) {
165
throw new IllegalStateException(
166
"getStatus should not be called on remote player!");
167
}
168
169
for (PlaylistItem item : mPlaylist) {
170
if (item.getItemId().equals(iid)) {
171
if (item == getCurrentItem()) {
172
mPlayer.getStatus(item, false);
173
}
174
return item;
175
}
176
}
177
return null;
178
}
179
180
public void pause() {
181
if (DEBUG) {
182
log("pause");
183
}
184
mPaused = true;
185
updatePlaybackState();
186
}
187
188
public void resume() {
189
if (DEBUG) {
190
log("resume");
191
}
192
mPaused = false;
193
updatePlaybackState();
194
}
195
196
public void stop() {
197
if (DEBUG) {
198
log("stop");
199
}
200
mPlayer.stop();
201
mPlaylist.clear();
202
mPaused = false;
203
updateStatus();
204
}
205
206
public String startSession() {
207
if (!mSessionValid) {
208
mSessionId++;
209
mItemId = 0;
210
mPaused = false;
211
mSessionValid = true;
212
return Integer.toString(mSessionId);
213
}
214
return null;
215
}
216
217
public boolean endSession() {
218
if (mSessionValid) {
219
mSessionValid = false;
220
return true;
221
}
222
return false;
223
}
224
225
public MediaSessionStatus getSessionStatus(String sid) {
226
int sessionState = (sid != null && sid.equals(mSessionId)) ?
227
MediaSessionStatus.SESSION_STATE_ACTIVE :
228
MediaSessionStatus.SESSION_STATE_INVALIDATED;
229
230
return new MediaSessionStatus.Builder(sessionState)
231
.setQueuePaused(mPaused)
232
.build();
233
}
234
235
// Suspend the playback manager. Put the current item back into PENDING
236
// state, and remember the current playback position. Called when switching
237
// to a different player (route).
238
public void suspend(long pos) {
239
for (PlaylistItem item : mPlaylist) {
240
item.setRemoteItemId(null);
241
item.setDuration(0);
242
}
243
PlaylistItem item = getCurrentItem();
244
if (DEBUG) {
245
log("suspend: item=" + item + ", pos=" + pos);
246
}
247
if (item != null) {
248
if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PLAYING
249
|| item.getState() == MediaItemStatus.PLAYBACK_STATE_PAUSED) {
250
item.setState(MediaItemStatus.PLAYBACK_STATE_PENDING);
251
item.setPosition(pos);
252
}
253
}
254
}
255
256
// Unsuspend the playback manager. Restart playback on new player (route).
257
// This will resume playback of current item. Furthermore, if the new player
258
// supports queuing, playlist will be re-established on the remote player.
259
public void unsuspend() {
260
if (DEBUG) {
261
log("unsuspend");
262
}
263
if (mPlayer.isQueuingSupported()) {
264
for (PlaylistItem item : mPlaylist) {
265
mPlayer.enqueue(item);
266
}
267
}
268
updatePlaybackState();
269
}
270
271
// Player.Callback
272
@Override
273
public void onError() {
274
finishItem(true);
275
}
276
277
@Override
278
public void onCompletion() {
279
finishItem(false);
280
}
281
282
@Override
283
public void onPlaylistChanged() {
284
// Playlist has changed, update the cached playlist
285
updateStatus();
286
}
287
288
@Override
289
public void onPlaylistReady() {
290
// Notify activity to update Ui
291
if (mCallback != null) {
292
mCallback.onStatusChanged();
293
}
294
}
295
296
private void log(String message) {
297
Log.d(TAG, mName + ": " + message);
298
}
299
300
private void checkPlayer() {
301
if (mPlayer == null) {
302
throw new IllegalStateException("Player not set!");
303
}
304
}
305
306
private void checkSession() {
307
if (!mSessionValid) {
308
throw new IllegalStateException("Session not set!");
309
}
310
}
311
312
private void checkPlayerAndSession() {
313
checkPlayer();
314
checkSession();
315
}
316
317
private void checkItemCurrent(String iid) {
318
PlaylistItem item = getCurrentItem();
319
if (item == null || !item.getItemId().equals(iid)) {
320
throw new IllegalArgumentException("Item is not current!");
321
}
322
}
323
324
private void updatePlaybackState() {
325
PlaylistItem item = getCurrentItem();
326
if (item != null) {
327
if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PENDING) {
328
item.setState(mPaused ? MediaItemStatus.PLAYBACK_STATE_PAUSED
329
: MediaItemStatus.PLAYBACK_STATE_PLAYING);
330
if (!mPlayer.isQueuingSupported()) {
331
mPlayer.play(item);
332
}
333
} else if (mPaused && item.getState() == MediaItemStatus.PLAYBACK_STATE_PLAYING) {
334
mPlayer.pause();
335
item.setState(MediaItemStatus.PLAYBACK_STATE_PAUSED);
336
} else if (!mPaused && item.getState() == MediaItemStatus.PLAYBACK_STATE_PAUSED) {
337
mPlayer.resume();
338
item.setState(MediaItemStatus.PLAYBACK_STATE_PLAYING);
339
}
340
// notify client that item playback status has changed
341
if (mCallback != null) {
342
mCallback.onItemChanged(item);
343
}
344
}
345
updateStatus();
346
}
347
348
private PlaylistItem removeItem(String iid, int state) {
349
checkPlayerAndSession();
350
List<PlaylistItem> queue =
351
new ArrayList<PlaylistItem>(mPlaylist.size());
352
PlaylistItem found = null;
353
for (PlaylistItem item : mPlaylist) {
354
if (iid.equals(item.getItemId())) {
355
if (mPlayer.isQueuingSupported()) {
356
mPlayer.remove(item.getRemoteItemId());
357
} else if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PLAYING
358
|| item.getState() == MediaItemStatus.PLAYBACK_STATE_PAUSED){
359
mPlayer.stop();
360
}
361
item.setState(state);
362
found = item;
363
// notify client that item is now removed
364
if (mCallback != null) {
365
mCallback.onItemChanged(found);
366
}
367
} else {
368
queue.add(item);
369
}
370
}
371
if (found != null) {
372
mPlaylist = queue;
373
updatePlaybackState();
374
} else {
375
log("item not found");
376
}
377
return found;
378
}
379
380
private void finishItem(boolean error) {
381
PlaylistItem item = getCurrentItem();
382
if (item != null) {
383
removeItem(item.getItemId(), error ?
384
MediaItemStatus.PLAYBACK_STATE_ERROR :
385
MediaItemStatus.PLAYBACK_STATE_FINISHED);
386
updateStatus();
387
}
388
}
389
390
// set the Player that this playback manager will interact with
391
public void setPlayer(Player player) {
392
mPlayer = player;
393
checkPlayer();
394
mPlayer.setCallback(this);
395
}
396
397
// provide a callback interface to tell the UI when significant state changes occur
398
public void setCallback(Callback callback) {
399
mCallback = callback;
400
}
401
402
@Override
403
public String toString() {
404
String result = "Media Queue: ";
405
if (!mPlaylist.isEmpty()) {
406
for (PlaylistItem item : mPlaylist) {
407
result += "\n" + item.toString();
408
}
409
} else {
410
result += "<empty>";
411
}
412
return result;
413
}
414
415
public interface Callback {
416
void onStatusChanged();
417
void onItemChanged(PlaylistItem item);
418
}
419
}