Daniel Elliott
c080f0d97f
- Added realracing3-community.apk (71.57 MB) - Removed 32-bit support (armeabi-v7a) - Only includes arm64-v8a libraries - Decompiled source code included - Added README-community.md with analysis
1754 lines
72 KiB
Java
1754 lines
72 KiB
Java
package android.support.v4.media.session;
|
|
|
|
import android.annotation.SuppressLint;
|
|
import android.app.Activity;
|
|
import android.app.PendingIntent;
|
|
import android.content.Context;
|
|
import android.media.MediaMetadata;
|
|
import android.media.Rating;
|
|
import android.media.session.MediaController;
|
|
import android.media.session.MediaSession;
|
|
import android.media.session.PlaybackState;
|
|
import android.net.Uri;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.IBinder;
|
|
import android.os.Looper;
|
|
import android.os.Message;
|
|
import android.os.RemoteException;
|
|
import android.os.ResultReceiver;
|
|
import android.support.v4.media.MediaDescriptionCompat;
|
|
import android.support.v4.media.MediaMetadataCompat;
|
|
import android.support.v4.media.RatingCompat;
|
|
import android.support.v4.media.session.IMediaControllerCallback;
|
|
import android.support.v4.media.session.IMediaSession;
|
|
import android.support.v4.media.session.MediaSessionCompat;
|
|
import android.support.v4.media.session.PlaybackStateCompat;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
import android.view.KeyEvent;
|
|
import androidx.annotation.GuardedBy;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.RequiresApi;
|
|
import androidx.annotation.RestrictTo;
|
|
import androidx.core.app.BundleCompat;
|
|
import androidx.media.AudioAttributesCompat;
|
|
import androidx.media.R;
|
|
import androidx.versionedparcelable.ParcelUtils;
|
|
import androidx.versionedparcelable.VersionedParcelable;
|
|
import csdk.gluads.Consts;
|
|
import java.lang.ref.WeakReference;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
/* loaded from: classes.dex */
|
|
public final class MediaControllerCompat {
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public static final String COMMAND_ADD_QUEUE_ITEM = "android.support.v4.media.session.command.ADD_QUEUE_ITEM";
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public static final String COMMAND_ADD_QUEUE_ITEM_AT = "android.support.v4.media.session.command.ADD_QUEUE_ITEM_AT";
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public static final String COMMAND_ARGUMENT_INDEX = "android.support.v4.media.session.command.ARGUMENT_INDEX";
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public static final String COMMAND_ARGUMENT_MEDIA_DESCRIPTION = "android.support.v4.media.session.command.ARGUMENT_MEDIA_DESCRIPTION";
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public static final String COMMAND_GET_EXTRA_BINDER = "android.support.v4.media.session.command.GET_EXTRA_BINDER";
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public static final String COMMAND_REMOVE_QUEUE_ITEM = "android.support.v4.media.session.command.REMOVE_QUEUE_ITEM";
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public static final String COMMAND_REMOVE_QUEUE_ITEM_AT = "android.support.v4.media.session.command.REMOVE_QUEUE_ITEM_AT";
|
|
static final String TAG = "MediaControllerCompat";
|
|
private final MediaControllerImpl mImpl;
|
|
|
|
@SuppressLint({"BanConcurrentHashMap"})
|
|
private final ConcurrentHashMap<Callback, Boolean> mRegisteredCallbacks = new ConcurrentHashMap<>();
|
|
private final MediaSessionCompat.Token mToken;
|
|
|
|
public interface MediaControllerImpl {
|
|
void addQueueItem(MediaDescriptionCompat mediaDescriptionCompat);
|
|
|
|
void addQueueItem(MediaDescriptionCompat mediaDescriptionCompat, int i);
|
|
|
|
void adjustVolume(int i, int i2);
|
|
|
|
boolean dispatchMediaButtonEvent(KeyEvent keyEvent);
|
|
|
|
Bundle getExtras();
|
|
|
|
long getFlags();
|
|
|
|
Object getMediaController();
|
|
|
|
MediaMetadataCompat getMetadata();
|
|
|
|
String getPackageName();
|
|
|
|
PlaybackInfo getPlaybackInfo();
|
|
|
|
PlaybackStateCompat getPlaybackState();
|
|
|
|
List<MediaSessionCompat.QueueItem> getQueue();
|
|
|
|
CharSequence getQueueTitle();
|
|
|
|
int getRatingType();
|
|
|
|
int getRepeatMode();
|
|
|
|
PendingIntent getSessionActivity();
|
|
|
|
Bundle getSessionInfo();
|
|
|
|
int getShuffleMode();
|
|
|
|
TransportControls getTransportControls();
|
|
|
|
boolean isCaptioningEnabled();
|
|
|
|
boolean isSessionReady();
|
|
|
|
void registerCallback(Callback callback, Handler handler);
|
|
|
|
void removeQueueItem(MediaDescriptionCompat mediaDescriptionCompat);
|
|
|
|
void sendCommand(String str, Bundle bundle, ResultReceiver resultReceiver);
|
|
|
|
void setVolumeTo(int i, int i2);
|
|
|
|
void unregisterCallback(Callback callback);
|
|
}
|
|
|
|
public static abstract class TransportControls {
|
|
public static final String EXTRA_LEGACY_STREAM_TYPE = "android.media.session.extra.LEGACY_STREAM_TYPE";
|
|
|
|
public abstract void fastForward();
|
|
|
|
public abstract void pause();
|
|
|
|
public abstract void play();
|
|
|
|
public abstract void playFromMediaId(String str, Bundle bundle);
|
|
|
|
public abstract void playFromSearch(String str, Bundle bundle);
|
|
|
|
public abstract void playFromUri(Uri uri, Bundle bundle);
|
|
|
|
public abstract void prepare();
|
|
|
|
public abstract void prepareFromMediaId(String str, Bundle bundle);
|
|
|
|
public abstract void prepareFromSearch(String str, Bundle bundle);
|
|
|
|
public abstract void prepareFromUri(Uri uri, Bundle bundle);
|
|
|
|
public abstract void rewind();
|
|
|
|
public abstract void seekTo(long j);
|
|
|
|
public abstract void sendCustomAction(PlaybackStateCompat.CustomAction customAction, Bundle bundle);
|
|
|
|
public abstract void sendCustomAction(String str, Bundle bundle);
|
|
|
|
public abstract void setCaptioningEnabled(boolean z);
|
|
|
|
public void setPlaybackSpeed(float f) {
|
|
}
|
|
|
|
public abstract void setRating(RatingCompat ratingCompat);
|
|
|
|
public abstract void setRating(RatingCompat ratingCompat, Bundle bundle);
|
|
|
|
public abstract void setRepeatMode(int i);
|
|
|
|
public abstract void setShuffleMode(int i);
|
|
|
|
public abstract void skipToNext();
|
|
|
|
public abstract void skipToPrevious();
|
|
|
|
public abstract void skipToQueueItem(long j);
|
|
|
|
public abstract void stop();
|
|
}
|
|
|
|
public MediaSessionCompat.Token getSessionToken() {
|
|
return this.mToken;
|
|
}
|
|
|
|
public static void setMediaController(@NonNull Activity activity, MediaControllerCompat mediaControllerCompat) {
|
|
activity.getWindow().getDecorView().setTag(R.id.media_controller_compat_view_tag, mediaControllerCompat);
|
|
activity.setMediaController(mediaControllerCompat != null ? new MediaController(activity, (MediaSession.Token) mediaControllerCompat.getSessionToken().getToken()) : null);
|
|
}
|
|
|
|
public static MediaControllerCompat getMediaController(@NonNull Activity activity) {
|
|
Object tag = activity.getWindow().getDecorView().getTag(R.id.media_controller_compat_view_tag);
|
|
if (tag instanceof MediaControllerCompat) {
|
|
return (MediaControllerCompat) tag;
|
|
}
|
|
MediaController mediaController = activity.getMediaController();
|
|
if (mediaController == null) {
|
|
return null;
|
|
}
|
|
return new MediaControllerCompat(activity, MediaSessionCompat.Token.fromToken(mediaController.getSessionToken()));
|
|
}
|
|
|
|
public static void validateCustomAction(String str, Bundle bundle) {
|
|
if (str == null) {
|
|
return;
|
|
}
|
|
if (str.equals(MediaSessionCompat.ACTION_FOLLOW) || str.equals(MediaSessionCompat.ACTION_UNFOLLOW)) {
|
|
if (bundle == null || !bundle.containsKey(MediaSessionCompat.ARGUMENT_MEDIA_ATTRIBUTE)) {
|
|
throw new IllegalArgumentException("An extra field android.support.v4.media.session.ARGUMENT_MEDIA_ATTRIBUTE is required for this action " + str + Consts.STRING_PERIOD);
|
|
}
|
|
}
|
|
}
|
|
|
|
public MediaControllerCompat(Context context, @NonNull MediaSessionCompat mediaSessionCompat) {
|
|
if (mediaSessionCompat == null) {
|
|
throw new IllegalArgumentException("session must not be null");
|
|
}
|
|
MediaSessionCompat.Token sessionToken = mediaSessionCompat.getSessionToken();
|
|
this.mToken = sessionToken;
|
|
this.mImpl = new MediaControllerImplApi21(context, sessionToken);
|
|
}
|
|
|
|
public MediaControllerCompat(Context context, @NonNull MediaSessionCompat.Token token) {
|
|
if (token == null) {
|
|
throw new IllegalArgumentException("sessionToken must not be null");
|
|
}
|
|
this.mToken = token;
|
|
this.mImpl = new MediaControllerImplApi21(context, token);
|
|
}
|
|
|
|
public TransportControls getTransportControls() {
|
|
return this.mImpl.getTransportControls();
|
|
}
|
|
|
|
public boolean dispatchMediaButtonEvent(KeyEvent keyEvent) {
|
|
if (keyEvent == null) {
|
|
throw new IllegalArgumentException("KeyEvent may not be null");
|
|
}
|
|
return this.mImpl.dispatchMediaButtonEvent(keyEvent);
|
|
}
|
|
|
|
public PlaybackStateCompat getPlaybackState() {
|
|
return this.mImpl.getPlaybackState();
|
|
}
|
|
|
|
public MediaMetadataCompat getMetadata() {
|
|
return this.mImpl.getMetadata();
|
|
}
|
|
|
|
public List<MediaSessionCompat.QueueItem> getQueue() {
|
|
return this.mImpl.getQueue();
|
|
}
|
|
|
|
public void addQueueItem(MediaDescriptionCompat mediaDescriptionCompat) {
|
|
this.mImpl.addQueueItem(mediaDescriptionCompat);
|
|
}
|
|
|
|
public void addQueueItem(MediaDescriptionCompat mediaDescriptionCompat, int i) {
|
|
this.mImpl.addQueueItem(mediaDescriptionCompat, i);
|
|
}
|
|
|
|
public void removeQueueItem(MediaDescriptionCompat mediaDescriptionCompat) {
|
|
this.mImpl.removeQueueItem(mediaDescriptionCompat);
|
|
}
|
|
|
|
@Deprecated
|
|
public void removeQueueItemAt(int i) {
|
|
MediaSessionCompat.QueueItem queueItem;
|
|
List<MediaSessionCompat.QueueItem> queue = getQueue();
|
|
if (queue == null || i < 0 || i >= queue.size() || (queueItem = queue.get(i)) == null) {
|
|
return;
|
|
}
|
|
removeQueueItem(queueItem.getDescription());
|
|
}
|
|
|
|
public CharSequence getQueueTitle() {
|
|
return this.mImpl.getQueueTitle();
|
|
}
|
|
|
|
public Bundle getExtras() {
|
|
return this.mImpl.getExtras();
|
|
}
|
|
|
|
public int getRatingType() {
|
|
return this.mImpl.getRatingType();
|
|
}
|
|
|
|
public boolean isCaptioningEnabled() {
|
|
return this.mImpl.isCaptioningEnabled();
|
|
}
|
|
|
|
public int getRepeatMode() {
|
|
return this.mImpl.getRepeatMode();
|
|
}
|
|
|
|
public int getShuffleMode() {
|
|
return this.mImpl.getShuffleMode();
|
|
}
|
|
|
|
public long getFlags() {
|
|
return this.mImpl.getFlags();
|
|
}
|
|
|
|
public PlaybackInfo getPlaybackInfo() {
|
|
return this.mImpl.getPlaybackInfo();
|
|
}
|
|
|
|
public PendingIntent getSessionActivity() {
|
|
return this.mImpl.getSessionActivity();
|
|
}
|
|
|
|
@Nullable
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public VersionedParcelable getSession2Token() {
|
|
return this.mToken.getSession2Token();
|
|
}
|
|
|
|
public void setVolumeTo(int i, int i2) {
|
|
this.mImpl.setVolumeTo(i, i2);
|
|
}
|
|
|
|
public void adjustVolume(int i, int i2) {
|
|
this.mImpl.adjustVolume(i, i2);
|
|
}
|
|
|
|
public void registerCallback(@NonNull Callback callback) {
|
|
registerCallback(callback, null);
|
|
}
|
|
|
|
public void registerCallback(@NonNull Callback callback, Handler handler) {
|
|
if (callback == null) {
|
|
throw new IllegalArgumentException("callback must not be null");
|
|
}
|
|
if (this.mRegisteredCallbacks.putIfAbsent(callback, Boolean.TRUE) != null) {
|
|
Log.w(TAG, "the callback has already been registered");
|
|
return;
|
|
}
|
|
if (handler == null) {
|
|
handler = new Handler();
|
|
}
|
|
callback.setHandler(handler);
|
|
this.mImpl.registerCallback(callback, handler);
|
|
}
|
|
|
|
public void unregisterCallback(@NonNull Callback callback) {
|
|
if (callback == null) {
|
|
throw new IllegalArgumentException("callback must not be null");
|
|
}
|
|
if (this.mRegisteredCallbacks.remove(callback) == null) {
|
|
Log.w(TAG, "the callback has never been registered");
|
|
return;
|
|
}
|
|
try {
|
|
this.mImpl.unregisterCallback(callback);
|
|
} finally {
|
|
callback.setHandler(null);
|
|
}
|
|
}
|
|
|
|
public void sendCommand(@NonNull String str, @Nullable Bundle bundle, @Nullable ResultReceiver resultReceiver) {
|
|
if (TextUtils.isEmpty(str)) {
|
|
throw new IllegalArgumentException("command must neither be null nor empty");
|
|
}
|
|
this.mImpl.sendCommand(str, bundle, resultReceiver);
|
|
}
|
|
|
|
public boolean isSessionReady() {
|
|
return this.mImpl.isSessionReady();
|
|
}
|
|
|
|
public String getPackageName() {
|
|
return this.mImpl.getPackageName();
|
|
}
|
|
|
|
@NonNull
|
|
public Bundle getSessionInfo() {
|
|
return this.mImpl.getSessionInfo();
|
|
}
|
|
|
|
public Object getMediaController() {
|
|
return this.mImpl.getMediaController();
|
|
}
|
|
|
|
public static abstract class Callback implements IBinder.DeathRecipient {
|
|
final MediaController.Callback mCallbackFwk = new MediaControllerCallbackApi21(this);
|
|
MessageHandler mHandler;
|
|
IMediaControllerCallback mIControllerCallback;
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public IMediaControllerCallback getIControllerCallback() {
|
|
return this.mIControllerCallback;
|
|
}
|
|
|
|
public void onAudioInfoChanged(PlaybackInfo playbackInfo) {
|
|
}
|
|
|
|
public void onCaptioningEnabledChanged(boolean z) {
|
|
}
|
|
|
|
public void onExtrasChanged(Bundle bundle) {
|
|
}
|
|
|
|
public void onMetadataChanged(MediaMetadataCompat mediaMetadataCompat) {
|
|
}
|
|
|
|
public void onPlaybackStateChanged(PlaybackStateCompat playbackStateCompat) {
|
|
}
|
|
|
|
public void onQueueChanged(List<MediaSessionCompat.QueueItem> list) {
|
|
}
|
|
|
|
public void onQueueTitleChanged(CharSequence charSequence) {
|
|
}
|
|
|
|
public void onRepeatModeChanged(int i) {
|
|
}
|
|
|
|
public void onSessionDestroyed() {
|
|
}
|
|
|
|
public void onSessionEvent(String str, Bundle bundle) {
|
|
}
|
|
|
|
public void onSessionReady() {
|
|
}
|
|
|
|
public void onShuffleModeChanged(int i) {
|
|
}
|
|
|
|
@Override // android.os.IBinder.DeathRecipient
|
|
public void binderDied() {
|
|
postToHandler(8, null, null);
|
|
}
|
|
|
|
public void setHandler(Handler handler) {
|
|
if (handler != null) {
|
|
MessageHandler messageHandler = new MessageHandler(handler.getLooper());
|
|
this.mHandler = messageHandler;
|
|
messageHandler.mRegistered = true;
|
|
} else {
|
|
MessageHandler messageHandler2 = this.mHandler;
|
|
if (messageHandler2 != null) {
|
|
messageHandler2.mRegistered = false;
|
|
messageHandler2.removeCallbacksAndMessages(null);
|
|
this.mHandler = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void postToHandler(int i, Object obj, Bundle bundle) {
|
|
MessageHandler messageHandler = this.mHandler;
|
|
if (messageHandler != null) {
|
|
Message obtainMessage = messageHandler.obtainMessage(i, obj);
|
|
obtainMessage.setData(bundle);
|
|
obtainMessage.sendToTarget();
|
|
}
|
|
}
|
|
|
|
@RequiresApi(21)
|
|
public static class MediaControllerCallbackApi21 extends MediaController.Callback {
|
|
private final WeakReference<Callback> mCallback;
|
|
|
|
public MediaControllerCallbackApi21(Callback callback) {
|
|
this.mCallback = new WeakReference<>(callback);
|
|
}
|
|
|
|
@Override // android.media.session.MediaController.Callback
|
|
public void onSessionDestroyed() {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.onSessionDestroyed();
|
|
}
|
|
}
|
|
|
|
@Override // android.media.session.MediaController.Callback
|
|
public void onSessionEvent(String str, Bundle bundle) {
|
|
MediaSessionCompat.ensureClassLoader(bundle);
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.onSessionEvent(str, bundle);
|
|
}
|
|
}
|
|
|
|
@Override // android.media.session.MediaController.Callback
|
|
public void onPlaybackStateChanged(PlaybackState playbackState) {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback == null || callback.mIControllerCallback != null) {
|
|
return;
|
|
}
|
|
callback.onPlaybackStateChanged(PlaybackStateCompat.fromPlaybackState(playbackState));
|
|
}
|
|
|
|
@Override // android.media.session.MediaController.Callback
|
|
public void onMetadataChanged(MediaMetadata mediaMetadata) {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.onMetadataChanged(MediaMetadataCompat.fromMediaMetadata(mediaMetadata));
|
|
}
|
|
}
|
|
|
|
@Override // android.media.session.MediaController.Callback
|
|
public void onQueueChanged(List<MediaSession.QueueItem> list) {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.onQueueChanged(MediaSessionCompat.QueueItem.fromQueueItemList(list));
|
|
}
|
|
}
|
|
|
|
@Override // android.media.session.MediaController.Callback
|
|
public void onQueueTitleChanged(CharSequence charSequence) {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.onQueueTitleChanged(charSequence);
|
|
}
|
|
}
|
|
|
|
@Override // android.media.session.MediaController.Callback
|
|
public void onExtrasChanged(Bundle bundle) {
|
|
MediaSessionCompat.ensureClassLoader(bundle);
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.onExtrasChanged(bundle);
|
|
}
|
|
}
|
|
|
|
@Override // android.media.session.MediaController.Callback
|
|
public void onAudioInfoChanged(MediaController.PlaybackInfo playbackInfo) {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.onAudioInfoChanged(new PlaybackInfo(playbackInfo.getPlaybackType(), AudioAttributesCompat.wrap(playbackInfo.getAudioAttributes()), playbackInfo.getVolumeControl(), playbackInfo.getMaxVolume(), playbackInfo.getCurrentVolume()));
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class StubCompat extends IMediaControllerCallback.Stub {
|
|
private final WeakReference<Callback> mCallback;
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onShuffleModeChangedRemoved(boolean z) throws RemoteException {
|
|
}
|
|
|
|
public StubCompat(Callback callback) {
|
|
this.mCallback = new WeakReference<>(callback);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onEvent(String str, Bundle bundle) throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(1, str, bundle);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onSessionDestroyed() throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(8, null, null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onPlaybackStateChanged(PlaybackStateCompat playbackStateCompat) throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(2, playbackStateCompat, null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onMetadataChanged(MediaMetadataCompat mediaMetadataCompat) throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(3, mediaMetadataCompat, null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onQueueChanged(List<MediaSessionCompat.QueueItem> list) throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(5, list, null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onQueueTitleChanged(CharSequence charSequence) throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(6, charSequence, null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onCaptioningEnabledChanged(boolean z) throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(11, Boolean.valueOf(z), null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onRepeatModeChanged(int i) throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(9, Integer.valueOf(i), null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onShuffleModeChanged(int i) throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(12, Integer.valueOf(i), null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onExtrasChanged(Bundle bundle) throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(7, bundle, null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onVolumeInfoChanged(ParcelableVolumeInfo parcelableVolumeInfo) throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(4, parcelableVolumeInfo != null ? new PlaybackInfo(parcelableVolumeInfo.volumeType, parcelableVolumeInfo.audioStream, parcelableVolumeInfo.controlType, parcelableVolumeInfo.maxVolume, parcelableVolumeInfo.currentVolume) : null, null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.IMediaControllerCallback
|
|
public void onSessionReady() throws RemoteException {
|
|
Callback callback = this.mCallback.get();
|
|
if (callback != null) {
|
|
callback.postToHandler(13, null, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class MessageHandler extends Handler {
|
|
private static final int MSG_DESTROYED = 8;
|
|
private static final int MSG_EVENT = 1;
|
|
private static final int MSG_SESSION_READY = 13;
|
|
private static final int MSG_UPDATE_CAPTIONING_ENABLED = 11;
|
|
private static final int MSG_UPDATE_EXTRAS = 7;
|
|
private static final int MSG_UPDATE_METADATA = 3;
|
|
private static final int MSG_UPDATE_PLAYBACK_STATE = 2;
|
|
private static final int MSG_UPDATE_QUEUE = 5;
|
|
private static final int MSG_UPDATE_QUEUE_TITLE = 6;
|
|
private static final int MSG_UPDATE_REPEAT_MODE = 9;
|
|
private static final int MSG_UPDATE_SHUFFLE_MODE = 12;
|
|
private static final int MSG_UPDATE_VOLUME = 4;
|
|
boolean mRegistered;
|
|
|
|
public MessageHandler(Looper looper) {
|
|
super(looper);
|
|
this.mRegistered = false;
|
|
}
|
|
|
|
@Override // android.os.Handler
|
|
public void handleMessage(Message message) {
|
|
if (this.mRegistered) {
|
|
switch (message.what) {
|
|
case 1:
|
|
Bundle data = message.getData();
|
|
MediaSessionCompat.ensureClassLoader(data);
|
|
Callback.this.onSessionEvent((String) message.obj, data);
|
|
break;
|
|
case 2:
|
|
Callback.this.onPlaybackStateChanged((PlaybackStateCompat) message.obj);
|
|
break;
|
|
case 3:
|
|
Callback.this.onMetadataChanged((MediaMetadataCompat) message.obj);
|
|
break;
|
|
case 4:
|
|
Callback.this.onAudioInfoChanged((PlaybackInfo) message.obj);
|
|
break;
|
|
case 5:
|
|
Callback.this.onQueueChanged((List) message.obj);
|
|
break;
|
|
case 6:
|
|
Callback.this.onQueueTitleChanged((CharSequence) message.obj);
|
|
break;
|
|
case 7:
|
|
Bundle bundle = (Bundle) message.obj;
|
|
MediaSessionCompat.ensureClassLoader(bundle);
|
|
Callback.this.onExtrasChanged(bundle);
|
|
break;
|
|
case 8:
|
|
Callback.this.onSessionDestroyed();
|
|
break;
|
|
case 9:
|
|
Callback.this.onRepeatModeChanged(((Integer) message.obj).intValue());
|
|
break;
|
|
case 11:
|
|
Callback.this.onCaptioningEnabledChanged(((Boolean) message.obj).booleanValue());
|
|
break;
|
|
case 12:
|
|
Callback.this.onShuffleModeChanged(((Integer) message.obj).intValue());
|
|
break;
|
|
case 13:
|
|
Callback.this.onSessionReady();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static final class PlaybackInfo {
|
|
public static final int PLAYBACK_TYPE_LOCAL = 1;
|
|
public static final int PLAYBACK_TYPE_REMOTE = 2;
|
|
private final AudioAttributesCompat mAudioAttrsCompat;
|
|
private final int mCurrentVolume;
|
|
private final int mMaxVolume;
|
|
private final int mPlaybackType;
|
|
private final int mVolumeControl;
|
|
|
|
@NonNull
|
|
public AudioAttributesCompat getAudioAttributes() {
|
|
return this.mAudioAttrsCompat;
|
|
}
|
|
|
|
public int getCurrentVolume() {
|
|
return this.mCurrentVolume;
|
|
}
|
|
|
|
public int getMaxVolume() {
|
|
return this.mMaxVolume;
|
|
}
|
|
|
|
public int getPlaybackType() {
|
|
return this.mPlaybackType;
|
|
}
|
|
|
|
public int getVolumeControl() {
|
|
return this.mVolumeControl;
|
|
}
|
|
|
|
public PlaybackInfo(int i, int i2, int i3, int i4, int i5) {
|
|
this(i, new AudioAttributesCompat.Builder().setLegacyStreamType(i2).build(), i3, i4, i5);
|
|
}
|
|
|
|
public PlaybackInfo(int i, @NonNull AudioAttributesCompat audioAttributesCompat, int i2, int i3, int i4) {
|
|
this.mPlaybackType = i;
|
|
this.mAudioAttrsCompat = audioAttributesCompat;
|
|
this.mVolumeControl = i2;
|
|
this.mMaxVolume = i3;
|
|
this.mCurrentVolume = i4;
|
|
}
|
|
|
|
@Deprecated
|
|
public int getAudioStream() {
|
|
return this.mAudioAttrsCompat.getLegacyStreamType();
|
|
}
|
|
}
|
|
|
|
public static class MediaControllerImplBase implements MediaControllerImpl {
|
|
private IMediaSession mBinder;
|
|
private Bundle mSessionInfo;
|
|
private TransportControls mTransportControls;
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public Object getMediaController() {
|
|
return null;
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public boolean isSessionReady() {
|
|
return true;
|
|
}
|
|
|
|
public MediaControllerImplBase(MediaSessionCompat.Token token) {
|
|
this.mBinder = IMediaSession.Stub.asInterface((IBinder) token.getToken());
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void registerCallback(Callback callback, Handler handler) {
|
|
if (callback == null) {
|
|
throw new IllegalArgumentException("callback may not be null.");
|
|
}
|
|
try {
|
|
this.mBinder.asBinder().linkToDeath(callback, 0);
|
|
this.mBinder.registerCallbackListener(callback.mIControllerCallback);
|
|
callback.postToHandler(13, null, null);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in registerCallback.", e);
|
|
callback.postToHandler(8, null, null);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void unregisterCallback(Callback callback) {
|
|
if (callback == null) {
|
|
throw new IllegalArgumentException("callback may not be null.");
|
|
}
|
|
try {
|
|
this.mBinder.unregisterCallbackListener(callback.mIControllerCallback);
|
|
this.mBinder.asBinder().unlinkToDeath(callback, 0);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in unregisterCallback.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public boolean dispatchMediaButtonEvent(KeyEvent keyEvent) {
|
|
if (keyEvent == null) {
|
|
throw new IllegalArgumentException("event may not be null.");
|
|
}
|
|
try {
|
|
this.mBinder.sendMediaButton(keyEvent);
|
|
return false;
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in dispatchMediaButtonEvent.", e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public TransportControls getTransportControls() {
|
|
if (this.mTransportControls == null) {
|
|
this.mTransportControls = new TransportControlsBase(this.mBinder);
|
|
}
|
|
return this.mTransportControls;
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public PlaybackStateCompat getPlaybackState() {
|
|
try {
|
|
return this.mBinder.getPlaybackState();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getPlaybackState.", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public MediaMetadataCompat getMetadata() {
|
|
try {
|
|
return this.mBinder.getMetadata();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getMetadata.", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public List<MediaSessionCompat.QueueItem> getQueue() {
|
|
try {
|
|
return this.mBinder.getQueue();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getQueue.", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void addQueueItem(MediaDescriptionCompat mediaDescriptionCompat) {
|
|
try {
|
|
if ((this.mBinder.getFlags() & 4) == 0) {
|
|
throw new UnsupportedOperationException("This session doesn't support queue management operations");
|
|
}
|
|
this.mBinder.addQueueItem(mediaDescriptionCompat);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in addQueueItem.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void addQueueItem(MediaDescriptionCompat mediaDescriptionCompat, int i) {
|
|
try {
|
|
if ((this.mBinder.getFlags() & 4) == 0) {
|
|
throw new UnsupportedOperationException("This session doesn't support queue management operations");
|
|
}
|
|
this.mBinder.addQueueItemAt(mediaDescriptionCompat, i);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in addQueueItemAt.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void removeQueueItem(MediaDescriptionCompat mediaDescriptionCompat) {
|
|
try {
|
|
if ((this.mBinder.getFlags() & 4) == 0) {
|
|
throw new UnsupportedOperationException("This session doesn't support queue management operations");
|
|
}
|
|
this.mBinder.removeQueueItem(mediaDescriptionCompat);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in removeQueueItem.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public CharSequence getQueueTitle() {
|
|
try {
|
|
return this.mBinder.getQueueTitle();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getQueueTitle.", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public Bundle getExtras() {
|
|
try {
|
|
return this.mBinder.getExtras();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getExtras.", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public int getRatingType() {
|
|
try {
|
|
return this.mBinder.getRatingType();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getRatingType.", e);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public boolean isCaptioningEnabled() {
|
|
try {
|
|
return this.mBinder.isCaptioningEnabled();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in isCaptioningEnabled.", e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public int getRepeatMode() {
|
|
try {
|
|
return this.mBinder.getRepeatMode();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getRepeatMode.", e);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public int getShuffleMode() {
|
|
try {
|
|
return this.mBinder.getShuffleMode();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getShuffleMode.", e);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public long getFlags() {
|
|
try {
|
|
return this.mBinder.getFlags();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getFlags.", e);
|
|
return 0L;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public PlaybackInfo getPlaybackInfo() {
|
|
try {
|
|
ParcelableVolumeInfo volumeAttributes = this.mBinder.getVolumeAttributes();
|
|
return new PlaybackInfo(volumeAttributes.volumeType, volumeAttributes.audioStream, volumeAttributes.controlType, volumeAttributes.maxVolume, volumeAttributes.currentVolume);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getPlaybackInfo.", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public PendingIntent getSessionActivity() {
|
|
try {
|
|
return this.mBinder.getLaunchPendingIntent();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getSessionActivity.", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void setVolumeTo(int i, int i2) {
|
|
try {
|
|
this.mBinder.setVolumeTo(i, i2, null);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in setVolumeTo.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void adjustVolume(int i, int i2) {
|
|
try {
|
|
this.mBinder.adjustVolume(i, i2, null);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in adjustVolume.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void sendCommand(String str, Bundle bundle, ResultReceiver resultReceiver) {
|
|
try {
|
|
this.mBinder.sendCommand(str, bundle, resultReceiver == null ? null : new MediaSessionCompat.ResultReceiverWrapper(resultReceiver));
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in sendCommand.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public String getPackageName() {
|
|
try {
|
|
return this.mBinder.getPackageName();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getPackageName.", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public Bundle getSessionInfo() {
|
|
try {
|
|
this.mSessionInfo = this.mBinder.getSessionInfo();
|
|
} catch (RemoteException unused) {
|
|
}
|
|
Bundle unparcelWithClassLoader = MediaSessionCompat.unparcelWithClassLoader(this.mSessionInfo);
|
|
this.mSessionInfo = unparcelWithClassLoader;
|
|
return unparcelWithClassLoader == null ? Bundle.EMPTY : new Bundle(this.mSessionInfo);
|
|
}
|
|
}
|
|
|
|
public static class TransportControlsBase extends TransportControls {
|
|
private IMediaSession mBinder;
|
|
|
|
public TransportControlsBase(IMediaSession iMediaSession) {
|
|
this.mBinder = iMediaSession;
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void prepare() {
|
|
try {
|
|
this.mBinder.prepare();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in prepare.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void prepareFromMediaId(String str, Bundle bundle) {
|
|
try {
|
|
this.mBinder.prepareFromMediaId(str, bundle);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in prepareFromMediaId.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void prepareFromSearch(String str, Bundle bundle) {
|
|
try {
|
|
this.mBinder.prepareFromSearch(str, bundle);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in prepareFromSearch.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void prepareFromUri(Uri uri, Bundle bundle) {
|
|
try {
|
|
this.mBinder.prepareFromUri(uri, bundle);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in prepareFromUri.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void play() {
|
|
try {
|
|
this.mBinder.play();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in play.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void playFromMediaId(String str, Bundle bundle) {
|
|
try {
|
|
this.mBinder.playFromMediaId(str, bundle);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in playFromMediaId.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void playFromSearch(String str, Bundle bundle) {
|
|
try {
|
|
this.mBinder.playFromSearch(str, bundle);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in playFromSearch.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void playFromUri(Uri uri, Bundle bundle) {
|
|
try {
|
|
this.mBinder.playFromUri(uri, bundle);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in playFromUri.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void skipToQueueItem(long j) {
|
|
try {
|
|
this.mBinder.skipToQueueItem(j);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in skipToQueueItem.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void pause() {
|
|
try {
|
|
this.mBinder.pause();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in pause.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void stop() {
|
|
try {
|
|
this.mBinder.stop();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in stop.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void seekTo(long j) {
|
|
try {
|
|
this.mBinder.seekTo(j);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in seekTo.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void fastForward() {
|
|
try {
|
|
this.mBinder.fastForward();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in fastForward.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void skipToNext() {
|
|
try {
|
|
this.mBinder.next();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in skipToNext.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void rewind() {
|
|
try {
|
|
this.mBinder.rewind();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in rewind.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void skipToPrevious() {
|
|
try {
|
|
this.mBinder.previous();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in skipToPrevious.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setRating(RatingCompat ratingCompat) {
|
|
try {
|
|
this.mBinder.rate(ratingCompat);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in setRating.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setRating(RatingCompat ratingCompat, Bundle bundle) {
|
|
try {
|
|
this.mBinder.rateWithExtras(ratingCompat, bundle);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in setRating.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setPlaybackSpeed(float f) {
|
|
if (f == 0.0f) {
|
|
throw new IllegalArgumentException("speed must not be zero");
|
|
}
|
|
try {
|
|
this.mBinder.setPlaybackSpeed(f);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in setPlaybackSpeed.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setCaptioningEnabled(boolean z) {
|
|
try {
|
|
this.mBinder.setCaptioningEnabled(z);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in setCaptioningEnabled.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setRepeatMode(int i) {
|
|
try {
|
|
this.mBinder.setRepeatMode(i);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in setRepeatMode.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setShuffleMode(int i) {
|
|
try {
|
|
this.mBinder.setShuffleMode(i);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in setShuffleMode.", e);
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void sendCustomAction(PlaybackStateCompat.CustomAction customAction, Bundle bundle) {
|
|
sendCustomAction(customAction.getAction(), bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void sendCustomAction(String str, Bundle bundle) {
|
|
MediaControllerCompat.validateCustomAction(str, bundle);
|
|
try {
|
|
this.mBinder.sendCustomAction(str, bundle);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in sendCustomAction.", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
@RequiresApi(21)
|
|
public static class MediaControllerImplApi21 implements MediaControllerImpl {
|
|
protected final MediaController mControllerFwk;
|
|
private Bundle mSessionInfo;
|
|
final MediaSessionCompat.Token mSessionToken;
|
|
final Object mLock = new Object();
|
|
|
|
@GuardedBy("mLock")
|
|
private final List<Callback> mPendingCallbacks = new ArrayList();
|
|
private HashMap<Callback, ExtraCallback> mCallbackMap = new HashMap<>();
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public Object getMediaController() {
|
|
return this.mControllerFwk;
|
|
}
|
|
|
|
public MediaControllerImplApi21(Context context, MediaSessionCompat.Token token) {
|
|
this.mSessionToken = token;
|
|
this.mControllerFwk = new MediaController(context, (MediaSession.Token) token.getToken());
|
|
if (token.getExtraBinder() == null) {
|
|
requestExtraBinder();
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public final void registerCallback(Callback callback, Handler handler) {
|
|
this.mControllerFwk.registerCallback(callback.mCallbackFwk, handler);
|
|
synchronized (this.mLock) {
|
|
if (this.mSessionToken.getExtraBinder() != null) {
|
|
ExtraCallback extraCallback = new ExtraCallback(callback);
|
|
this.mCallbackMap.put(callback, extraCallback);
|
|
callback.mIControllerCallback = extraCallback;
|
|
try {
|
|
this.mSessionToken.getExtraBinder().registerCallbackListener(extraCallback);
|
|
callback.postToHandler(13, null, null);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in registerCallback.", e);
|
|
}
|
|
} else {
|
|
callback.mIControllerCallback = null;
|
|
this.mPendingCallbacks.add(callback);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public final void unregisterCallback(Callback callback) {
|
|
this.mControllerFwk.unregisterCallback(callback.mCallbackFwk);
|
|
synchronized (this.mLock) {
|
|
if (this.mSessionToken.getExtraBinder() != null) {
|
|
try {
|
|
ExtraCallback remove = this.mCallbackMap.remove(callback);
|
|
if (remove != null) {
|
|
callback.mIControllerCallback = null;
|
|
this.mSessionToken.getExtraBinder().unregisterCallbackListener(remove);
|
|
}
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in unregisterCallback.", e);
|
|
}
|
|
} else {
|
|
this.mPendingCallbacks.remove(callback);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public boolean dispatchMediaButtonEvent(KeyEvent keyEvent) {
|
|
return this.mControllerFwk.dispatchMediaButtonEvent(keyEvent);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public TransportControls getTransportControls() {
|
|
return new TransportControlsApi21(this.mControllerFwk.getTransportControls());
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public PlaybackStateCompat getPlaybackState() {
|
|
if (this.mSessionToken.getExtraBinder() != null) {
|
|
try {
|
|
return this.mSessionToken.getExtraBinder().getPlaybackState();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getPlaybackState.", e);
|
|
}
|
|
}
|
|
PlaybackState playbackState = this.mControllerFwk.getPlaybackState();
|
|
if (playbackState != null) {
|
|
return PlaybackStateCompat.fromPlaybackState(playbackState);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public MediaMetadataCompat getMetadata() {
|
|
MediaMetadata metadata = this.mControllerFwk.getMetadata();
|
|
if (metadata != null) {
|
|
return MediaMetadataCompat.fromMediaMetadata(metadata);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public List<MediaSessionCompat.QueueItem> getQueue() {
|
|
List<MediaSession.QueueItem> queue = this.mControllerFwk.getQueue();
|
|
if (queue != null) {
|
|
return MediaSessionCompat.QueueItem.fromQueueItemList(queue);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void addQueueItem(MediaDescriptionCompat mediaDescriptionCompat) {
|
|
if ((getFlags() & 4) == 0) {
|
|
throw new UnsupportedOperationException("This session doesn't support queue management operations");
|
|
}
|
|
Bundle bundle = new Bundle();
|
|
bundle.putParcelable(MediaControllerCompat.COMMAND_ARGUMENT_MEDIA_DESCRIPTION, mediaDescriptionCompat);
|
|
sendCommand(MediaControllerCompat.COMMAND_ADD_QUEUE_ITEM, bundle, null);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void addQueueItem(MediaDescriptionCompat mediaDescriptionCompat, int i) {
|
|
if ((getFlags() & 4) == 0) {
|
|
throw new UnsupportedOperationException("This session doesn't support queue management operations");
|
|
}
|
|
Bundle bundle = new Bundle();
|
|
bundle.putParcelable(MediaControllerCompat.COMMAND_ARGUMENT_MEDIA_DESCRIPTION, mediaDescriptionCompat);
|
|
bundle.putInt(MediaControllerCompat.COMMAND_ARGUMENT_INDEX, i);
|
|
sendCommand(MediaControllerCompat.COMMAND_ADD_QUEUE_ITEM_AT, bundle, null);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void removeQueueItem(MediaDescriptionCompat mediaDescriptionCompat) {
|
|
if ((getFlags() & 4) == 0) {
|
|
throw new UnsupportedOperationException("This session doesn't support queue management operations");
|
|
}
|
|
Bundle bundle = new Bundle();
|
|
bundle.putParcelable(MediaControllerCompat.COMMAND_ARGUMENT_MEDIA_DESCRIPTION, mediaDescriptionCompat);
|
|
sendCommand(MediaControllerCompat.COMMAND_REMOVE_QUEUE_ITEM, bundle, null);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public CharSequence getQueueTitle() {
|
|
return this.mControllerFwk.getQueueTitle();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public Bundle getExtras() {
|
|
return this.mControllerFwk.getExtras();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public int getRatingType() {
|
|
return this.mControllerFwk.getRatingType();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public boolean isCaptioningEnabled() {
|
|
if (this.mSessionToken.getExtraBinder() == null) {
|
|
return false;
|
|
}
|
|
try {
|
|
return this.mSessionToken.getExtraBinder().isCaptioningEnabled();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in isCaptioningEnabled.", e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public int getRepeatMode() {
|
|
if (this.mSessionToken.getExtraBinder() == null) {
|
|
return -1;
|
|
}
|
|
try {
|
|
return this.mSessionToken.getExtraBinder().getRepeatMode();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getRepeatMode.", e);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public int getShuffleMode() {
|
|
if (this.mSessionToken.getExtraBinder() == null) {
|
|
return -1;
|
|
}
|
|
try {
|
|
return this.mSessionToken.getExtraBinder().getShuffleMode();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getShuffleMode.", e);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public long getFlags() {
|
|
return this.mControllerFwk.getFlags();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public PlaybackInfo getPlaybackInfo() {
|
|
MediaController.PlaybackInfo playbackInfo = this.mControllerFwk.getPlaybackInfo();
|
|
if (playbackInfo != null) {
|
|
return new PlaybackInfo(playbackInfo.getPlaybackType(), AudioAttributesCompat.wrap(playbackInfo.getAudioAttributes()), playbackInfo.getVolumeControl(), playbackInfo.getMaxVolume(), playbackInfo.getCurrentVolume());
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public PendingIntent getSessionActivity() {
|
|
return this.mControllerFwk.getSessionActivity();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void setVolumeTo(int i, int i2) {
|
|
this.mControllerFwk.setVolumeTo(i, i2);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void adjustVolume(int i, int i2) {
|
|
this.mControllerFwk.adjustVolume(i, i2);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public void sendCommand(String str, Bundle bundle, ResultReceiver resultReceiver) {
|
|
this.mControllerFwk.sendCommand(str, bundle, resultReceiver);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public boolean isSessionReady() {
|
|
return this.mSessionToken.getExtraBinder() != null;
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public String getPackageName() {
|
|
return this.mControllerFwk.getPackageName();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.MediaControllerImpl
|
|
public Bundle getSessionInfo() {
|
|
Bundle sessionInfo;
|
|
if (this.mSessionInfo != null) {
|
|
return new Bundle(this.mSessionInfo);
|
|
}
|
|
if (Build.VERSION.SDK_INT >= 29) {
|
|
sessionInfo = this.mControllerFwk.getSessionInfo();
|
|
this.mSessionInfo = sessionInfo;
|
|
} else if (this.mSessionToken.getExtraBinder() != null) {
|
|
try {
|
|
this.mSessionInfo = this.mSessionToken.getExtraBinder().getSessionInfo();
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in getSessionInfo.", e);
|
|
this.mSessionInfo = Bundle.EMPTY;
|
|
}
|
|
}
|
|
Bundle unparcelWithClassLoader = MediaSessionCompat.unparcelWithClassLoader(this.mSessionInfo);
|
|
this.mSessionInfo = unparcelWithClassLoader;
|
|
return unparcelWithClassLoader == null ? Bundle.EMPTY : new Bundle(this.mSessionInfo);
|
|
}
|
|
|
|
private void requestExtraBinder() {
|
|
sendCommand(MediaControllerCompat.COMMAND_GET_EXTRA_BINDER, null, new ExtraBinderRequestResultReceiver(this));
|
|
}
|
|
|
|
@GuardedBy("mLock")
|
|
public void processPendingCallbacksLocked() {
|
|
if (this.mSessionToken.getExtraBinder() == null) {
|
|
return;
|
|
}
|
|
for (Callback callback : this.mPendingCallbacks) {
|
|
ExtraCallback extraCallback = new ExtraCallback(callback);
|
|
this.mCallbackMap.put(callback, extraCallback);
|
|
callback.mIControllerCallback = extraCallback;
|
|
try {
|
|
this.mSessionToken.getExtraBinder().registerCallbackListener(extraCallback);
|
|
callback.postToHandler(13, null, null);
|
|
} catch (RemoteException e) {
|
|
Log.e(MediaControllerCompat.TAG, "Dead object in registerCallback.", e);
|
|
}
|
|
}
|
|
this.mPendingCallbacks.clear();
|
|
}
|
|
|
|
public static class ExtraBinderRequestResultReceiver extends ResultReceiver {
|
|
private WeakReference<MediaControllerImplApi21> mMediaControllerImpl;
|
|
|
|
public ExtraBinderRequestResultReceiver(MediaControllerImplApi21 mediaControllerImplApi21) {
|
|
super(null);
|
|
this.mMediaControllerImpl = new WeakReference<>(mediaControllerImplApi21);
|
|
}
|
|
|
|
@Override // android.os.ResultReceiver
|
|
public void onReceiveResult(int i, Bundle bundle) {
|
|
MediaControllerImplApi21 mediaControllerImplApi21 = this.mMediaControllerImpl.get();
|
|
if (mediaControllerImplApi21 == null || bundle == null) {
|
|
return;
|
|
}
|
|
synchronized (mediaControllerImplApi21.mLock) {
|
|
mediaControllerImplApi21.mSessionToken.setExtraBinder(IMediaSession.Stub.asInterface(BundleCompat.getBinder(bundle, MediaSessionCompat.KEY_EXTRA_BINDER)));
|
|
mediaControllerImplApi21.mSessionToken.setSession2Token(ParcelUtils.getVersionedParcelable(bundle, MediaSessionCompat.KEY_SESSION2_TOKEN));
|
|
mediaControllerImplApi21.processPendingCallbacksLocked();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class ExtraCallback extends Callback.StubCompat {
|
|
public ExtraCallback(Callback callback) {
|
|
super(callback);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.Callback.StubCompat, android.support.v4.media.session.IMediaControllerCallback
|
|
public void onSessionDestroyed() throws RemoteException {
|
|
throw new AssertionError();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.Callback.StubCompat, android.support.v4.media.session.IMediaControllerCallback
|
|
public void onMetadataChanged(MediaMetadataCompat mediaMetadataCompat) throws RemoteException {
|
|
throw new AssertionError();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.Callback.StubCompat, android.support.v4.media.session.IMediaControllerCallback
|
|
public void onQueueChanged(List<MediaSessionCompat.QueueItem> list) throws RemoteException {
|
|
throw new AssertionError();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.Callback.StubCompat, android.support.v4.media.session.IMediaControllerCallback
|
|
public void onQueueTitleChanged(CharSequence charSequence) throws RemoteException {
|
|
throw new AssertionError();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.Callback.StubCompat, android.support.v4.media.session.IMediaControllerCallback
|
|
public void onExtrasChanged(Bundle bundle) throws RemoteException {
|
|
throw new AssertionError();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.Callback.StubCompat, android.support.v4.media.session.IMediaControllerCallback
|
|
public void onVolumeInfoChanged(ParcelableVolumeInfo parcelableVolumeInfo) throws RemoteException {
|
|
throw new AssertionError();
|
|
}
|
|
}
|
|
}
|
|
|
|
@RequiresApi(21)
|
|
public static class TransportControlsApi21 extends TransportControls {
|
|
protected final MediaController.TransportControls mControlsFwk;
|
|
|
|
public TransportControlsApi21(MediaController.TransportControls transportControls) {
|
|
this.mControlsFwk = transportControls;
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void prepare() {
|
|
this.mControlsFwk.prepare();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void prepareFromMediaId(String str, Bundle bundle) {
|
|
this.mControlsFwk.prepareFromMediaId(str, bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void prepareFromSearch(String str, Bundle bundle) {
|
|
this.mControlsFwk.prepareFromSearch(str, bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void prepareFromUri(Uri uri, Bundle bundle) {
|
|
this.mControlsFwk.prepareFromUri(uri, bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void play() {
|
|
this.mControlsFwk.play();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void pause() {
|
|
this.mControlsFwk.pause();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void stop() {
|
|
this.mControlsFwk.stop();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void seekTo(long j) {
|
|
this.mControlsFwk.seekTo(j);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void fastForward() {
|
|
this.mControlsFwk.fastForward();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void rewind() {
|
|
this.mControlsFwk.rewind();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void skipToNext() {
|
|
this.mControlsFwk.skipToNext();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void skipToPrevious() {
|
|
this.mControlsFwk.skipToPrevious();
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setRating(RatingCompat ratingCompat) {
|
|
this.mControlsFwk.setRating(ratingCompat != null ? (Rating) ratingCompat.getRating() : null);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setRating(RatingCompat ratingCompat, Bundle bundle) {
|
|
Bundle bundle2 = new Bundle();
|
|
bundle2.putParcelable(MediaSessionCompat.ACTION_ARGUMENT_RATING, ratingCompat);
|
|
bundle2.putBundle(MediaSessionCompat.ACTION_ARGUMENT_EXTRAS, bundle);
|
|
sendCustomAction(MediaSessionCompat.ACTION_SET_RATING, bundle2);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setPlaybackSpeed(float f) {
|
|
if (f == 0.0f) {
|
|
throw new IllegalArgumentException("speed must not be zero");
|
|
}
|
|
if (Build.VERSION.SDK_INT >= 29) {
|
|
this.mControlsFwk.setPlaybackSpeed(f);
|
|
return;
|
|
}
|
|
Bundle bundle = new Bundle();
|
|
bundle.putFloat(MediaSessionCompat.ACTION_ARGUMENT_PLAYBACK_SPEED, f);
|
|
sendCustomAction(MediaSessionCompat.ACTION_SET_PLAYBACK_SPEED, bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setCaptioningEnabled(boolean z) {
|
|
Bundle bundle = new Bundle();
|
|
bundle.putBoolean(MediaSessionCompat.ACTION_ARGUMENT_CAPTIONING_ENABLED, z);
|
|
sendCustomAction(MediaSessionCompat.ACTION_SET_CAPTIONING_ENABLED, bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setRepeatMode(int i) {
|
|
Bundle bundle = new Bundle();
|
|
bundle.putInt(MediaSessionCompat.ACTION_ARGUMENT_REPEAT_MODE, i);
|
|
sendCustomAction(MediaSessionCompat.ACTION_SET_REPEAT_MODE, bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void setShuffleMode(int i) {
|
|
Bundle bundle = new Bundle();
|
|
bundle.putInt(MediaSessionCompat.ACTION_ARGUMENT_SHUFFLE_MODE, i);
|
|
sendCustomAction(MediaSessionCompat.ACTION_SET_SHUFFLE_MODE, bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void playFromMediaId(String str, Bundle bundle) {
|
|
this.mControlsFwk.playFromMediaId(str, bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void playFromSearch(String str, Bundle bundle) {
|
|
this.mControlsFwk.playFromSearch(str, bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void playFromUri(Uri uri, Bundle bundle) {
|
|
this.mControlsFwk.playFromUri(uri, bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void skipToQueueItem(long j) {
|
|
this.mControlsFwk.skipToQueueItem(j);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void sendCustomAction(PlaybackStateCompat.CustomAction customAction, Bundle bundle) {
|
|
MediaControllerCompat.validateCustomAction(customAction.getAction(), bundle);
|
|
this.mControlsFwk.sendCustomAction(customAction.getAction(), bundle);
|
|
}
|
|
|
|
@Override // android.support.v4.media.session.MediaControllerCompat.TransportControls
|
|
public void sendCustomAction(String str, Bundle bundle) {
|
|
MediaControllerCompat.validateCustomAction(str, bundle);
|
|
this.mControlsFwk.sendCustomAction(str, bundle);
|
|
}
|
|
}
|
|
}
|