1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.android.supportv7.media;
import android.content.Context;
import android.graphics.Bitmap;
import android.support.v4.media.MediaMetadataCompat;
import android.support.v4.media.session.MediaSessionCompat;
import android.support.v4.media.session.PlaybackStateCompat;
import android.support.v7.media.MediaControlIntent;
import android.support.v7.media.MediaRouter.RouteInfo;
import android.util.Log;
/**
* Abstraction of common playback operations of media items, such as play,
* seek, etc. Used by PlaybackManager as a backend to handle actual playback
* of media items.
*
* TODO: Introduce prepare() method and refactor subclasses accordingly.
*/
public abstract class Player {
private static final String TAG = "SampleMediaRoutePlayer";
protected static final int STATE_IDLE = 0;
protected static final int STATE_PREPARING_FOR_PLAY = 1;
protected static final int STATE_PREPARING_FOR_PAUSE = 2;
protected static final int STATE_READY = 3;
protected static final int STATE_PLAYING = 4;
protected static final int STATE_PAUSED = 5;
private static final long PLAYBACK_ACTIONS = PlaybackStateCompat.ACTION_PAUSE
| PlaybackStateCompat.ACTION_PLAY;
private static final PlaybackStateCompat INIT_PLAYBACK_STATE = new PlaybackStateCompat.Builder()
.setState(PlaybackStateCompat.STATE_NONE, 0, .0f).build();
protected Callback mCallback;
protected MediaSessionCompat mMediaSession;
public abstract boolean isRemotePlayback();
public abstract boolean isQueuingSupported();
public abstract void connect(RouteInfo route);
public abstract void release();
// basic operations that are always supported
public abstract void play(final PlaylistItem item);
public abstract void seek(final PlaylistItem item);
public abstract void getStatus(final PlaylistItem item, final boolean update);
public abstract void pause();
public abstract void resume();
public abstract void stop();
// advanced queuing (enqueue & remove) are only supported
// if isQueuingSupported() returns true
public abstract void enqueue(final PlaylistItem item);
public abstract PlaylistItem remove(String iid);
// track info for current media item
public void updateTrackInfo() {}
public String getDescription() { return ""; }
public Bitmap getSnapshot() { return null; }
// presentation display
public void updatePresentation() {}
public void setCallback(Callback callback) {
mCallback = callback;
}
public static Player create(Context context, RouteInfo route, MediaSessionCompat session) {
Player player;
if (route != null && route.supportsControlCategory(
MediaControlIntent.CATEGORY_REMOTE_PLAYBACK)) {
player = new RemotePlayer(context);
} else if (route != null) {
player = new LocalPlayer.SurfaceViewPlayer(context);
} else {
player = new LocalPlayer.OverlayPlayer(context);
}
player.setMediaSession(session);
player.initMediaSession();
player.connect(route);
return player;
}
protected void initMediaSession() {
if (mMediaSession == null) {
return;
}
mMediaSession.setMetadata(null);
mMediaSession.setPlaybackState(INIT_PLAYBACK_STATE);
}
protected void updateMetadata() {
if (mMediaSession == null) {
return;
}
MediaMetadataCompat.Builder bob = new MediaMetadataCompat.Builder();
bob.putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_TITLE, getDescription());
bob.putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, "Subtitle of the thing");
bob.putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_DESCRIPTION,
"Description of the thing");
bob.putBitmap(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON, getSnapshot());
mMediaSession.setMetadata(bob.build());
}
protected void publishState(int state) {
if (mMediaSession == null) {
return;
}
PlaybackStateCompat.Builder bob = new PlaybackStateCompat.Builder();
bob.setActions(PLAYBACK_ACTIONS);
switch (state) {
case STATE_PLAYING:
bob.setState(PlaybackStateCompat.STATE_PLAYING, -1, 1);
break;
case STATE_READY:
case STATE_PAUSED:
bob.setState(PlaybackStateCompat.STATE_PAUSED, -1, 0);
break;
case STATE_IDLE:
bob.setState(PlaybackStateCompat.STATE_STOPPED, -1, 0);
break;
}
PlaybackStateCompat pbState = bob.build();
Log.d(TAG, "Setting state to " + pbState);
mMediaSession.setPlaybackState(pbState);
if (state != STATE_IDLE) {
mMediaSession.setActive(true);
} else {
mMediaSession.setActive(false);
}
}
private void setMediaSession(MediaSessionCompat session) {
mMediaSession = session;
}
public interface Callback {
void onError();
void onCompletion();
void onPlaylistChanged();
void onPlaylistReady();
}
}
|
