| /* |
| * 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 android.media; |
| |
| import android.app.ActivityManager; |
| import android.app.PendingIntent; |
| import android.app.PendingIntent.CanceledException; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.graphics.Bitmap; |
| import android.media.session.MediaController; |
| import android.media.session.MediaSession; |
| import android.media.session.MediaSessionLegacyHelper; |
| import android.media.session.MediaSessionManager; |
| import android.media.session.PlaybackState; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.SystemClock; |
| import android.os.UserHandle; |
| import android.util.DisplayMetrics; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| |
| import java.lang.ref.WeakReference; |
| import java.util.List; |
| |
| /** |
| * The RemoteController class is used to control media playback, display and update media metadata |
| * and playback status, published by applications using the {@link RemoteControlClient} class. |
| * <p> |
| * A RemoteController shall be registered through |
| * {@link AudioManager#registerRemoteController(RemoteController)} in order for the system to send |
| * media event updates to the {@link OnClientUpdateListener} listener set in the class constructor. |
| * Implement the methods of the interface to receive the information published by the active |
| * {@link RemoteControlClient} instances. |
| * <br>By default an {@link OnClientUpdateListener} implementation will not receive bitmaps for |
| * album art. Use {@link #setArtworkConfiguration(int, int)} to receive images as well. |
| * <p> |
| * Registration requires the {@link OnClientUpdateListener} listener to be one of the enabled |
| * notification listeners (see {@link android.service.notification.NotificationListenerService}). |
| * |
| * @deprecated Use {@link MediaController} instead. |
| */ |
| @Deprecated public final class RemoteController |
| { |
| private final static int MAX_BITMAP_DIMENSION = 512; |
| private final static int TRANSPORT_UNKNOWN = 0; |
| private final static String TAG = "RemoteController"; |
| private final static boolean DEBUG = false; |
| private final static boolean USE_SESSIONS = true; |
| private final static Object mGenLock = new Object(); |
| private final static Object mInfoLock = new Object(); |
| private final RcDisplay mRcd; |
| private final Context mContext; |
| private final AudioManager mAudioManager; |
| private final int mMaxBitmapDimension; |
| private MetadataEditor mMetadataEditor; |
| |
| private MediaSessionManager mSessionManager; |
| private MediaSessionManager.OnActiveSessionsChangedListener mSessionListener; |
| private MediaController.Callback mSessionCb = new MediaControllerCallback(); |
| |
| /** |
| * Synchronized on mGenLock |
| */ |
| private int mClientGenerationIdCurrent = 0; |
| |
| /** |
| * Synchronized on mInfoLock |
| */ |
| private boolean mIsRegistered = false; |
| private PendingIntent mClientPendingIntentCurrent; |
| private OnClientUpdateListener mOnClientUpdateListener; |
| private PlaybackInfo mLastPlaybackInfo; |
| private int mArtworkWidth = -1; |
| private int mArtworkHeight = -1; |
| private boolean mEnabled = true; |
| // synchronized on mInfoLock, for USE_SESSION apis. |
| private MediaController mCurrentSession; |
| |
| /** |
| * Class constructor. |
| * @param context the {@link Context}, must be non-null. |
| * @param updateListener the listener to be called whenever new client information is available, |
| * must be non-null. |
| * @throws IllegalArgumentException |
| */ |
| public RemoteController(Context context, OnClientUpdateListener updateListener) |
| throws IllegalArgumentException { |
| this(context, updateListener, null); |
| } |
| |
| /** |
| * Class constructor. |
| * @param context the {@link Context}, must be non-null. |
| * @param updateListener the listener to be called whenever new client information is available, |
| * must be non-null. |
| * @param looper the {@link Looper} on which to run the event loop, |
| * or null to use the current thread's looper. |
| * @throws java.lang.IllegalArgumentException |
| */ |
| public RemoteController(Context context, OnClientUpdateListener updateListener, Looper looper) |
| throws IllegalArgumentException { |
| if (context == null) { |
| throw new IllegalArgumentException("Invalid null Context"); |
| } |
| if (updateListener == null) { |
| throw new IllegalArgumentException("Invalid null OnClientUpdateListener"); |
| } |
| if (looper != null) { |
| mEventHandler = new EventHandler(this, looper); |
| } else { |
| Looper l = Looper.myLooper(); |
| if (l != null) { |
| mEventHandler = new EventHandler(this, l); |
| } else { |
| throw new IllegalArgumentException("Calling thread not associated with a looper"); |
| } |
| } |
| mOnClientUpdateListener = updateListener; |
| mContext = context; |
| mRcd = new RcDisplay(this); |
| mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); |
| mSessionManager = (MediaSessionManager) context |
| .getSystemService(Context.MEDIA_SESSION_SERVICE); |
| mSessionListener = new TopTransportSessionListener(); |
| |
| if (ActivityManager.isLowRamDeviceStatic()) { |
| mMaxBitmapDimension = MAX_BITMAP_DIMENSION; |
| } else { |
| final DisplayMetrics dm = context.getResources().getDisplayMetrics(); |
| mMaxBitmapDimension = Math.max(dm.widthPixels, dm.heightPixels); |
| } |
| } |
| |
| |
| /** |
| * Interface definition for the callbacks to be invoked whenever media events, metadata |
| * and playback status are available. |
| */ |
| public interface OnClientUpdateListener { |
| /** |
| * Called whenever all information, previously received through the other |
| * methods of the listener, is no longer valid and is about to be refreshed. |
| * This is typically called whenever a new {@link RemoteControlClient} has been selected |
| * by the system to have its media information published. |
| * @param clearing true if there is no selected RemoteControlClient and no information |
| * is available. |
| */ |
| public void onClientChange(boolean clearing); |
| |
| /** |
| * Called whenever the playback state has changed. |
| * It is called when no information is known about the playback progress in the media and |
| * the playback speed. |
| * @param state one of the playback states authorized |
| * in {@link RemoteControlClient#setPlaybackState(int)}. |
| */ |
| public void onClientPlaybackStateUpdate(int state); |
| /** |
| * Called whenever the playback state has changed, and playback position |
| * and speed are known. |
| * @param state one of the playback states authorized |
| * in {@link RemoteControlClient#setPlaybackState(int)}. |
| * @param stateChangeTimeMs the system time at which the state change was reported, |
| * expressed in ms. Based on {@link android.os.SystemClock#elapsedRealtime()}. |
| * @param currentPosMs a positive value for the current media playback position expressed |
| * in ms, a negative value if the position is temporarily unknown. |
| * @param speed a value expressed as a ratio of 1x playback: 1.0f is normal playback, |
| * 2.0f is 2x, 0.5f is half-speed, -2.0f is rewind at 2x speed. 0.0f means nothing is |
| * playing (e.g. when state is {@link RemoteControlClient#PLAYSTATE_ERROR}). |
| */ |
| public void onClientPlaybackStateUpdate(int state, long stateChangeTimeMs, |
| long currentPosMs, float speed); |
| /** |
| * Called whenever the transport control flags have changed. |
| * @param transportControlFlags one of the flags authorized |
| * in {@link RemoteControlClient#setTransportControlFlags(int)}. |
| */ |
| public void onClientTransportControlUpdate(int transportControlFlags); |
| /** |
| * Called whenever new metadata is available. |
| * See the {@link MediaMetadataEditor#putLong(int, long)}, |
| * {@link MediaMetadataEditor#putString(int, String)}, |
| * {@link MediaMetadataEditor#putBitmap(int, Bitmap)}, and |
| * {@link MediaMetadataEditor#putObject(int, Object)} methods for the various keys that |
| * can be queried. |
| * @param metadataEditor the container of the new metadata. |
| */ |
| public void onClientMetadataUpdate(MetadataEditor metadataEditor); |
| }; |
| |
| |
| /** |
| * @hide |
| */ |
| public String getRemoteControlClientPackageName() { |
| if (USE_SESSIONS) { |
| synchronized (mInfoLock) { |
| return mCurrentSession != null ? mCurrentSession.getPackageName() |
| : null; |
| } |
| } else { |
| return mClientPendingIntentCurrent != null ? |
| mClientPendingIntentCurrent.getCreatorPackage() : null; |
| } |
| } |
| |
| /** |
| * Return the estimated playback position of the current media track or a negative value |
| * if not available. |
| * |
| * <p>The value returned is estimated by the current process and may not be perfect. |
| * The time returned by this method is calculated from the last state change time based |
| * on the current play position at that time and the last known playback speed. |
| * An application may call {@link #setSynchronizationMode(int)} to apply |
| * a synchronization policy that will periodically re-sync the estimated position |
| * with the RemoteControlClient.</p> |
| * |
| * @return the current estimated playback position in milliseconds or a negative value |
| * if not available |
| * |
| * @see OnClientUpdateListener#onClientPlaybackStateUpdate(int, long, long, float) |
| */ |
| public long getEstimatedMediaPosition() { |
| if (USE_SESSIONS) { |
| synchronized (mInfoLock) { |
| if (mCurrentSession != null) { |
| PlaybackState state = mCurrentSession.getPlaybackState(); |
| if (state != null) { |
| return state.getPosition(); |
| } |
| } |
| } |
| } else { |
| final PlaybackInfo lastPlaybackInfo; |
| synchronized (mInfoLock) { |
| lastPlaybackInfo = mLastPlaybackInfo; |
| } |
| if (lastPlaybackInfo != null) { |
| if (!RemoteControlClient.playbackPositionShouldMove(lastPlaybackInfo.mState)) { |
| return lastPlaybackInfo.mCurrentPosMs; |
| } |
| |
| // Take the current position at the time of state change and |
| // estimate. |
| final long thenPos = lastPlaybackInfo.mCurrentPosMs; |
| if (thenPos < 0) { |
| return -1; |
| } |
| |
| final long now = SystemClock.elapsedRealtime(); |
| final long then = lastPlaybackInfo.mStateChangeTimeMs; |
| final long sinceThen = now - then; |
| final long scaledSinceThen = (long) (sinceThen * lastPlaybackInfo.mSpeed); |
| return thenPos + scaledSinceThen; |
| } |
| } |
| return -1; |
| } |
| |
| |
| /** |
| * Send a simulated key event for a media button to be received by the current client. |
| * To simulate a key press, you must first send a KeyEvent built with |
| * a {@link KeyEvent#ACTION_DOWN} action, then another event with the {@link KeyEvent#ACTION_UP} |
| * action. |
| * <p>The key event will be sent to the registered receiver |
| * (see {@link AudioManager#registerMediaButtonEventReceiver(PendingIntent)}) whose associated |
| * {@link RemoteControlClient}'s metadata and playback state is published (there may be |
| * none under some circumstances). |
| * @param keyEvent a {@link KeyEvent} instance whose key code is one of |
| * {@link KeyEvent#KEYCODE_MUTE}, |
| * {@link KeyEvent#KEYCODE_HEADSETHOOK}, |
| * {@link KeyEvent#KEYCODE_MEDIA_PLAY}, |
| * {@link KeyEvent#KEYCODE_MEDIA_PAUSE}, |
| * {@link KeyEvent#KEYCODE_MEDIA_PLAY_PAUSE}, |
| * {@link KeyEvent#KEYCODE_MEDIA_STOP}, |
| * {@link KeyEvent#KEYCODE_MEDIA_NEXT}, |
| * {@link KeyEvent#KEYCODE_MEDIA_PREVIOUS}, |
| * {@link KeyEvent#KEYCODE_MEDIA_REWIND}, |
| * {@link KeyEvent#KEYCODE_MEDIA_RECORD}, |
| * {@link KeyEvent#KEYCODE_MEDIA_FAST_FORWARD}, |
| * {@link KeyEvent#KEYCODE_MEDIA_CLOSE}, |
| * {@link KeyEvent#KEYCODE_MEDIA_EJECT}, |
| * or {@link KeyEvent#KEYCODE_MEDIA_AUDIO_TRACK}. |
| * @return true if the event was successfully sent, false otherwise. |
| * @throws IllegalArgumentException |
| */ |
| public boolean sendMediaKeyEvent(KeyEvent keyEvent) throws IllegalArgumentException { |
| if (!KeyEvent.isMediaKey(keyEvent.getKeyCode())) { |
| throw new IllegalArgumentException("not a media key event"); |
| } |
| if (USE_SESSIONS) { |
| synchronized (mInfoLock) { |
| if (mCurrentSession != null) { |
| return mCurrentSession.dispatchMediaButtonEvent(keyEvent); |
| } |
| return false; |
| } |
| } else { |
| final PendingIntent pi; |
| synchronized (mInfoLock) { |
| if (!mIsRegistered) { |
| Log.e(TAG, |
| "Cannot use sendMediaKeyEvent() from an unregistered RemoteController"); |
| return false; |
| } |
| if (!mEnabled) { |
| Log.e(TAG, "Cannot use sendMediaKeyEvent() from a disabled RemoteController"); |
| return false; |
| } |
| pi = mClientPendingIntentCurrent; |
| } |
| if (pi != null) { |
| Intent intent = new Intent(Intent.ACTION_MEDIA_BUTTON); |
| intent.putExtra(Intent.EXTRA_KEY_EVENT, keyEvent); |
| try { |
| pi.send(mContext, 0, intent); |
| } catch (CanceledException e) { |
| Log.e(TAG, "Error sending intent for media button down: ", e); |
| return false; |
| } |
| } else { |
| Log.i(TAG, "No-op when sending key click, no receiver right now"); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| |
| /** |
| * Sets the new playback position. |
| * This method can only be called on a registered RemoteController. |
| * @param timeMs a 0 or positive value for the new playback position, expressed in ms. |
| * @return true if the command to set the playback position was successfully sent. |
| * @throws IllegalArgumentException |
| */ |
| public boolean seekTo(long timeMs) throws IllegalArgumentException { |
| if (!mEnabled) { |
| Log.e(TAG, "Cannot use seekTo() from a disabled RemoteController"); |
| return false; |
| } |
| if (timeMs < 0) { |
| throw new IllegalArgumentException("illegal negative time value"); |
| } |
| synchronized (mInfoLock) { |
| if (mCurrentSession != null) { |
| mCurrentSession.getTransportControls().seekTo(timeMs); |
| } |
| } |
| return true; |
| } |
| |
| |
| /** |
| * @hide |
| * @param wantBitmap |
| * @param width |
| * @param height |
| * @return true if successful |
| * @throws IllegalArgumentException |
| */ |
| public boolean setArtworkConfiguration(boolean wantBitmap, int width, int height) |
| throws IllegalArgumentException { |
| synchronized (mInfoLock) { |
| if (wantBitmap) { |
| if ((width > 0) && (height > 0)) { |
| if (width > mMaxBitmapDimension) { width = mMaxBitmapDimension; } |
| if (height > mMaxBitmapDimension) { height = mMaxBitmapDimension; } |
| mArtworkWidth = width; |
| mArtworkHeight = height; |
| } else { |
| throw new IllegalArgumentException("Invalid dimensions"); |
| } |
| } else { |
| mArtworkWidth = -1; |
| mArtworkHeight = -1; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Set the maximum artwork image dimensions to be received in the metadata. |
| * No bitmaps will be received unless this has been specified. |
| * @param width the maximum width in pixels |
| * @param height the maximum height in pixels |
| * @return true if the artwork dimension was successfully set. |
| * @throws IllegalArgumentException |
| */ |
| public boolean setArtworkConfiguration(int width, int height) throws IllegalArgumentException { |
| return setArtworkConfiguration(true, width, height); |
| } |
| |
| /** |
| * Prevents this RemoteController from receiving artwork images. |
| * @return true if receiving artwork images was successfully disabled. |
| */ |
| public boolean clearArtworkConfiguration() { |
| return setArtworkConfiguration(false, -1, -1); |
| } |
| |
| |
| /** |
| * Default playback position synchronization mode where the RemoteControlClient is not |
| * asked regularly for its playback position to see if it has drifted from the estimated |
| * position. |
| */ |
| public static final int POSITION_SYNCHRONIZATION_NONE = 0; |
| |
| /** |
| * The playback position synchronization mode where the RemoteControlClient instances which |
| * expose their playback position to the framework, will be regularly polled to check |
| * whether any drift has been noticed between their estimated position and the one they report. |
| * Note that this mode should only ever be used when needing to display very accurate playback |
| * position, as regularly polling a RemoteControlClient for its position may have an impact |
| * on battery life (if applicable) when this query will trigger network transactions in the |
| * case of remote playback. |
| */ |
| public static final int POSITION_SYNCHRONIZATION_CHECK = 1; |
| |
| /** |
| * Set the playback position synchronization mode. |
| * Must be called on a registered RemoteController. |
| * @param sync {@link #POSITION_SYNCHRONIZATION_NONE} or {@link #POSITION_SYNCHRONIZATION_CHECK} |
| * @return true if the synchronization mode was successfully set. |
| * @throws IllegalArgumentException |
| */ |
| public boolean setSynchronizationMode(int sync) throws IllegalArgumentException { |
| if ((sync != POSITION_SYNCHRONIZATION_NONE) && (sync != POSITION_SYNCHRONIZATION_CHECK)) { |
| throw new IllegalArgumentException("Unknown synchronization mode " + sync); |
| } |
| if (!mIsRegistered) { |
| Log.e(TAG, "Cannot set synchronization mode on an unregistered RemoteController"); |
| return false; |
| } |
| mAudioManager.remoteControlDisplayWantsPlaybackPositionSync(mRcd, |
| POSITION_SYNCHRONIZATION_CHECK == sync); |
| return true; |
| } |
| |
| |
| /** |
| * Creates a {@link MetadataEditor} for updating metadata values of the editable keys of |
| * the current {@link RemoteControlClient}. |
| * This method can only be called on a registered RemoteController. |
| * @return a new MetadataEditor instance. |
| */ |
| public MetadataEditor editMetadata() { |
| MetadataEditor editor = new MetadataEditor(); |
| editor.mEditorMetadata = new Bundle(); |
| editor.mEditorArtwork = null; |
| editor.mMetadataChanged = true; |
| editor.mArtworkChanged = true; |
| editor.mEditableKeys = 0; |
| return editor; |
| } |
| |
| /** |
| * A class to read the metadata published by a {@link RemoteControlClient}, or send a |
| * {@link RemoteControlClient} new values for keys that can be edited. |
| */ |
| public class MetadataEditor extends MediaMetadataEditor { |
| /** |
| * @hide |
| */ |
| protected MetadataEditor() { } |
| |
| /** |
| * @hide |
| */ |
| protected MetadataEditor(Bundle metadata, long editableKeys) { |
| mEditorMetadata = metadata; |
| mEditableKeys = editableKeys; |
| |
| mEditorArtwork = (Bitmap) metadata.getParcelable( |
| String.valueOf(MediaMetadataEditor.BITMAP_KEY_ARTWORK)); |
| if (mEditorArtwork != null) { |
| cleanupBitmapFromBundle(MediaMetadataEditor.BITMAP_KEY_ARTWORK); |
| } |
| |
| mMetadataChanged = true; |
| mArtworkChanged = true; |
| mApplied = false; |
| } |
| |
| private void cleanupBitmapFromBundle(int key) { |
| if (METADATA_KEYS_TYPE.get(key, METADATA_TYPE_INVALID) == METADATA_TYPE_BITMAP) { |
| mEditorMetadata.remove(String.valueOf(key)); |
| } |
| } |
| |
| /** |
| * Applies all of the metadata changes that have been set since the MediaMetadataEditor |
| * instance was created with {@link RemoteController#editMetadata()} |
| * or since {@link #clear()} was called. |
| */ |
| public synchronized void apply() { |
| // "applying" a metadata bundle in RemoteController is only for sending edited |
| // key values back to the RemoteControlClient, so here we only care about the only |
| // editable key we support: RATING_KEY_BY_USER |
| if (!mMetadataChanged) { |
| return; |
| } |
| synchronized (mInfoLock) { |
| if (mCurrentSession != null) { |
| if (mEditorMetadata.containsKey( |
| String.valueOf(MediaMetadataEditor.RATING_KEY_BY_USER))) { |
| Rating rating = (Rating) getObject( |
| MediaMetadataEditor.RATING_KEY_BY_USER, null); |
| if (rating != null) { |
| mCurrentSession.getTransportControls().setRating(rating); |
| } |
| } |
| } |
| } |
| // NOT setting mApplied to true as this type of MetadataEditor will be applied |
| // multiple times, whenever the user of a RemoteController needs to change the |
| // metadata (e.g. user changes the rating of a song more than once during playback) |
| mApplied = false; |
| } |
| |
| } |
| |
| |
| //================================================== |
| // Implementation of IRemoteControlDisplay interface |
| private static class RcDisplay extends IRemoteControlDisplay.Stub { |
| private final WeakReference<RemoteController> mController; |
| |
| RcDisplay(RemoteController rc) { |
| mController = new WeakReference<RemoteController>(rc); |
| } |
| |
| public void setCurrentClientId(int genId, PendingIntent clientMediaIntent, |
| boolean clearing) { |
| final RemoteController rc = mController.get(); |
| if (rc == null) { |
| return; |
| } |
| boolean isNew = false; |
| synchronized(mGenLock) { |
| if (rc.mClientGenerationIdCurrent != genId) { |
| rc.mClientGenerationIdCurrent = genId; |
| isNew = true; |
| } |
| } |
| if (clientMediaIntent != null) { |
| sendMsg(rc.mEventHandler, MSG_NEW_PENDING_INTENT, SENDMSG_REPLACE, |
| genId /*arg1*/, 0, clientMediaIntent /*obj*/, 0 /*delay*/); |
| } |
| if (isNew || clearing) { |
| sendMsg(rc.mEventHandler, MSG_CLIENT_CHANGE, SENDMSG_REPLACE, |
| genId /*arg1*/, clearing ? 1 : 0, null /*obj*/, 0 /*delay*/); |
| } |
| } |
| |
| public void setEnabled(boolean enabled) { |
| final RemoteController rc = mController.get(); |
| if (rc == null) { |
| return; |
| } |
| sendMsg(rc.mEventHandler, MSG_DISPLAY_ENABLE, SENDMSG_REPLACE, |
| enabled ? 1 : 0 /*arg1*/, 0, null /*obj*/, 0 /*delay*/); |
| } |
| |
| public void setPlaybackState(int genId, int state, |
| long stateChangeTimeMs, long currentPosMs, float speed) { |
| final RemoteController rc = mController.get(); |
| if (rc == null) { |
| return; |
| } |
| if (DEBUG) { |
| Log.d(TAG, "> new playback state: genId="+genId |
| + " state="+ state |
| + " changeTime="+ stateChangeTimeMs |
| + " pos=" + currentPosMs |
| + "ms speed=" + speed); |
| } |
| |
| synchronized(mGenLock) { |
| if (rc.mClientGenerationIdCurrent != genId) { |
| return; |
| } |
| } |
| final PlaybackInfo playbackInfo = |
| new PlaybackInfo(state, stateChangeTimeMs, currentPosMs, speed); |
| sendMsg(rc.mEventHandler, MSG_NEW_PLAYBACK_INFO, SENDMSG_REPLACE, |
| genId /*arg1*/, 0, playbackInfo /*obj*/, 0 /*delay*/); |
| |
| } |
| |
| public void setTransportControlInfo(int genId, int transportControlFlags, |
| int posCapabilities) { |
| final RemoteController rc = mController.get(); |
| if (rc == null) { |
| return; |
| } |
| synchronized(mGenLock) { |
| if (rc.mClientGenerationIdCurrent != genId) { |
| return; |
| } |
| } |
| sendMsg(rc.mEventHandler, MSG_NEW_TRANSPORT_INFO, SENDMSG_REPLACE, |
| genId /*arg1*/, transportControlFlags /*arg2*/, |
| null /*obj*/, 0 /*delay*/); |
| } |
| |
| public void setMetadata(int genId, Bundle metadata) { |
| final RemoteController rc = mController.get(); |
| if (rc == null) { |
| return; |
| } |
| if (DEBUG) { Log.e(TAG, "setMetadata("+genId+")"); } |
| if (metadata == null) { |
| return; |
| } |
| synchronized(mGenLock) { |
| if (rc.mClientGenerationIdCurrent != genId) { |
| return; |
| } |
| } |
| sendMsg(rc.mEventHandler, MSG_NEW_METADATA, SENDMSG_QUEUE, |
| genId /*arg1*/, 0 /*arg2*/, |
| metadata /*obj*/, 0 /*delay*/); |
| } |
| |
| public void setArtwork(int genId, Bitmap artwork) { |
| final RemoteController rc = mController.get(); |
| if (rc == null) { |
| return; |
| } |
| if (DEBUG) { Log.v(TAG, "setArtwork("+genId+")"); } |
| synchronized(mGenLock) { |
| if (rc.mClientGenerationIdCurrent != genId) { |
| return; |
| } |
| } |
| Bundle metadata = new Bundle(1); |
| metadata.putParcelable(String.valueOf(MediaMetadataEditor.BITMAP_KEY_ARTWORK), artwork); |
| sendMsg(rc.mEventHandler, MSG_NEW_METADATA, SENDMSG_QUEUE, |
| genId /*arg1*/, 0 /*arg2*/, |
| metadata /*obj*/, 0 /*delay*/); |
| } |
| |
| public void setAllMetadata(int genId, Bundle metadata, Bitmap artwork) { |
| final RemoteController rc = mController.get(); |
| if (rc == null) { |
| return; |
| } |
| if (DEBUG) { Log.e(TAG, "setAllMetadata("+genId+")"); } |
| if ((metadata == null) && (artwork == null)) { |
| return; |
| } |
| synchronized(mGenLock) { |
| if (rc.mClientGenerationIdCurrent != genId) { |
| return; |
| } |
| } |
| if (metadata == null) { |
| metadata = new Bundle(1); |
| } |
| if (artwork != null) { |
| metadata.putParcelable(String.valueOf(MediaMetadataEditor.BITMAP_KEY_ARTWORK), |
| artwork); |
| } |
| sendMsg(rc.mEventHandler, MSG_NEW_METADATA, SENDMSG_QUEUE, |
| genId /*arg1*/, 0 /*arg2*/, |
| metadata /*obj*/, 0 /*delay*/); |
| } |
| } |
| |
| /** |
| * This receives updates when the current session changes. This is |
| * registered to receive the updates on the handler thread so it can call |
| * directly into the appropriate methods. |
| */ |
| private class MediaControllerCallback extends MediaController.Callback { |
| @Override |
| public void onPlaybackStateChanged(PlaybackState state) { |
| onNewPlaybackState(state); |
| } |
| |
| @Override |
| public void onMetadataChanged(MediaMetadata metadata) { |
| onNewMediaMetadata(metadata); |
| } |
| } |
| |
| /** |
| * Listens for changes to the active session stack and replaces the |
| * currently tracked session if it has changed. |
| */ |
| private class TopTransportSessionListener implements |
| MediaSessionManager.OnActiveSessionsChangedListener { |
| |
| @Override |
| public void onActiveSessionsChanged(List<MediaController> controllers) { |
| int size = controllers.size(); |
| for (int i = 0; i < size; i++) { |
| MediaController controller = controllers.get(i); |
| long flags = controller.getFlags(); |
| // We only care about sessions that handle transport controls, |
| // which will be true for apps using RCC |
| if ((flags & MediaSession.FLAG_HANDLES_TRANSPORT_CONTROLS) != 0) { |
| updateController(controller); |
| return; |
| } |
| } |
| updateController(null); |
| } |
| |
| } |
| |
| //================================================== |
| // Event handling |
| private final EventHandler mEventHandler; |
| private final static int MSG_NEW_PENDING_INTENT = 0; |
| private final static int MSG_NEW_PLAYBACK_INFO = 1; |
| private final static int MSG_NEW_TRANSPORT_INFO = 2; |
| private final static int MSG_NEW_METADATA = 3; // msg always has non-null obj parameter |
| private final static int MSG_CLIENT_CHANGE = 4; |
| private final static int MSG_DISPLAY_ENABLE = 5; |
| private final static int MSG_NEW_PLAYBACK_STATE = 6; |
| private final static int MSG_NEW_MEDIA_METADATA = 7; |
| |
| private class EventHandler extends Handler { |
| |
| public EventHandler(RemoteController rc, Looper looper) { |
| super(looper); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| switch(msg.what) { |
| case MSG_NEW_PENDING_INTENT: |
| onNewPendingIntent(msg.arg1, (PendingIntent) msg.obj); |
| break; |
| case MSG_NEW_PLAYBACK_INFO: |
| onNewPlaybackInfo(msg.arg1, (PlaybackInfo) msg.obj); |
| break; |
| case MSG_NEW_TRANSPORT_INFO: |
| onNewTransportInfo(msg.arg1, msg.arg2); |
| break; |
| case MSG_NEW_METADATA: |
| onNewMetadata(msg.arg1, (Bundle)msg.obj); |
| break; |
| case MSG_CLIENT_CHANGE: |
| onClientChange(msg.arg1, msg.arg2 == 1); |
| break; |
| case MSG_DISPLAY_ENABLE: |
| onDisplayEnable(msg.arg1 == 1); |
| break; |
| case MSG_NEW_PLAYBACK_STATE: |
| // same as new playback info but using new apis |
| onNewPlaybackState((PlaybackState) msg.obj); |
| break; |
| case MSG_NEW_MEDIA_METADATA: |
| onNewMediaMetadata((MediaMetadata) msg.obj); |
| break; |
| default: |
| Log.e(TAG, "unknown event " + msg.what); |
| } |
| } |
| } |
| |
| /** |
| * @hide |
| */ |
| void startListeningToSessions() { |
| final ComponentName listenerComponent = new ComponentName(mContext, |
| mOnClientUpdateListener.getClass()); |
| Handler handler = null; |
| if (Looper.myLooper() == null) { |
| handler = new Handler(Looper.getMainLooper()); |
| } |
| mSessionManager.addOnActiveSessionsChangedListener(mSessionListener, listenerComponent, |
| UserHandle.myUserId(), handler); |
| mSessionListener.onActiveSessionsChanged(mSessionManager |
| .getActiveSessions(listenerComponent)); |
| if (DEBUG) { |
| Log.d(TAG, "Registered session listener with component " + listenerComponent |
| + " for user " + UserHandle.myUserId()); |
| } |
| } |
| |
| /** |
| * @hide |
| */ |
| void stopListeningToSessions() { |
| mSessionManager.removeOnActiveSessionsChangedListener(mSessionListener); |
| if (DEBUG) { |
| Log.d(TAG, "Unregistered session listener for user " |
| + UserHandle.myUserId()); |
| } |
| } |
| |
| /** If the msg is already queued, replace it with this one. */ |
| private static final int SENDMSG_REPLACE = 0; |
| /** If the msg is already queued, ignore this one and leave the old. */ |
| private static final int SENDMSG_NOOP = 1; |
| /** If the msg is already queued, queue this one and leave the old. */ |
| private static final int SENDMSG_QUEUE = 2; |
| |
| private static void sendMsg(Handler handler, int msg, int existingMsgPolicy, |
| int arg1, int arg2, Object obj, int delayMs) { |
| if (handler == null) { |
| Log.e(TAG, "null event handler, will not deliver message " + msg); |
| return; |
| } |
| if (existingMsgPolicy == SENDMSG_REPLACE) { |
| handler.removeMessages(msg); |
| } else if (existingMsgPolicy == SENDMSG_NOOP && handler.hasMessages(msg)) { |
| return; |
| } |
| handler.sendMessageDelayed(handler.obtainMessage(msg, arg1, arg2, obj), delayMs); |
| } |
| |
| ///////////// These calls are used by the old APIs with RCC and RCD ////////////////////// |
| private void onNewPendingIntent(int genId, PendingIntent pi) { |
| synchronized(mGenLock) { |
| if (mClientGenerationIdCurrent != genId) { |
| return; |
| } |
| } |
| synchronized(mInfoLock) { |
| mClientPendingIntentCurrent = pi; |
| } |
| } |
| |
| private void onNewPlaybackInfo(int genId, PlaybackInfo pi) { |
| synchronized(mGenLock) { |
| if (mClientGenerationIdCurrent != genId) { |
| return; |
| } |
| } |
| final OnClientUpdateListener l; |
| synchronized(mInfoLock) { |
| l = this.mOnClientUpdateListener; |
| mLastPlaybackInfo = pi; |
| } |
| if (l != null) { |
| if (pi.mCurrentPosMs == RemoteControlClient.PLAYBACK_POSITION_ALWAYS_UNKNOWN) { |
| l.onClientPlaybackStateUpdate(pi.mState); |
| } else { |
| l.onClientPlaybackStateUpdate(pi.mState, pi.mStateChangeTimeMs, pi.mCurrentPosMs, |
| pi.mSpeed); |
| } |
| } |
| } |
| |
| private void onNewTransportInfo(int genId, int transportControlFlags) { |
| synchronized(mGenLock) { |
| if (mClientGenerationIdCurrent != genId) { |
| return; |
| } |
| } |
| final OnClientUpdateListener l; |
| synchronized(mInfoLock) { |
| l = mOnClientUpdateListener; |
| } |
| if (l != null) { |
| l.onClientTransportControlUpdate(transportControlFlags); |
| } |
| } |
| |
| /** |
| * @param genId |
| * @param metadata guaranteed to be always non-null |
| */ |
| private void onNewMetadata(int genId, Bundle metadata) { |
| synchronized(mGenLock) { |
| if (mClientGenerationIdCurrent != genId) { |
| return; |
| } |
| } |
| final OnClientUpdateListener l; |
| final MetadataEditor metadataEditor; |
| // prepare the received Bundle to be used inside a MetadataEditor |
| final long editableKeys = metadata.getLong( |
| String.valueOf(MediaMetadataEditor.KEY_EDITABLE_MASK), 0); |
| if (editableKeys != 0) { |
| metadata.remove(String.valueOf(MediaMetadataEditor.KEY_EDITABLE_MASK)); |
| } |
| synchronized(mInfoLock) { |
| l = mOnClientUpdateListener; |
| if ((mMetadataEditor != null) && (mMetadataEditor.mEditorMetadata != null)) { |
| if (mMetadataEditor.mEditorMetadata != metadata) { |
| // existing metadata, merge existing and new |
| mMetadataEditor.mEditorMetadata.putAll(metadata); |
| } |
| |
| mMetadataEditor.putBitmap(MediaMetadataEditor.BITMAP_KEY_ARTWORK, |
| (Bitmap)metadata.getParcelable( |
| String.valueOf(MediaMetadataEditor.BITMAP_KEY_ARTWORK))); |
| mMetadataEditor.cleanupBitmapFromBundle(MediaMetadataEditor.BITMAP_KEY_ARTWORK); |
| } else { |
| mMetadataEditor = new MetadataEditor(metadata, editableKeys); |
| } |
| metadataEditor = mMetadataEditor; |
| } |
| if (l != null) { |
| l.onClientMetadataUpdate(metadataEditor); |
| } |
| } |
| |
| private void onClientChange(int genId, boolean clearing) { |
| synchronized(mGenLock) { |
| if (mClientGenerationIdCurrent != genId) { |
| return; |
| } |
| } |
| final OnClientUpdateListener l; |
| synchronized(mInfoLock) { |
| l = mOnClientUpdateListener; |
| mMetadataEditor = null; |
| } |
| if (l != null) { |
| l.onClientChange(clearing); |
| } |
| } |
| |
| private void onDisplayEnable(boolean enabled) { |
| final OnClientUpdateListener l; |
| synchronized(mInfoLock) { |
| mEnabled = enabled; |
| l = this.mOnClientUpdateListener; |
| } |
| if (!enabled) { |
| // when disabling, reset all info sent to the user |
| final int genId; |
| synchronized (mGenLock) { |
| genId = mClientGenerationIdCurrent; |
| } |
| // send "stopped" state, happened "now", playback position is 0, speed 0.0f |
| final PlaybackInfo pi = new PlaybackInfo(RemoteControlClient.PLAYSTATE_STOPPED, |
| SystemClock.elapsedRealtime() /*stateChangeTimeMs*/, |
| 0 /*currentPosMs*/, 0.0f /*speed*/); |
| sendMsg(mEventHandler, MSG_NEW_PLAYBACK_INFO, SENDMSG_REPLACE, |
| genId /*arg1*/, 0 /*arg2, ignored*/, pi /*obj*/, 0 /*delay*/); |
| // send "blank" transport control info: no controls are supported |
| sendMsg(mEventHandler, MSG_NEW_TRANSPORT_INFO, SENDMSG_REPLACE, |
| genId /*arg1*/, 0 /*arg2, no flags*/, |
| null /*obj, ignored*/, 0 /*delay*/); |
| // send dummy metadata with empty string for title and artist, duration of 0 |
| Bundle metadata = new Bundle(3); |
| metadata.putString(String.valueOf(MediaMetadataRetriever.METADATA_KEY_TITLE), ""); |
| metadata.putString(String.valueOf(MediaMetadataRetriever.METADATA_KEY_ARTIST), ""); |
| metadata.putLong(String.valueOf(MediaMetadataRetriever.METADATA_KEY_DURATION), 0); |
| sendMsg(mEventHandler, MSG_NEW_METADATA, SENDMSG_QUEUE, |
| genId /*arg1*/, 0 /*arg2, ignored*/, metadata /*obj*/, 0 /*delay*/); |
| } |
| } |
| |
| ///////////// These calls are used by the new APIs with Sessions ////////////////////// |
| private void updateController(MediaController controller) { |
| if (DEBUG) { |
| Log.d(TAG, "Updating controller to " + controller + " previous controller is " |
| + mCurrentSession); |
| } |
| synchronized (mInfoLock) { |
| if (controller == null) { |
| if (mCurrentSession != null) { |
| mCurrentSession.unregisterCallback(mSessionCb); |
| mCurrentSession = null; |
| sendMsg(mEventHandler, MSG_CLIENT_CHANGE, SENDMSG_REPLACE, |
| 0 /* genId */, 1 /* clearing */, null /* obj */, 0 /* delay */); |
| } |
| } else if (mCurrentSession == null |
| || !controller.getSessionToken() |
| .equals(mCurrentSession.getSessionToken())) { |
| if (mCurrentSession != null) { |
| mCurrentSession.unregisterCallback(mSessionCb); |
| } |
| sendMsg(mEventHandler, MSG_CLIENT_CHANGE, SENDMSG_REPLACE, |
| 0 /* genId */, 0 /* clearing */, null /* obj */, 0 /* delay */); |
| mCurrentSession = controller; |
| mCurrentSession.registerCallback(mSessionCb, mEventHandler); |
| |
| PlaybackState state = controller.getPlaybackState(); |
| sendMsg(mEventHandler, MSG_NEW_PLAYBACK_STATE, SENDMSG_REPLACE, |
| 0 /* genId */, 0, state /* obj */, 0 /* delay */); |
| |
| MediaMetadata metadata = controller.getMetadata(); |
| sendMsg(mEventHandler, MSG_NEW_MEDIA_METADATA, SENDMSG_REPLACE, |
| 0 /* arg1 */, 0 /* arg2 */, metadata /* obj */, 0 /* delay */); |
| } |
| // else same controller, no need to update |
| } |
| } |
| |
| private void onNewPlaybackState(PlaybackState state) { |
| final OnClientUpdateListener l; |
| synchronized (mInfoLock) { |
| l = this.mOnClientUpdateListener; |
| } |
| if (l != null) { |
| int playstate = state == null ? RemoteControlClient.PLAYSTATE_NONE : PlaybackState |
| .getRccStateFromState(state.getState()); |
| if (state == null || state.getPosition() == PlaybackState.PLAYBACK_POSITION_UNKNOWN) { |
| l.onClientPlaybackStateUpdate(playstate); |
| } else { |
| l.onClientPlaybackStateUpdate(playstate, state.getLastPositionUpdateTime(), |
| state.getPosition(), state.getPlaybackSpeed()); |
| } |
| if (state != null) { |
| l.onClientTransportControlUpdate( |
| PlaybackState.getRccControlFlagsFromActions(state.getActions())); |
| } |
| } |
| } |
| |
| private void onNewMediaMetadata(MediaMetadata metadata) { |
| if (metadata == null) { |
| // RemoteController only handles non-null metadata |
| return; |
| } |
| final OnClientUpdateListener l; |
| final MetadataEditor metadataEditor; |
| // prepare the received Bundle to be used inside a MetadataEditor |
| synchronized(mInfoLock) { |
| l = mOnClientUpdateListener; |
| boolean canRate = mCurrentSession != null |
| && mCurrentSession.getRatingType() != Rating.RATING_NONE; |
| long editableKeys = canRate ? MediaMetadataEditor.RATING_KEY_BY_USER : 0; |
| Bundle legacyMetadata = MediaSessionLegacyHelper.getOldMetadata(metadata, |
| mArtworkWidth, mArtworkHeight); |
| mMetadataEditor = new MetadataEditor(legacyMetadata, editableKeys); |
| metadataEditor = mMetadataEditor; |
| } |
| if (l != null) { |
| l.onClientMetadataUpdate(metadataEditor); |
| } |
| } |
| |
| //================================================== |
| private static class PlaybackInfo { |
| int mState; |
| long mStateChangeTimeMs; |
| long mCurrentPosMs; |
| float mSpeed; |
| |
| PlaybackInfo(int state, long stateChangeTimeMs, long currentPosMs, float speed) { |
| mState = state; |
| mStateChangeTimeMs = stateChangeTimeMs; |
| mCurrentPosMs = currentPosMs; |
| mSpeed = speed; |
| } |
| } |
| |
| /** |
| * @hide |
| * Used by AudioManager to mark this instance as registered. |
| * @param registered |
| */ |
| void setIsRegistered(boolean registered) { |
| synchronized (mInfoLock) { |
| mIsRegistered = registered; |
| } |
| } |
| |
| /** |
| * @hide |
| * Used by AudioManager to access binder to be registered/unregistered inside MediaFocusControl |
| * @return |
| */ |
| RcDisplay getRcDisplay() { |
| return mRcd; |
| } |
| |
| /** |
| * @hide |
| * Used by AudioManager to read the current artwork dimension |
| * @return array containing width (index 0) and height (index 1) of currently set artwork size |
| */ |
| int[] getArtworkSize() { |
| synchronized (mInfoLock) { |
| int[] size = { mArtworkWidth, mArtworkHeight }; |
| return size; |
| } |
| } |
| |
| /** |
| * @hide |
| * Used by AudioManager to access user listener receiving the client update notifications |
| * @return |
| */ |
| OnClientUpdateListener getUpdateListener() { |
| return mOnClientUpdateListener; |
| } |
| } |
