MediaSessionCompatApi14.java revision 55642c06219b6c5c41cd97a389797131d00cb595 
1/*
2 * Copyright (C) 2014 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 */
16package android.support.v4.media.session;
17
18import android.app.PendingIntent;
19import android.content.Context;
20import android.content.Intent;
21import android.graphics.Bitmap;
22import android.media.AudioManager;
23import android.media.MediaMetadataRetriever;
24import android.media.RemoteControlClient;
25import android.os.Bundle;
26import android.os.ResultReceiver;
27
28public class MediaSessionCompatApi14 {
29    /***** RemoteControlClient States, we only need none as the others were public *******/
30    final static int RCC_PLAYSTATE_NONE = 0;
31
32    /***** MediaSession States *******/
33    final static int STATE_NONE = 0;
34    final static int STATE_STOPPED = 1;
35    final static int STATE_PAUSED = 2;
36    final static int STATE_PLAYING = 3;
37    final static int STATE_FAST_FORWARDING = 4;
38    final static int STATE_REWINDING = 5;
39    final static int STATE_BUFFERING = 6;
40    final static int STATE_ERROR = 7;
41    final static int STATE_CONNECTING = 8;
42    final static int STATE_SKIPPING_TO_PREVIOUS = 9;
43    final static int STATE_SKIPPING_TO_NEXT = 10;
44
45    /***** MediaMetadata keys ********/
46    private static final String METADATA_KEY_TITLE = "android.media.metadata.TITLE";
47    private static final String METADATA_KEY_ARTIST = "android.media.metadata.ARTIST";
48    private static final String METADATA_KEY_DURATION = "android.media.metadata.DURATION";
49    private static final String METADATA_KEY_ALBUM = "android.media.metadata.ALBUM";
50    private static final String METADATA_KEY_AUTHOR = "android.media.metadata.AUTHOR";
51    private static final String METADATA_KEY_WRITER = "android.media.metadata.WRITER";
52    private static final String METADATA_KEY_COMPOSER = "android.media.metadata.COMPOSER";
53    private static final String METADATA_KEY_COMPILATION = "android.media.metadata.COMPILATION";
54    private static final String METADATA_KEY_DATE = "android.media.metadata.DATE";
55    private static final String METADATA_KEY_YEAR = "android.media.metadata.YEAR";
56    private static final String METADATA_KEY_GENRE = "android.media.metadata.GENRE";
57    private static final String METADATA_KEY_TRACK_NUMBER = "android.media.metadata.TRACK_NUMBER";
58    private static final String METADATA_KEY_NUM_TRACKS = "android.media.metadata.NUM_TRACKS";
59    private static final String METADATA_KEY_DISC_NUMBER = "android.media.metadata.DISC_NUMBER";
60    private static final String METADATA_KEY_ALBUM_ARTIST = "android.media.metadata.ALBUM_ARTIST";
61
62    public static Object createRemoteControlClient(PendingIntent mbIntent) {
63        return new RemoteControlClient(mbIntent);
64    }
65
66    public static void setState(Object rccObj, int state) {
67        ((RemoteControlClient) rccObj).setPlaybackState(getRccStateFromState(state));
68    }
69
70    public static void setTransportControlFlags(Object rccObj, int actions) {
71        ((RemoteControlClient) rccObj).setTransportControlFlags(
72                getRccTransportControlFlagsFromActions(actions));
73    }
74
75    public static void setMetadata(Object rccObj, Bundle metadata) {
76        RemoteControlClient.MetadataEditor editor = ((RemoteControlClient) rccObj).editMetadata(
77                true);
78        buildOldMetadata(metadata, editor);
79        editor.apply();
80    }
81
82    public static void registerRemoteControlClient(Context context, Object rccObj) {
83        AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
84        am.registerRemoteControlClient((RemoteControlClient) rccObj);
85    }
86
87    public static void unregisterRemoteControlClient(Context context, Object rccObj) {
88        AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
89        am.unregisterRemoteControlClient((RemoteControlClient) rccObj);
90    }
91
92    static int getRccStateFromState(int state) {
93        switch (state) {
94            case STATE_CONNECTING:
95            case STATE_BUFFERING:
96                return RemoteControlClient.PLAYSTATE_BUFFERING;
97            case STATE_ERROR:
98                return RemoteControlClient.PLAYSTATE_ERROR;
99            case STATE_FAST_FORWARDING:
100                return RemoteControlClient.PLAYSTATE_FAST_FORWARDING;
101            case STATE_NONE:
102                return RCC_PLAYSTATE_NONE;
103            case STATE_PAUSED:
104                return RemoteControlClient.PLAYSTATE_PAUSED;
105            case STATE_PLAYING:
106                return RemoteControlClient.PLAYSTATE_PLAYING;
107            case STATE_REWINDING:
108                return RemoteControlClient.PLAYSTATE_REWINDING;
109            case STATE_SKIPPING_TO_PREVIOUS:
110                return RemoteControlClient.PLAYSTATE_SKIPPING_BACKWARDS;
111            case STATE_SKIPPING_TO_NEXT:
112                return RemoteControlClient.PLAYSTATE_SKIPPING_FORWARDS;
113            case STATE_STOPPED:
114                return RemoteControlClient.PLAYSTATE_STOPPED;
115            default:
116                return -1;
117        }
118    }
119
120    static int getRccTransportControlFlagsFromActions(int actions) {
121        int transportControlFlags = 0;
122        if ((actions & PlaybackStateCompat.ACTION_FAST_FORWARD) != 0) {
123            transportControlFlags |= RemoteControlClient.FLAG_KEY_MEDIA_FAST_FORWARD;
124        }
125        if ((actions & PlaybackStateCompat.ACTION_SKIP_TO_NEXT) != 0) {
126            transportControlFlags |= RemoteControlClient.FLAG_KEY_MEDIA_NEXT;
127        }
128        if ((actions & PlaybackStateCompat.ACTION_PAUSE) != 0) {
129            transportControlFlags |= RemoteControlClient.FLAG_KEY_MEDIA_PAUSE;
130        }
131        if ((actions & PlaybackStateCompat.ACTION_PLAY) != 0) {
132            transportControlFlags |= RemoteControlClient.FLAG_KEY_MEDIA_PLAY;
133        }
134        if ((actions & PlaybackStateCompat.ACTION_PLAY_PAUSE) != 0) {
135            transportControlFlags |= RemoteControlClient.FLAG_KEY_MEDIA_PLAY_PAUSE;
136        }
137        if ((actions & PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS) != 0) {
138            transportControlFlags |= RemoteControlClient.FLAG_KEY_MEDIA_PREVIOUS;
139        }
140        if ((actions & PlaybackStateCompat.ACTION_REWIND) != 0) {
141            transportControlFlags |= RemoteControlClient.FLAG_KEY_MEDIA_REWIND;
142        }
143        if ((actions & PlaybackStateCompat.ACTION_STOP) != 0) {
144            transportControlFlags |= RemoteControlClient.FLAG_KEY_MEDIA_STOP;
145        }
146        return transportControlFlags;
147    }
148
149    static void buildOldMetadata(Bundle metadata, RemoteControlClient.MetadataEditor editor) {
150        if (metadata.containsKey(METADATA_KEY_ALBUM)) {
151            editor.putString(MediaMetadataRetriever.METADATA_KEY_ALBUM,
152                    metadata.getString(METADATA_KEY_ALBUM));
153        }
154        if (metadata.containsKey(METADATA_KEY_ALBUM_ARTIST)) {
155            editor.putString(MediaMetadataRetriever.METADATA_KEY_ALBUMARTIST,
156                    metadata.getString(METADATA_KEY_ALBUM_ARTIST));
157        }
158        if (metadata.containsKey(METADATA_KEY_ARTIST)) {
159            editor.putString(MediaMetadataRetriever.METADATA_KEY_ARTIST,
160                    metadata.getString(METADATA_KEY_ARTIST));
161        }
162        if (metadata.containsKey(METADATA_KEY_AUTHOR)) {
163            editor.putString(MediaMetadataRetriever.METADATA_KEY_AUTHOR,
164                    metadata.getString(METADATA_KEY_AUTHOR));
165        }
166        if (metadata.containsKey(METADATA_KEY_COMPILATION)) {
167            editor.putString(MediaMetadataRetriever.METADATA_KEY_COMPILATION,
168                    metadata.getString(METADATA_KEY_COMPILATION));
169        }
170        if (metadata.containsKey(METADATA_KEY_COMPOSER)) {
171            editor.putString(MediaMetadataRetriever.METADATA_KEY_COMPOSER,
172                    metadata.getString(METADATA_KEY_COMPOSER));
173        }
174        if (metadata.containsKey(METADATA_KEY_DATE)) {
175            editor.putString(MediaMetadataRetriever.METADATA_KEY_DATE,
176                    metadata.getString(METADATA_KEY_DATE));
177        }
178        if (metadata.containsKey(METADATA_KEY_DISC_NUMBER)) {
179            editor.putLong(MediaMetadataRetriever.METADATA_KEY_DISC_NUMBER,
180                    metadata.getLong(METADATA_KEY_DISC_NUMBER));
181        }
182        if (metadata.containsKey(METADATA_KEY_DURATION)) {
183            editor.putLong(MediaMetadataRetriever.METADATA_KEY_DURATION,
184                    metadata.getLong(METADATA_KEY_DURATION));
185        }
186        if (metadata.containsKey(METADATA_KEY_GENRE)) {
187            editor.putString(MediaMetadataRetriever.METADATA_KEY_GENRE,
188                    metadata.getString(METADATA_KEY_GENRE));
189        }
190        if (metadata.containsKey(METADATA_KEY_NUM_TRACKS)) {
191            editor.putLong(MediaMetadataRetriever.METADATA_KEY_NUM_TRACKS,
192                    metadata.getLong(METADATA_KEY_NUM_TRACKS));
193        }
194        if (metadata.containsKey(METADATA_KEY_TITLE)) {
195            editor.putString(MediaMetadataRetriever.METADATA_KEY_TITLE,
196                    metadata.getString(METADATA_KEY_TITLE));
197        }
198        if (metadata.containsKey(METADATA_KEY_TRACK_NUMBER)) {
199            editor.putLong(MediaMetadataRetriever.METADATA_KEY_CD_TRACK_NUMBER,
200                    metadata.getLong(METADATA_KEY_TRACK_NUMBER));
201        }
202        if (metadata.containsKey(METADATA_KEY_WRITER)) {
203            editor.putString(MediaMetadataRetriever.METADATA_KEY_WRITER,
204                    metadata.getString(METADATA_KEY_WRITER));
205        }
206        if (metadata.containsKey(METADATA_KEY_YEAR)) {
207            editor.putString(MediaMetadataRetriever.METADATA_KEY_YEAR,
208                    metadata.getString(METADATA_KEY_YEAR));
209        }
210    }
211
212    public static interface Callback {
213        public void onCommand(String command, Bundle extras, ResultReceiver cb);
214
215        public boolean onMediaButtonEvent(Intent mediaButtonIntent);
216
217        public void onPlay();
218
219        public void onPause();
220
221        public void onSkipToNext();
222
223        public void onSkipToPrevious();
224
225        public void onFastForward();
226
227        public void onRewind();
228
229        public void onStop();
230
231        public void onSeekTo(long pos);
232
233        public void onSetRating(Object ratingObj);
234    }
235}
236