mSubscriptions = new ArrayMap<>();
int mState = CONNECT_STATE_DISCONNECTED;
MediaServiceConnection mServiceConnection;
ServiceBinderWrapper mServiceBinderWrapper;
Messenger mCallbacksMessenger;
private String mRootId;
private MediaSessionCompat.Token mMediaSessionToken;
private Bundle mExtras;
public MediaBrowserImplBase(Context context, ComponentName serviceComponent,
ConnectionCallback callback, Bundle rootHints) {
if (context == null) {
throw new IllegalArgumentException("context must not be null");
}
if (serviceComponent == null) {
throw new IllegalArgumentException("service component must not be null");
}
if (callback == null) {
throw new IllegalArgumentException("connection callback must not be null");
}
mContext = context;
mServiceComponent = serviceComponent;
mCallback = callback;
mRootHints = rootHints == null ? null : new Bundle(rootHints);
}
@Override
public void connect() {
if (mState != CONNECT_STATE_DISCONNECTING && mState != CONNECT_STATE_DISCONNECTED) {
throw new IllegalStateException("connect() called while neigther disconnecting nor "
+ "disconnected (state=" + getStateLabel(mState) + ")");
}
mState = CONNECT_STATE_CONNECTING;
mHandler.post(new Runnable() {
@Override
public void run() {
// mState could be changed by the Runnable of disconnect()
if (mState == CONNECT_STATE_DISCONNECTING) {
return;
}
mState = CONNECT_STATE_CONNECTING;
// TODO: remove this extra check.
if (DEBUG) {
if (mServiceConnection != null) {
throw new RuntimeException("mServiceConnection should be null. Instead "
+ "it is " + mServiceConnection);
}
}
if (mServiceBinderWrapper != null) {
throw new RuntimeException("mServiceBinderWrapper should be null. Instead "
+ "it is " + mServiceBinderWrapper);
}
if (mCallbacksMessenger != null) {
throw new RuntimeException("mCallbacksMessenger should be null. Instead "
+ "it is " + mCallbacksMessenger);
}
final Intent intent = new Intent(MediaBrowserServiceCompat.SERVICE_INTERFACE);
intent.setComponent(mServiceComponent);
mServiceConnection = new MediaServiceConnection();
boolean bound = false;
try {
bound = mContext.bindService(intent, mServiceConnection,
Context.BIND_AUTO_CREATE);
} catch (Exception ex) {
Log.e(TAG, "Failed binding to service " + mServiceComponent);
}
if (!bound) {
// Tell them that it didn't work.
forceCloseConnection();
mCallback.onConnectionFailed();
}
if (DEBUG) {
Log.d(TAG, "connect...");
dump();
}
}
});
}
@Override
public void disconnect() {
// It's ok to call this any state, because allowing this lets apps not have
// to check isConnected() unnecessarily. They won't appreciate the extra
// assertions for this. We do everything we can here to go back to a sane state.
mState = CONNECT_STATE_DISCONNECTING;
mHandler.post(new Runnable() {
@Override
public void run() {
// connect() could be called before this. Then we will disconnect and reconnect.
if (mCallbacksMessenger != null) {
try {
mServiceBinderWrapper.disconnect(mCallbacksMessenger);
} catch (RemoteException ex) {
// We are disconnecting anyway. Log, just for posterity but it's not
// a big problem.
Log.w(TAG, "RemoteException during connect for " + mServiceComponent);
}
}
int state = mState;
forceCloseConnection();
// If the state was not CONNECT_STATE_DISCONNECTING, keep the state so that
// the operation came after disconnect() can be handled properly.
if (state != CONNECT_STATE_DISCONNECTING) {
mState = state;
}
if (DEBUG) {
Log.d(TAG, "disconnect...");
dump();
}
}
});
}
/**
* Null out the variables and unbind from the service. This doesn't include
* calling disconnect on the service, because we only try to do that in the
* clean shutdown cases.
*
* Everywhere that calls this EXCEPT for disconnect() should follow it with
* a call to mCallback.onConnectionFailed(). Disconnect doesn't do that callback
* for a clean shutdown, but everywhere else is a dirty shutdown and should
* notify the app.
*/
void forceCloseConnection() {
if (mServiceConnection != null) {
mContext.unbindService(mServiceConnection);
}
mState = CONNECT_STATE_DISCONNECTED;
mServiceConnection = null;
mServiceBinderWrapper = null;
mCallbacksMessenger = null;
mHandler.setCallbacksMessenger(null);
mRootId = null;
mMediaSessionToken = null;
}
@Override
public boolean isConnected() {
return mState == CONNECT_STATE_CONNECTED;
}
@Override
public @NonNull ComponentName getServiceComponent() {
if (!isConnected()) {
throw new IllegalStateException("getServiceComponent() called while not connected" +
" (state=" + mState + ")");
}
return mServiceComponent;
}
@Override
public @NonNull String getRoot() {
if (!isConnected()) {
throw new IllegalStateException("getRoot() called while not connected"
+ "(state=" + getStateLabel(mState) + ")");
}
return mRootId;
}
@Override
public @Nullable Bundle getExtras() {
if (!isConnected()) {
throw new IllegalStateException("getExtras() called while not connected (state="
+ getStateLabel(mState) + ")");
}
return mExtras;
}
@Override
public @NonNull MediaSessionCompat.Token getSessionToken() {
if (!isConnected()) {
throw new IllegalStateException("getSessionToken() called while not connected"
+ "(state=" + mState + ")");
}
return mMediaSessionToken;
}
@Override
public void subscribe(@NonNull String parentId, Bundle options,
@NonNull SubscriptionCallback callback) {
// Update or create the subscription.
Subscription sub = mSubscriptions.get(parentId);
if (sub == null) {
sub = new Subscription();
mSubscriptions.put(parentId, sub);
}
Bundle copiedOptions = options == null ? null : new Bundle(options);
sub.putCallback(copiedOptions, callback);
// If we are connected, tell the service that we are watching. If we aren't
// connected, the service will be told when we connect.
if (isConnected()) {
try {
mServiceBinderWrapper.addSubscription(parentId, callback.mToken, copiedOptions,
mCallbacksMessenger);
} catch (RemoteException e) {
// Process is crashing. We will disconnect, and upon reconnect we will
// automatically reregister. So nothing to do here.
Log.d(TAG, "addSubscription failed with RemoteException parentId=" + parentId);
}
}
}
@Override
public void unsubscribe(@NonNull String parentId, SubscriptionCallback callback) {
Subscription sub = mSubscriptions.get(parentId);
if (sub == null) {
return;
}
// Tell the service if necessary.
try {
if (callback == null) {
if (isConnected()) {
mServiceBinderWrapper.removeSubscription(parentId, null,
mCallbacksMessenger);
}
} else {
final List callbacks = sub.getCallbacks();
final List optionsList = sub.getOptionsList();
for (int i = callbacks.size() - 1; i >= 0; --i) {
if (callbacks.get(i) == callback) {
if (isConnected()) {
mServiceBinderWrapper.removeSubscription(
parentId, callback.mToken, mCallbacksMessenger);
}
callbacks.remove(i);
optionsList.remove(i);
}
}
}
} catch (RemoteException ex) {
// Process is crashing. We will disconnect, and upon reconnect we will
// automatically reregister. So nothing to do here.
Log.d(TAG, "removeSubscription failed with RemoteException parentId=" + parentId);
}
if (sub.isEmpty() || callback == null) {
mSubscriptions.remove(parentId);
}
}
@Override
public void getItem(@NonNull final String mediaId, @NonNull final ItemCallback cb) {
if (TextUtils.isEmpty(mediaId)) {
throw new IllegalArgumentException("mediaId is empty");
}
if (cb == null) {
throw new IllegalArgumentException("cb is null");
}
if (!isConnected()) {
Log.i(TAG, "Not connected, unable to retrieve the MediaItem.");
mHandler.post(new Runnable() {
@Override
public void run() {
cb.onError(mediaId);
}
});
return;
}
ResultReceiver receiver = new ItemReceiver(mediaId, cb, mHandler);
try {
mServiceBinderWrapper.getMediaItem(mediaId, receiver, mCallbacksMessenger);
} catch (RemoteException e) {
Log.i(TAG, "Remote error getting media item: " + mediaId);
mHandler.post(new Runnable() {
@Override
public void run() {
cb.onError(mediaId);
}
});
}
}
@Override
public void search(@NonNull final String query, final Bundle extras,
@NonNull final SearchCallback callback) {
if (!isConnected()) {
throw new IllegalStateException("search() called while not connected"
+ " (state=" + getStateLabel(mState) + ")");
}
ResultReceiver receiver = new SearchResultReceiver(query, extras, callback, mHandler);
try {
mServiceBinderWrapper.search(query, extras, receiver, mCallbacksMessenger);
} catch (RemoteException e) {
Log.i(TAG, "Remote error searching items with query: " + query, e);
mHandler.post(new Runnable() {
@Override
public void run() {
callback.onError(query, extras);
}
});
}
}
@Override
public void sendCustomAction(@NonNull final String action, final Bundle extras,
@Nullable final CustomActionCallback callback) {
if (!isConnected()) {
throw new IllegalStateException("Cannot send a custom action (" + action + ") with "
+ "extras " + extras + " because the browser is not connected to the "
+ "service.");
}
ResultReceiver receiver = new CustomActionResultReceiver(action, extras, callback,
mHandler);
try {
mServiceBinderWrapper.sendCustomAction(action, extras, receiver,
mCallbacksMessenger);
} catch (RemoteException e) {
Log.i(TAG, "Remote error sending a custom action: action=" + action + ", extras="
+ extras, e);
mHandler.post(new Runnable() {
@Override
public void run() {
callback.onError(action, extras, null);
}
});
}
}
@Override
public void onServiceConnected(final Messenger callback, final String root,
final MediaSessionCompat.Token session, final Bundle extra) {
// Check to make sure there hasn't been a disconnect or a different ServiceConnection.
if (!isCurrent(callback, "onConnect")) {
return;
}
// Don't allow them to call us twice.
if (mState != CONNECT_STATE_CONNECTING) {
Log.w(TAG, "onConnect from service while mState=" + getStateLabel(mState)
+ "... ignoring");
return;
}
mRootId = root;
mMediaSessionToken = session;
mExtras = extra;
mState = CONNECT_STATE_CONNECTED;
if (DEBUG) {
Log.d(TAG, "ServiceCallbacks.onConnect...");
dump();
}
mCallback.onConnected();
// we may receive some subscriptions before we are connected, so re-subscribe
// everything now
try {
for (Map.Entry subscriptionEntry
: mSubscriptions.entrySet()) {
String id = subscriptionEntry.getKey();
Subscription sub = subscriptionEntry.getValue();
List callbackList = sub.getCallbacks();
List optionsList = sub.getOptionsList();
for (int i = 0; i < callbackList.size(); ++i) {
mServiceBinderWrapper.addSubscription(id, callbackList.get(i).mToken,
optionsList.get(i), mCallbacksMessenger);
}
}
} catch (RemoteException ex) {
// Process is crashing. We will disconnect, and upon reconnect we will
// automatically reregister. So nothing to do here.
Log.d(TAG, "addSubscription failed with RemoteException.");
}
}
@Override
public void onConnectionFailed(final Messenger callback) {
Log.e(TAG, "onConnectFailed for " + mServiceComponent);
// Check to make sure there hasn't been a disconnect or a different ServiceConnection.
if (!isCurrent(callback, "onConnectFailed")) {
return;
}
// Don't allow them to call us twice.
if (mState != CONNECT_STATE_CONNECTING) {
Log.w(TAG, "onConnect from service while mState=" + getStateLabel(mState)
+ "... ignoring");
return;
}
// Clean up
forceCloseConnection();
// Tell the app.
mCallback.onConnectionFailed();
}
@Override
public void onLoadChildren(final Messenger callback, final String parentId,
final List list, final Bundle options) {
// Check that there hasn't been a disconnect or a different ServiceConnection.
if (!isCurrent(callback, "onLoadChildren")) {
return;
}
if (DEBUG) {
Log.d(TAG, "onLoadChildren for " + mServiceComponent + " id=" + parentId);
}
// Check that the subscription is still subscribed.
final Subscription subscription = mSubscriptions.get(parentId);
if (subscription == null) {
if (DEBUG) {
Log.d(TAG, "onLoadChildren for id that isn't subscribed id=" + parentId);
}
return;
}
// Tell the app.
SubscriptionCallback subscriptionCallback = subscription.getCallback(options);
if (subscriptionCallback != null) {
if (options == null) {
if (list == null) {
subscriptionCallback.onError(parentId);
} else {
subscriptionCallback.onChildrenLoaded(parentId, list);
}
} else {
if (list == null) {
subscriptionCallback.onError(parentId, options);
} else {
subscriptionCallback.onChildrenLoaded(parentId, list, options);
}
}
}
}
/**
* For debugging.
*/
private static String getStateLabel(int state) {
switch (state) {
case CONNECT_STATE_DISCONNECTING:
return "CONNECT_STATE_DISCONNECTING";
case CONNECT_STATE_DISCONNECTED:
return "CONNECT_STATE_DISCONNECTED";
case CONNECT_STATE_CONNECTING:
return "CONNECT_STATE_CONNECTING";
case CONNECT_STATE_CONNECTED:
return "CONNECT_STATE_CONNECTED";
case CONNECT_STATE_SUSPENDED:
return "CONNECT_STATE_SUSPENDED";
default:
return "UNKNOWN/" + state;
}
}
/**
* Return true if {@code callback} is the current ServiceCallbacks. Also logs if it's not.
*/
@SuppressWarnings("ReferenceEquality")
private boolean isCurrent(Messenger callback, String funcName) {
if (mCallbacksMessenger != callback || mState == CONNECT_STATE_DISCONNECTING
|| mState == CONNECT_STATE_DISCONNECTED) {
if (mState != CONNECT_STATE_DISCONNECTING && mState != CONNECT_STATE_DISCONNECTED) {
Log.i(TAG, funcName + " for " + mServiceComponent + " with mCallbacksMessenger="
+ mCallbacksMessenger + " this=" + this);
}
return false;
}
return true;
}
/**
* Log internal state.
*/
void dump() {
Log.d(TAG, "MediaBrowserCompat...");
Log.d(TAG, " mServiceComponent=" + mServiceComponent);
Log.d(TAG, " mCallback=" + mCallback);
Log.d(TAG, " mRootHints=" + mRootHints);
Log.d(TAG, " mState=" + getStateLabel(mState));
Log.d(TAG, " mServiceConnection=" + mServiceConnection);
Log.d(TAG, " mServiceBinderWrapper=" + mServiceBinderWrapper);
Log.d(TAG, " mCallbacksMessenger=" + mCallbacksMessenger);
Log.d(TAG, " mRootId=" + mRootId);
Log.d(TAG, " mMediaSessionToken=" + mMediaSessionToken);
}
/**
* ServiceConnection to the other app.
*/
private class MediaServiceConnection implements ServiceConnection {
MediaServiceConnection() {
}
@Override
public void onServiceConnected(final ComponentName name, final IBinder binder) {
postOrRun(new Runnable() {
@Override
public void run() {
if (DEBUG) {
Log.d(TAG, "MediaServiceConnection.onServiceConnected name=" + name
+ " binder=" + binder);
dump();
}
// Make sure we are still the current connection, and that they haven't
// called disconnect().
if (!isCurrent("onServiceConnected")) {
return;
}
// Save their binder
mServiceBinderWrapper = new ServiceBinderWrapper(binder, mRootHints);
// We make a new mServiceCallbacks each time we connect so that we can drop
// responses from previous connections.
mCallbacksMessenger = new Messenger(mHandler);
mHandler.setCallbacksMessenger(mCallbacksMessenger);
mState = CONNECT_STATE_CONNECTING;
// Call connect, which is async. When we get a response from that we will
// say that we're connected.
try {
if (DEBUG) {
Log.d(TAG, "ServiceCallbacks.onConnect...");
dump();
}
mServiceBinderWrapper.connect(mContext, mCallbacksMessenger);
} catch (RemoteException ex) {
// Connect failed, which isn't good. But the auto-reconnect on the
// service will take over and we will come back. We will also get the
// onServiceDisconnected, which has all the cleanup code. So let that
// do it.
Log.w(TAG, "RemoteException during connect for " + mServiceComponent);
if (DEBUG) {
Log.d(TAG, "ServiceCallbacks.onConnect...");
dump();
}
}
}
});
}
@Override
public void onServiceDisconnected(final ComponentName name) {
postOrRun(new Runnable() {
@Override
public void run() {
if (DEBUG) {
Log.d(TAG, "MediaServiceConnection.onServiceDisconnected name=" + name
+ " this=" + this + " mServiceConnection=" +
mServiceConnection);
dump();
}
// Make sure we are still the current connection, and that they haven't
// called disconnect().
if (!isCurrent("onServiceDisconnected")) {
return;
}
// Clear out what we set in onServiceConnected
mServiceBinderWrapper = null;
mCallbacksMessenger = null;
mHandler.setCallbacksMessenger(null);
// And tell the app that it's suspended.
mState = CONNECT_STATE_SUSPENDED;
mCallback.onConnectionSuspended();
}
});
}
private void postOrRun(Runnable r) {
if (Thread.currentThread() == mHandler.getLooper().getThread()) {
r.run();
} else {
mHandler.post(r);
}
}
/**
* Return true if this is the current ServiceConnection. Also logs if it's not.
*/
boolean isCurrent(String funcName) {
if (mServiceConnection != this || mState == CONNECT_STATE_DISCONNECTING
|| mState == CONNECT_STATE_DISCONNECTED) {
if (mState != CONNECT_STATE_DISCONNECTING
&& mState != CONNECT_STATE_DISCONNECTED) {
// Check mState, because otherwise this log is noisy.
Log.i(TAG, funcName + " for " + mServiceComponent +
" with mServiceConnection=" + mServiceConnection + " this=" + this);
}
return false;
}
return true;
}
}
}
@RequiresApi(21)
static class MediaBrowserImplApi21 implements MediaBrowserImpl, MediaBrowserServiceCallbackImpl,
ConnectionCallback.ConnectionCallbackInternal {
protected final Object mBrowserObj;
protected final Bundle mRootHints;
protected final CallbackHandler mHandler = new CallbackHandler(this);
private final ArrayMap mSubscriptions = new ArrayMap<>();
protected ServiceBinderWrapper mServiceBinderWrapper;
protected Messenger mCallbacksMessenger;
private MediaSessionCompat.Token mMediaSessionToken;
public MediaBrowserImplApi21(Context context, ComponentName serviceComponent,
ConnectionCallback callback, Bundle rootHints) {
if (rootHints == null) {
rootHints = new Bundle();
}
rootHints.putInt(EXTRA_CLIENT_VERSION, CLIENT_VERSION_CURRENT);
mRootHints = new Bundle(rootHints);
callback.setInternalConnectionCallback(this);
mBrowserObj = MediaBrowserCompatApi21.createBrowser(context, serviceComponent,
callback.mConnectionCallbackObj, mRootHints);
}
@Override
public void connect() {
MediaBrowserCompatApi21.connect(mBrowserObj);
}
@Override
public void disconnect() {
if (mServiceBinderWrapper != null && mCallbacksMessenger != null) {
try {
mServiceBinderWrapper.unregisterCallbackMessenger(mCallbacksMessenger);
} catch (RemoteException e) {
Log.i(TAG, "Remote error unregistering client messenger." );
}
}
MediaBrowserCompatApi21.disconnect(mBrowserObj);
}
@Override
public boolean isConnected() {
return MediaBrowserCompatApi21.isConnected(mBrowserObj);
}
@Override
public ComponentName getServiceComponent() {
return MediaBrowserCompatApi21.getServiceComponent(mBrowserObj);
}
@NonNull
@Override
public String getRoot() {
return MediaBrowserCompatApi21.getRoot(mBrowserObj);
}
@Nullable
@Override
public Bundle getExtras() {
return MediaBrowserCompatApi21.getExtras(mBrowserObj);
}
@NonNull
@Override
public MediaSessionCompat.Token getSessionToken() {
if (mMediaSessionToken == null) {
mMediaSessionToken = MediaSessionCompat.Token.fromToken(
MediaBrowserCompatApi21.getSessionToken(mBrowserObj));
}
return mMediaSessionToken;
}
@Override
public void subscribe(@NonNull final String parentId, final Bundle options,
@NonNull final SubscriptionCallback callback) {
// Update or create the subscription.
Subscription sub = mSubscriptions.get(parentId);
if (sub == null) {
sub = new Subscription();
mSubscriptions.put(parentId, sub);
}
callback.setSubscription(sub);
Bundle copiedOptions = options == null ? null : new Bundle(options);
sub.putCallback(copiedOptions, callback);
if (mServiceBinderWrapper == null) {
// TODO: When MediaBrowser is connected to framework's MediaBrowserService,
// subscribe with options won't work properly.
MediaBrowserCompatApi21.subscribe(
mBrowserObj, parentId, callback.mSubscriptionCallbackObj);
} else {
try {
mServiceBinderWrapper.addSubscription(
parentId, callback.mToken, copiedOptions, mCallbacksMessenger);
} catch (RemoteException e) {
// Process is crashing. We will disconnect, and upon reconnect we will
// automatically reregister. So nothing to do here.
Log.i(TAG, "Remote error subscribing media item: " + parentId);
}
}
}
@Override
public void unsubscribe(@NonNull String parentId, SubscriptionCallback callback) {
Subscription sub = mSubscriptions.get(parentId);
if (sub == null) {
return;
}
if (mServiceBinderWrapper == null) {
if (callback == null) {
MediaBrowserCompatApi21.unsubscribe(mBrowserObj, parentId);
} else {
final List callbacks = sub.getCallbacks();
final List optionsList = sub.getOptionsList();
for (int i = callbacks.size() - 1; i >= 0; --i) {
if (callbacks.get(i) == callback) {
callbacks.remove(i);
optionsList.remove(i);
}
}
if (callbacks.size() == 0) {
MediaBrowserCompatApi21.unsubscribe(mBrowserObj, parentId);
}
}
} else {
// Tell the service if necessary.
try {
if (callback == null) {
mServiceBinderWrapper.removeSubscription(parentId, null,
mCallbacksMessenger);
} else {
final List callbacks = sub.getCallbacks();
final List optionsList = sub.getOptionsList();
for (int i = callbacks.size() - 1; i >= 0; --i) {
if (callbacks.get(i) == callback) {
mServiceBinderWrapper.removeSubscription(
parentId, callback.mToken, mCallbacksMessenger);
callbacks.remove(i);
optionsList.remove(i);
}
}
}
} catch (RemoteException ex) {
// Process is crashing. We will disconnect, and upon reconnect we will
// automatically reregister. So nothing to do here.
Log.d(TAG, "removeSubscription failed with RemoteException parentId="
+ parentId);
}
}
if (sub.isEmpty() || callback == null) {
mSubscriptions.remove(parentId);
}
}
@Override
public void getItem(@NonNull final String mediaId, @NonNull final ItemCallback cb) {
if (TextUtils.isEmpty(mediaId)) {
throw new IllegalArgumentException("mediaId is empty");
}
if (cb == null) {
throw new IllegalArgumentException("cb is null");
}
if (!MediaBrowserCompatApi21.isConnected(mBrowserObj)) {
Log.i(TAG, "Not connected, unable to retrieve the MediaItem.");
mHandler.post(new Runnable() {
@Override
public void run() {
cb.onError(mediaId);
}
});
return;
}
if (mServiceBinderWrapper == null) {
mHandler.post(new Runnable() {
@Override
public void run() {
// Default framework implementation.
cb.onError(mediaId);
}
});
return;
}
ResultReceiver receiver = new ItemReceiver(mediaId, cb, mHandler);
try {
mServiceBinderWrapper.getMediaItem(mediaId, receiver, mCallbacksMessenger);
} catch (RemoteException e) {
Log.i(TAG, "Remote error getting media item: " + mediaId);
mHandler.post(new Runnable() {
@Override
public void run() {
cb.onError(mediaId);
}
});
}
}
@Override
public void search(@NonNull final String query, final Bundle extras,
@NonNull final SearchCallback callback) {
if (!isConnected()) {
throw new IllegalStateException("search() called while not connected");
}
if (mServiceBinderWrapper == null) {
Log.i(TAG, "The connected service doesn't support search.");
mHandler.post(new Runnable() {
@Override
public void run() {
// Default framework implementation.
callback.onError(query, extras);
}
});
return;
}
ResultReceiver receiver = new SearchResultReceiver(query, extras, callback, mHandler);
try {
mServiceBinderWrapper.search(query, extras, receiver, mCallbacksMessenger);
} catch (RemoteException e) {
Log.i(TAG, "Remote error searching items with query: " + query, e);
mHandler.post(new Runnable() {
@Override
public void run() {
callback.onError(query, extras);
}
});
}
}
@Override
public void sendCustomAction(final String action, final Bundle extras,
final CustomActionCallback callback) {
if (!isConnected()) {
throw new IllegalStateException("Cannot send a custom action (" + action + ") with "
+ "extras " + extras + " because the browser is not connected to the "
+ "service.");
}
if (mServiceBinderWrapper == null) {
Log.i(TAG, "The connected service doesn't support sendCustomAction.");
mHandler.post(new Runnable() {
@Override
public void run() {
callback.onError(action, extras, null);
}
});
}
ResultReceiver receiver = new CustomActionResultReceiver(action, extras, callback,
mHandler);
try {
mServiceBinderWrapper.sendCustomAction(action, extras, receiver,
mCallbacksMessenger);
} catch (RemoteException e) {
Log.i(TAG, "Remote error sending a custom action: action=" + action + ", extras="
+ extras, e);
mHandler.post(new Runnable() {
@Override
public void run() {
callback.onError(action, extras, null);
}
});
}
}
@Override
public void onConnected() {
Bundle extras = MediaBrowserCompatApi21.getExtras(mBrowserObj);
if (extras == null) {
return;
}
IBinder serviceBinder = BundleCompat.getBinder(extras, EXTRA_MESSENGER_BINDER);
if (serviceBinder != null) {
mServiceBinderWrapper = new ServiceBinderWrapper(serviceBinder, mRootHints);
mCallbacksMessenger = new Messenger(mHandler);
mHandler.setCallbacksMessenger(mCallbacksMessenger);
try {
mServiceBinderWrapper.registerCallbackMessenger(mCallbacksMessenger);
} catch (RemoteException e) {
Log.i(TAG, "Remote error registering client messenger." );
}
}
IMediaSession sessionToken = IMediaSession.Stub.asInterface(
BundleCompat.getBinder(extras, EXTRA_SESSION_BINDER));
if (sessionToken != null) {
mMediaSessionToken = MediaSessionCompat.Token.fromToken(
MediaBrowserCompatApi21.getSessionToken(mBrowserObj), sessionToken);
}
}
@Override
public void onConnectionSuspended() {
mServiceBinderWrapper = null;
mCallbacksMessenger = null;
mMediaSessionToken = null;
mHandler.setCallbacksMessenger(null);
}
@Override
public void onConnectionFailed() {
// Do noting
}
@Override
public void onServiceConnected(final Messenger callback, final String root,
final MediaSessionCompat.Token session, final Bundle extra) {
// This method will not be called.
}
@Override
public void onConnectionFailed(Messenger callback) {
// This method will not be called.
}
@Override
@SuppressWarnings("ReferenceEquality")
public void onLoadChildren(Messenger callback, String parentId, List list, Bundle options) {
if (mCallbacksMessenger != callback) {
return;
}
// Check that the subscription is still subscribed.
Subscription subscription = mSubscriptions.get(parentId);
if (subscription == null) {
if (DEBUG) {
Log.d(TAG, "onLoadChildren for id that isn't subscribed id=" + parentId);
}
return;
}
// Tell the app.
SubscriptionCallback subscriptionCallback = subscription.getCallback(options);
if (subscriptionCallback != null) {
if (options == null) {
if (list == null) {
subscriptionCallback.onError(parentId);
} else {
subscriptionCallback.onChildrenLoaded(parentId, list);
}
} else {
if (list == null) {
subscriptionCallback.onError(parentId, options);
} else {
subscriptionCallback.onChildrenLoaded(parentId, list, options);
}
}
}
}
}
@RequiresApi(23)
static class MediaBrowserImplApi23 extends MediaBrowserImplApi21 {
public MediaBrowserImplApi23(Context context, ComponentName serviceComponent,
ConnectionCallback callback, Bundle rootHints) {
super(context, serviceComponent, callback, rootHints);
}
@Override
public void getItem(@NonNull final String mediaId, @NonNull final ItemCallback cb) {
if (mServiceBinderWrapper == null) {
MediaBrowserCompatApi23.getItem(mBrowserObj, mediaId, cb.mItemCallbackObj);
} else {
super.getItem(mediaId, cb);
}
}
}
// TODO: Rename to MediaBrowserImplApi26 once O is released
@RequiresApi(26)
static class MediaBrowserImplApi24 extends MediaBrowserImplApi23 {
public MediaBrowserImplApi24(Context context, ComponentName serviceComponent,
ConnectionCallback callback, Bundle rootHints) {
super(context, serviceComponent, callback, rootHints);
}
@Override
public void subscribe(@NonNull String parentId, @NonNull Bundle options,
@NonNull SubscriptionCallback callback) {
if (options == null) {
MediaBrowserCompatApi21.subscribe(
mBrowserObj, parentId, callback.mSubscriptionCallbackObj);
} else {
MediaBrowserCompatApi24.subscribe(
mBrowserObj, parentId, options, callback.mSubscriptionCallbackObj);
}
}
@Override
public void unsubscribe(@NonNull String parentId, SubscriptionCallback callback) {
if (callback == null) {
MediaBrowserCompatApi21.unsubscribe(mBrowserObj, parentId);
} else {
MediaBrowserCompatApi24.unsubscribe(mBrowserObj, parentId,
callback.mSubscriptionCallbackObj);
}
}
}
private static class Subscription {
private final List mCallbacks;
private final List mOptionsList;
public Subscription() {
mCallbacks = new ArrayList<>();
mOptionsList = new ArrayList<>();
}
public boolean isEmpty() {
return mCallbacks.isEmpty();
}
public List getOptionsList() {
return mOptionsList;
}
public List getCallbacks() {
return mCallbacks;
}
public SubscriptionCallback getCallback(Bundle options) {
for (int i = 0; i < mOptionsList.size(); ++i) {
if (MediaBrowserCompatUtils.areSameOptions(mOptionsList.get(i), options)) {
return mCallbacks.get(i);
}
}
return null;
}
public void putCallback(Bundle options, SubscriptionCallback callback) {
for (int i = 0; i < mOptionsList.size(); ++i) {
if (MediaBrowserCompatUtils.areSameOptions(mOptionsList.get(i), options)) {
mCallbacks.set(i, callback);
return;
}
}
mCallbacks.add(callback);
mOptionsList.add(options);
}
}
private static class CallbackHandler extends Handler {
private final WeakReference mCallbackImplRef;
private WeakReference mCallbacksMessengerRef;
CallbackHandler(MediaBrowserServiceCallbackImpl callbackImpl) {
super();
mCallbackImplRef = new WeakReference<>(callbackImpl);
}
@Override
public void handleMessage(Message msg) {
if (mCallbacksMessengerRef == null || mCallbacksMessengerRef.get() == null ||
mCallbackImplRef.get() == null) {
return;
}
Bundle data = msg.getData();
data.setClassLoader(MediaSessionCompat.class.getClassLoader());
MediaBrowserServiceCallbackImpl serviceCallback = mCallbackImplRef.get();
Messenger callbacksMessenger = mCallbacksMessengerRef.get();
try {
switch (msg.what) {
case SERVICE_MSG_ON_CONNECT:
serviceCallback.onServiceConnected(callbacksMessenger,
data.getString(DATA_MEDIA_ITEM_ID),
(MediaSessionCompat.Token) data.getParcelable(
DATA_MEDIA_SESSION_TOKEN),
data.getBundle(DATA_ROOT_HINTS));
break;
case SERVICE_MSG_ON_CONNECT_FAILED:
serviceCallback.onConnectionFailed(callbacksMessenger);
break;
case SERVICE_MSG_ON_LOAD_CHILDREN:
serviceCallback.onLoadChildren(callbacksMessenger,
data.getString(DATA_MEDIA_ITEM_ID),
data.getParcelableArrayList(DATA_MEDIA_ITEM_LIST),
data.getBundle(DATA_OPTIONS));
break;
default:
Log.w(TAG, "Unhandled message: " + msg
+ "\n Client version: " + CLIENT_VERSION_CURRENT
+ "\n Service version: " + msg.arg1);
}
} catch (BadParcelableException e) {
// Do not print the exception here, since it is already done by the Parcel class.
Log.e(TAG, "Could not unparcel the data.");
// If an error happened while connecting, disconnect from the service.
if (msg.what == SERVICE_MSG_ON_CONNECT) {
serviceCallback.onConnectionFailed(callbacksMessenger);
}
}
}
void setCallbacksMessenger(Messenger callbacksMessenger) {
mCallbacksMessengerRef = new WeakReference<>(callbacksMessenger);
}
}
private static class ServiceBinderWrapper {
private Messenger mMessenger;
private Bundle mRootHints;
public ServiceBinderWrapper(IBinder target, Bundle rootHints) {
mMessenger = new Messenger(target);
mRootHints = rootHints;
}
void connect(Context context, Messenger callbacksMessenger)
throws RemoteException {
Bundle data = new Bundle();
data.putString(DATA_PACKAGE_NAME, context.getPackageName());
data.putBundle(DATA_ROOT_HINTS, mRootHints);
sendRequest(CLIENT_MSG_CONNECT, data, callbacksMessenger);
}
void disconnect(Messenger callbacksMessenger) throws RemoteException {
sendRequest(CLIENT_MSG_DISCONNECT, null, callbacksMessenger);
}
void addSubscription(String parentId, IBinder callbackToken, Bundle options,
Messenger callbacksMessenger)
throws RemoteException {
Bundle data = new Bundle();
data.putString(DATA_MEDIA_ITEM_ID, parentId);
BundleCompat.putBinder(data, DATA_CALLBACK_TOKEN, callbackToken);
data.putBundle(DATA_OPTIONS, options);
sendRequest(CLIENT_MSG_ADD_SUBSCRIPTION, data, callbacksMessenger);
}
void removeSubscription(String parentId, IBinder callbackToken,
Messenger callbacksMessenger)
throws RemoteException {
Bundle data = new Bundle();
data.putString(DATA_MEDIA_ITEM_ID, parentId);
BundleCompat.putBinder(data, DATA_CALLBACK_TOKEN, callbackToken);
sendRequest(CLIENT_MSG_REMOVE_SUBSCRIPTION, data, callbacksMessenger);
}
void getMediaItem(String mediaId, ResultReceiver receiver, Messenger callbacksMessenger)
throws RemoteException {
Bundle data = new Bundle();
data.putString(DATA_MEDIA_ITEM_ID, mediaId);
data.putParcelable(DATA_RESULT_RECEIVER, receiver);
sendRequest(CLIENT_MSG_GET_MEDIA_ITEM, data, callbacksMessenger);
}
void registerCallbackMessenger(Messenger callbackMessenger) throws RemoteException {
Bundle data = new Bundle();
data.putBundle(DATA_ROOT_HINTS, mRootHints);
sendRequest(CLIENT_MSG_REGISTER_CALLBACK_MESSENGER, data, callbackMessenger);
}
void unregisterCallbackMessenger(Messenger callbackMessenger) throws RemoteException {
sendRequest(CLIENT_MSG_UNREGISTER_CALLBACK_MESSENGER, null, callbackMessenger);
}
void search(String query, Bundle extras, ResultReceiver receiver,
Messenger callbacksMessenger) throws RemoteException {
Bundle data = new Bundle();
data.putString(DATA_SEARCH_QUERY, query);
data.putBundle(DATA_SEARCH_EXTRAS, extras);
data.putParcelable(DATA_RESULT_RECEIVER, receiver);
sendRequest(CLIENT_MSG_SEARCH, data, callbacksMessenger);
}
void sendCustomAction(String action, Bundle extras, ResultReceiver receiver,
Messenger callbacksMessenger) throws RemoteException {
Bundle data = new Bundle();
data.putString(DATA_CUSTOM_ACTION, action);
data.putBundle(DATA_CUSTOM_ACTION_EXTRAS, extras);
data.putParcelable(DATA_RESULT_RECEIVER, receiver);
sendRequest(CLIENT_MSG_SEND_CUSTOM_ACTION, data, callbacksMessenger);
}
private void sendRequest(int what, Bundle data, Messenger cbMessenger)
throws RemoteException {
Message msg = Message.obtain();
msg.what = what;
msg.arg1 = CLIENT_VERSION_CURRENT;
msg.setData(data);
msg.replyTo = cbMessenger;
mMessenger.send(msg);
}
}
private static class ItemReceiver extends ResultReceiver {
private final String mMediaId;
private final ItemCallback mCallback;
ItemReceiver(String mediaId, ItemCallback callback, Handler handler) {
super(handler);
mMediaId = mediaId;
mCallback = callback;
}
@Override
protected void onReceiveResult(int resultCode, Bundle resultData) {
if (resultData != null) {
resultData.setClassLoader(MediaBrowserCompat.class.getClassLoader());
}
if (resultCode != MediaBrowserServiceCompat.RESULT_OK || resultData == null
|| !resultData.containsKey(MediaBrowserServiceCompat.KEY_MEDIA_ITEM)) {
mCallback.onError(mMediaId);
return;
}
Parcelable item = resultData.getParcelable(MediaBrowserServiceCompat.KEY_MEDIA_ITEM);
if (item == null || item instanceof MediaItem) {
mCallback.onItemLoaded((MediaItem) item);
} else {
mCallback.onError(mMediaId);
}
}
}
private static class SearchResultReceiver extends ResultReceiver {
private final String mQuery;
private final Bundle mExtras;
private final SearchCallback mCallback;
SearchResultReceiver(String query, Bundle extras, SearchCallback callback,
Handler handler) {
super(handler);
mQuery = query;
mExtras = extras;
mCallback = callback;
}
@Override
protected void onReceiveResult(int resultCode, Bundle resultData) {
if (resultData != null) {
resultData.setClassLoader(MediaBrowserCompat.class.getClassLoader());
}
if (resultCode != MediaBrowserServiceCompat.RESULT_OK || resultData == null
|| !resultData.containsKey(MediaBrowserServiceCompat.KEY_SEARCH_RESULTS)) {
mCallback.onError(mQuery, mExtras);
return;
}
Parcelable[] items = resultData.getParcelableArray(
MediaBrowserServiceCompat.KEY_SEARCH_RESULTS);
List results = null;
if (items != null) {
results = new ArrayList<>();
for (Parcelable item : items) {
results.add((MediaItem) item);
}
}
mCallback.onSearchResult(mQuery, mExtras, results);
}
}
private static class CustomActionResultReceiver extends ResultReceiver {
private final String mAction;
private final Bundle mExtras;
private final CustomActionCallback mCallback;
CustomActionResultReceiver(String action, Bundle extras, CustomActionCallback callback,
Handler handler) {
super(handler);
mAction = action;
mExtras = extras;
mCallback = callback;
}
@Override
protected void onReceiveResult(int resultCode, Bundle resultData) {
if (mCallback == null) {
return;
}
switch (resultCode) {
case MediaBrowserServiceCompat.RESULT_PROGRESS_UPDATE:
mCallback.onProgressUpdate(mAction, mExtras, resultData);
break;
case MediaBrowserServiceCompat.RESULT_OK:
mCallback.onResult(mAction, mExtras, resultData);
break;
case MediaBrowserServiceCompat.RESULT_ERROR:
mCallback.onError(mAction, mExtras, resultData);
break;
default:
Log.w(TAG, "Unknown result code: " + resultCode + " (extras=" + mExtras
+ ", resultData=" + resultData + ")");
break;
}
}
}
}