Initial commit

sources/androidx/media/AudioAttributesCompat.java

@@ -0,0 +1,121 @@
+package androidx.media;
+
+import android.util.SparseIntArray;
+import androidx.versionedparcelable.VersionedParcelable;
+
+/* loaded from: classes.dex */
+public class AudioAttributesCompat implements VersionedParcelable {
+    private static final SparseIntArray b = new SparseIntArray();
+    AudioAttributesImpl a;
+
+    static {
+        b.put(5, 1);
+        b.put(6, 2);
+        b.put(7, 2);
+        b.put(8, 1);
+        b.put(9, 1);
+        b.put(10, 1);
+    }
+
+    AudioAttributesCompat() {
+    }
+
+    static String a(int i) {
+        switch (i) {
+            case 0:
+                return "USAGE_UNKNOWN";
+            case 1:
+                return "USAGE_MEDIA";
+            case 2:
+                return "USAGE_VOICE_COMMUNICATION";
+            case 3:
+                return "USAGE_VOICE_COMMUNICATION_SIGNALLING";
+            case 4:
+                return "USAGE_ALARM";
+            case 5:
+                return "USAGE_NOTIFICATION";
+            case 6:
+                return "USAGE_NOTIFICATION_RINGTONE";
+            case 7:
+                return "USAGE_NOTIFICATION_COMMUNICATION_REQUEST";
+            case 8:
+                return "USAGE_NOTIFICATION_COMMUNICATION_INSTANT";
+            case 9:
+                return "USAGE_NOTIFICATION_COMMUNICATION_DELAYED";
+            case 10:
+                return "USAGE_NOTIFICATION_EVENT";
+            case 11:
+                return "USAGE_ASSISTANCE_ACCESSIBILITY";
+            case 12:
+                return "USAGE_ASSISTANCE_NAVIGATION_GUIDANCE";
+            case 13:
+                return "USAGE_ASSISTANCE_SONIFICATION";
+            case 14:
+                return "USAGE_GAME";
+            case 15:
+            default:
+                return "unknown usage " + i;
+            case 16:
+                return "USAGE_ASSISTANT";
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof AudioAttributesCompat)) {
+            return false;
+        }
+        AudioAttributesCompat audioAttributesCompat = (AudioAttributesCompat) obj;
+        AudioAttributesImpl audioAttributesImpl = this.a;
+        return audioAttributesImpl == null ? audioAttributesCompat.a == null : audioAttributesImpl.equals(audioAttributesCompat.a);
+    }
+
+    public int hashCode() {
+        return this.a.hashCode();
+    }
+
+    public String toString() {
+        return this.a.toString();
+    }
+
+    static int a(boolean z, int i, int i2) {
+        if ((i & 1) == 1) {
+            return z ? 1 : 7;
+        }
+        if ((i & 4) == 4) {
+            return z ? 0 : 6;
+        }
+        switch (i2) {
+            case 0:
+                return z ? Integer.MIN_VALUE : 3;
+            case 1:
+            case 12:
+            case 14:
+            case 16:
+                return 3;
+            case 2:
+                return 0;
+            case 3:
+                return z ? 0 : 8;
+            case 4:
+                return 4;
+            case 5:
+            case 7:
+            case 8:
+            case 9:
+            case 10:
+                return 5;
+            case 6:
+                return 2;
+            case 11:
+                return 10;
+            case 13:
+                return 1;
+            case 15:
+            default:
+                if (!z) {
+                    return 3;
+                }
+                throw new IllegalArgumentException("Unknown usage value " + i2 + " in audio attributes");
+        }
+    }
+}

sources/androidx/media/AudioAttributesCompatParcelizer.java

@@ -0,0 +1,17 @@
+package androidx.media;
+
+import androidx.versionedparcelable.VersionedParcel;
+
+/* loaded from: classes.dex */
+public final class AudioAttributesCompatParcelizer {
+    public static AudioAttributesCompat read(VersionedParcel versionedParcel) {
+        AudioAttributesCompat audioAttributesCompat = new AudioAttributesCompat();
+        audioAttributesCompat.a = (AudioAttributesImpl) versionedParcel.a((VersionedParcel) audioAttributesCompat.a, 1);
+        return audioAttributesCompat;
+    }
+
+    public static void write(AudioAttributesCompat audioAttributesCompat, VersionedParcel versionedParcel) {
+        versionedParcel.a(false, false);
+        versionedParcel.b(audioAttributesCompat.a, 1);
+    }
+}

sources/androidx/media/AudioAttributesImpl.java

@@ -0,0 +1,7 @@
+package androidx.media;
+
+import androidx.versionedparcelable.VersionedParcelable;
+
+/* loaded from: classes.dex */
+interface AudioAttributesImpl extends VersionedParcelable {
+}

sources/androidx/media/AudioAttributesImplApi21.java

@@ -0,0 +1,29 @@
+package androidx.media;
+
+import android.annotation.TargetApi;
+import android.media.AudioAttributes;
+
+@TargetApi(21)
+/* loaded from: classes.dex */
+class AudioAttributesImplApi21 implements AudioAttributesImpl {
+    AudioAttributes a;
+    int b = -1;
+
+    AudioAttributesImplApi21() {
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof AudioAttributesImplApi21) {
+            return this.a.equals(((AudioAttributesImplApi21) obj).a);
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return this.a.hashCode();
+    }
+
+    public String toString() {
+        return "AudioAttributesCompat: audioattributes=" + this.a;
+    }
+}

sources/androidx/media/AudioAttributesImplApi21Parcelizer.java

@@ -0,0 +1,20 @@
+package androidx.media;
+
+import android.media.AudioAttributes;
+import androidx.versionedparcelable.VersionedParcel;
+
+/* loaded from: classes.dex */
+public final class AudioAttributesImplApi21Parcelizer {
+    public static AudioAttributesImplApi21 read(VersionedParcel versionedParcel) {
+        AudioAttributesImplApi21 audioAttributesImplApi21 = new AudioAttributesImplApi21();
+        audioAttributesImplApi21.a = (AudioAttributes) versionedParcel.a((VersionedParcel) audioAttributesImplApi21.a, 1);
+        audioAttributesImplApi21.b = versionedParcel.a(audioAttributesImplApi21.b, 2);
+        return audioAttributesImplApi21;
+    }
+
+    public static void write(AudioAttributesImplApi21 audioAttributesImplApi21, VersionedParcel versionedParcel) {
+        versionedParcel.a(false, false);
+        versionedParcel.b(audioAttributesImplApi21.a, 1);
+        versionedParcel.b(audioAttributesImplApi21.b, 2);
+    }
+}

sources/androidx/media/AudioAttributesImplBase.java

@@ -0,0 +1,67 @@
+package androidx.media;
+
+import com.chad.library.adapter.base.BaseQuickAdapter;
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+class AudioAttributesImplBase implements AudioAttributesImpl {
+    int a = 0;
+    int b = 0;
+    int c = 0;
+    int d = -1;
+
+    AudioAttributesImplBase() {
+    }
+
+    public int a() {
+        return this.b;
+    }
+
+    public int b() {
+        int i = this.c;
+        int c = c();
+        if (c == 6) {
+            i |= 4;
+        } else if (c == 7) {
+            i |= 1;
+        }
+        return i & BaseQuickAdapter.HEADER_VIEW;
+    }
+
+    public int c() {
+        int i = this.d;
+        return i != -1 ? i : AudioAttributesCompat.a(false, this.c, this.a);
+    }
+
+    public int d() {
+        return this.a;
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof AudioAttributesImplBase)) {
+            return false;
+        }
+        AudioAttributesImplBase audioAttributesImplBase = (AudioAttributesImplBase) obj;
+        return this.b == audioAttributesImplBase.a() && this.c == audioAttributesImplBase.b() && this.a == audioAttributesImplBase.d() && this.d == audioAttributesImplBase.d;
+    }
+
+    public int hashCode() {
+        return Arrays.hashCode(new Object[]{Integer.valueOf(this.b), Integer.valueOf(this.c), Integer.valueOf(this.a), Integer.valueOf(this.d)});
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder("AudioAttributesCompat:");
+        if (this.d != -1) {
+            sb.append(" stream=");
+            sb.append(this.d);
+            sb.append(" derived");
+        }
+        sb.append(" usage=");
+        sb.append(AudioAttributesCompat.a(this.a));
+        sb.append(" content=");
+        sb.append(this.b);
+        sb.append(" flags=0x");
+        sb.append(Integer.toHexString(this.c).toUpperCase());
+        return sb.toString();
+    }
+}

sources/androidx/media/AudioAttributesImplBaseParcelizer.java

@@ -0,0 +1,23 @@
+package androidx.media;
+
+import androidx.versionedparcelable.VersionedParcel;
+
+/* loaded from: classes.dex */
+public final class AudioAttributesImplBaseParcelizer {
+    public static AudioAttributesImplBase read(VersionedParcel versionedParcel) {
+        AudioAttributesImplBase audioAttributesImplBase = new AudioAttributesImplBase();
+        audioAttributesImplBase.a = versionedParcel.a(audioAttributesImplBase.a, 1);
+        audioAttributesImplBase.b = versionedParcel.a(audioAttributesImplBase.b, 2);
+        audioAttributesImplBase.c = versionedParcel.a(audioAttributesImplBase.c, 3);
+        audioAttributesImplBase.d = versionedParcel.a(audioAttributesImplBase.d, 4);
+        return audioAttributesImplBase;
+    }
+
+    public static void write(AudioAttributesImplBase audioAttributesImplBase, VersionedParcel versionedParcel) {
+        versionedParcel.a(false, false);
+        versionedParcel.b(audioAttributesImplBase.a, 1);
+        versionedParcel.b(audioAttributesImplBase.b, 2);
+        versionedParcel.b(audioAttributesImplBase.c, 3);
+        versionedParcel.b(audioAttributesImplBase.d, 4);
+    }
+}

sources/androidx/media/MediaBrowserCompatUtils.java

@@ -0,0 +1,13 @@
+package androidx.media;
+
+import android.os.Bundle;
+
+/* loaded from: classes.dex */
+public class MediaBrowserCompatUtils {
+    public static boolean a(Bundle bundle, Bundle bundle2) {
+        if (bundle == bundle2) {
+            return true;
+        }
+        return bundle == null ? bundle2.getInt("android.media.browse.extra.PAGE", -1) == -1 && bundle2.getInt("android.media.browse.extra.PAGE_SIZE", -1) == -1 : bundle2 == null ? bundle.getInt("android.media.browse.extra.PAGE", -1) == -1 && bundle.getInt("android.media.browse.extra.PAGE_SIZE", -1) == -1 : bundle.getInt("android.media.browse.extra.PAGE", -1) == bundle2.getInt("android.media.browse.extra.PAGE", -1) && bundle.getInt("android.media.browse.extra.PAGE_SIZE", -1) == bundle2.getInt("android.media.browse.extra.PAGE_SIZE", -1);
+    }
+}

sources/androidx/media/MediaBrowserServiceCompat.java

@@ -0,0 +1,883 @@
+package androidx.media;
+
+import android.app.Service;
+import android.content.Intent;
+import android.media.session.MediaSessionManager;
+import android.os.Binder;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.os.RemoteException;
+import android.support.v4.media.MediaBrowserCompat;
+import android.support.v4.media.session.IMediaSession;
+import android.support.v4.media.session.MediaSessionCompat;
+import android.support.v4.os.ResultReceiver;
+import android.text.TextUtils;
+import android.util.Log;
+import androidx.collection.ArrayMap;
+import androidx.core.app.BundleCompat;
+import androidx.core.util.ObjectsCompat;
+import androidx.core.util.Pair;
+import androidx.media.MediaBrowserServiceCompatApi21;
+import androidx.media.MediaBrowserServiceCompatApi23;
+import androidx.media.MediaBrowserServiceCompatApi26;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public abstract class MediaBrowserServiceCompat extends Service {
+    static final boolean f = Log.isLoggable("MBServiceCompat", 3);
+    private MediaBrowserServiceImpl a;
+    ConnectionRecord c;
+    MediaSessionCompat.Token e;
+    final ArrayMap<IBinder, ConnectionRecord> b = new ArrayMap<>();
+    final ServiceHandler d = new ServiceHandler();
+
+    public static final class BrowserRoot {
+        public Bundle a() {
+            throw null;
+        }
+
+        public String b() {
+            throw null;
+        }
+    }
+
+    private class ConnectionRecord implements IBinder.DeathRecipient {
+        public final String a;
+        public final ServiceCallbacks b;
+        public final HashMap<String, List<Pair<IBinder, Bundle>>> c = new HashMap<>();
+        public BrowserRoot d;
+
+        ConnectionRecord(final String str, final int i, final int i2, Bundle bundle, ServiceCallbacks serviceCallbacks) {
+            this.a = str;
+            new Object(str, i, i2) { // from class: androidx.media.MediaSessionManager$RemoteUserInfo
+                MediaSessionManager$RemoteUserInfoImpl a;
+
+                {
+                    if (Build.VERSION.SDK_INT >= 28) {
+                        this.a = new MediaSessionManager$RemoteUserInfoImpl(str, i, i2) { // from class: androidx.media.MediaSessionManagerImplApi28$RemoteUserInfoImplApi28
+                            final MediaSessionManager.RemoteUserInfo a;
+
+                            {
+                                this.a = new MediaSessionManager.RemoteUserInfo(str, i, i2);
+                            }
+
+                            public boolean equals(Object obj) {
+                                if (this == obj) {
+                                    return true;
+                                }
+                                if (obj instanceof MediaSessionManagerImplApi28$RemoteUserInfoImplApi28) {
+                                    return this.a.equals(((MediaSessionManagerImplApi28$RemoteUserInfoImplApi28) obj).a);
+                                }
+                                return false;
+                            }
+
+                            public int hashCode() {
+                                return ObjectsCompat.a(this.a);
+                            }
+                        };
+                    } else {
+                        this.a = new MediaSessionManager$RemoteUserInfoImpl(str, i, i2) { // from class: androidx.media.MediaSessionManagerImplBase$RemoteUserInfoImplBase
+                            private String a;
+                            private int b;
+                            private int c;
+
+                            {
+                                this.a = str;
+                                this.b = i;
+                                this.c = i2;
+                            }
+
+                            public boolean equals(Object obj) {
+                                if (this == obj) {
+                                    return true;
+                                }
+                                if (!(obj instanceof MediaSessionManagerImplBase$RemoteUserInfoImplBase)) {
+                                    return false;
+                                }
+                                MediaSessionManagerImplBase$RemoteUserInfoImplBase mediaSessionManagerImplBase$RemoteUserInfoImplBase = (MediaSessionManagerImplBase$RemoteUserInfoImplBase) obj;
+                                return TextUtils.equals(this.a, mediaSessionManagerImplBase$RemoteUserInfoImplBase.a) && this.b == mediaSessionManagerImplBase$RemoteUserInfoImplBase.b && this.c == mediaSessionManagerImplBase$RemoteUserInfoImplBase.c;
+                            }
+
+                            public int hashCode() {
+                                return ObjectsCompat.a(this.a, Integer.valueOf(this.b), Integer.valueOf(this.c));
+                            }
+                        };
+                    }
+                }
+
+                public boolean equals(Object obj) {
+                    if (this == obj) {
+                        return true;
+                    }
+                    if (obj instanceof MediaSessionManager$RemoteUserInfo) {
+                        return this.a.equals(((MediaSessionManager$RemoteUserInfo) obj).a);
+                    }
+                    return false;
+                }
+
+                public int hashCode() {
+                    return this.a.hashCode();
+                }
+            };
+            this.b = serviceCallbacks;
+        }
+
+        @Override // android.os.IBinder.DeathRecipient
+        public void binderDied() {
+            MediaBrowserServiceCompat.this.d.post(new Runnable() { // from class: androidx.media.MediaBrowserServiceCompat.ConnectionRecord.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    ConnectionRecord connectionRecord = ConnectionRecord.this;
+                    MediaBrowserServiceCompat.this.b.remove(connectionRecord.b.asBinder());
+                }
+            });
+        }
+    }
+
+    interface MediaBrowserServiceImpl {
+        IBinder a(Intent intent);
+
+        void a();
+    }
+
+    class MediaBrowserServiceImplApi28 extends MediaBrowserServiceImplApi26 {
+        MediaBrowserServiceImplApi28(MediaBrowserServiceCompat mediaBrowserServiceCompat) {
+            super();
+        }
+    }
+
+    class MediaBrowserServiceImplBase implements MediaBrowserServiceImpl {
+        private Messenger a;
+
+        MediaBrowserServiceImplBase() {
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImpl
+        public void a() {
+            this.a = new Messenger(MediaBrowserServiceCompat.this.d);
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImpl
+        public IBinder a(Intent intent) {
+            if ("android.media.browse.MediaBrowserService".equals(intent.getAction())) {
+                return this.a.getBinder();
+            }
+            return null;
+        }
+    }
+
+    public static class Result<T> {
+        private final Object a;
+        private boolean b;
+        private boolean c;
+        private boolean d;
+        private int e;
+
+        Result(Object obj) {
+            this.a = obj;
+        }
+
+        void a(int i) {
+            this.e = i;
+        }
+
+        void a(T t) {
+            throw null;
+        }
+
+        public void b(T t) {
+            if (!this.c && !this.d) {
+                this.c = true;
+                a((Result<T>) t);
+            } else {
+                throw new IllegalStateException("sendResult() called when either sendResult() or sendError() had already been called for: " + this.a);
+            }
+        }
+
+        int a() {
+            return this.e;
+        }
+
+        void a(Bundle bundle) {
+            throw new UnsupportedOperationException("It is not supported to send an error for " + this.a);
+        }
+
+        public void b(Bundle bundle) {
+            if (!this.c && !this.d) {
+                this.d = true;
+                a(bundle);
+            } else {
+                throw new IllegalStateException("sendError() called when either sendResult() or sendError() had already been called for: " + this.a);
+            }
+        }
+
+        boolean b() {
+            return this.b || this.c || this.d;
+        }
+    }
+
+    private class ServiceBinderImpl {
+        ServiceBinderImpl() {
+        }
+
+        public void a(final String str, final int i, final int i2, final Bundle bundle, final ServiceCallbacks serviceCallbacks) {
+            if (MediaBrowserServiceCompat.this.a(str, i2)) {
+                MediaBrowserServiceCompat.this.d.a(new Runnable() { // from class: androidx.media.MediaBrowserServiceCompat.ServiceBinderImpl.1
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        IBinder asBinder = serviceCallbacks.asBinder();
+                        MediaBrowserServiceCompat.this.b.remove(asBinder);
+                        ConnectionRecord connectionRecord = MediaBrowserServiceCompat.this.new ConnectionRecord(str, i, i2, bundle, serviceCallbacks);
+                        MediaBrowserServiceCompat mediaBrowserServiceCompat = MediaBrowserServiceCompat.this;
+                        mediaBrowserServiceCompat.c = connectionRecord;
+                        connectionRecord.d = mediaBrowserServiceCompat.a(str, i2, bundle);
+                        MediaBrowserServiceCompat mediaBrowserServiceCompat2 = MediaBrowserServiceCompat.this;
+                        mediaBrowserServiceCompat2.c = null;
+                        if (connectionRecord.d != null) {
+                            try {
+                                mediaBrowserServiceCompat2.b.put(asBinder, connectionRecord);
+                                asBinder.linkToDeath(connectionRecord, 0);
+                                if (MediaBrowserServiceCompat.this.e == null) {
+                                    return;
+                                }
+                                connectionRecord.d.b();
+                                throw null;
+                            } catch (RemoteException unused) {
+                                Log.w("MBServiceCompat", "Calling onConnect() failed. Dropping client. pkg=" + str);
+                                MediaBrowserServiceCompat.this.b.remove(asBinder);
+                                return;
+                            }
+                        }
+                        Log.i("MBServiceCompat", "No root for client " + str + " from service " + AnonymousClass1.class.getName());
+                        try {
+                            serviceCallbacks.a();
+                        } catch (RemoteException unused2) {
+                            Log.w("MBServiceCompat", "Calling onConnectFailed() failed. Ignoring. pkg=" + str);
+                        }
+                    }
+                });
+                return;
+            }
+            throw new IllegalArgumentException("Package/uid mismatch: uid=" + i2 + " package=" + str);
+        }
+
+        public void b(final ServiceCallbacks serviceCallbacks) {
+            MediaBrowserServiceCompat.this.d.a(new Runnable() { // from class: androidx.media.MediaBrowserServiceCompat.ServiceBinderImpl.7
+                @Override // java.lang.Runnable
+                public void run() {
+                    IBinder asBinder = serviceCallbacks.asBinder();
+                    ConnectionRecord remove = MediaBrowserServiceCompat.this.b.remove(asBinder);
+                    if (remove != null) {
+                        asBinder.unlinkToDeath(remove, 0);
+                    }
+                }
+            });
+        }
+
+        public void b(final String str, final Bundle bundle, final ResultReceiver resultReceiver, final ServiceCallbacks serviceCallbacks) {
+            if (TextUtils.isEmpty(str) || resultReceiver == null) {
+                return;
+            }
+            MediaBrowserServiceCompat.this.d.a(new Runnable() { // from class: androidx.media.MediaBrowserServiceCompat.ServiceBinderImpl.9
+                @Override // java.lang.Runnable
+                public void run() {
+                    ConnectionRecord connectionRecord = MediaBrowserServiceCompat.this.b.get(serviceCallbacks.asBinder());
+                    if (connectionRecord != null) {
+                        MediaBrowserServiceCompat.this.a(str, bundle, connectionRecord, resultReceiver);
+                        return;
+                    }
+                    Log.w("MBServiceCompat", "sendCustomAction for callback that isn't registered action=" + str + ", extras=" + bundle);
+                }
+            });
+        }
+
+        public void a(final ServiceCallbacks serviceCallbacks) {
+            MediaBrowserServiceCompat.this.d.a(new Runnable() { // from class: androidx.media.MediaBrowserServiceCompat.ServiceBinderImpl.2
+                @Override // java.lang.Runnable
+                public void run() {
+                    ConnectionRecord remove = MediaBrowserServiceCompat.this.b.remove(serviceCallbacks.asBinder());
+                    if (remove != null) {
+                        remove.b.asBinder().unlinkToDeath(remove, 0);
+                    }
+                }
+            });
+        }
+
+        public void a(final String str, final IBinder iBinder, final Bundle bundle, final ServiceCallbacks serviceCallbacks) {
+            MediaBrowserServiceCompat.this.d.a(new Runnable() { // from class: androidx.media.MediaBrowserServiceCompat.ServiceBinderImpl.3
+                @Override // java.lang.Runnable
+                public void run() {
+                    ConnectionRecord connectionRecord = MediaBrowserServiceCompat.this.b.get(serviceCallbacks.asBinder());
+                    if (connectionRecord != null) {
+                        MediaBrowserServiceCompat.this.a(str, connectionRecord, iBinder, bundle);
+                        return;
+                    }
+                    Log.w("MBServiceCompat", "addSubscription for callback that isn't registered id=" + str);
+                }
+            });
+        }
+
+        public void a(final String str, final IBinder iBinder, final ServiceCallbacks serviceCallbacks) {
+            MediaBrowserServiceCompat.this.d.a(new Runnable() { // from class: androidx.media.MediaBrowserServiceCompat.ServiceBinderImpl.4
+                @Override // java.lang.Runnable
+                public void run() {
+                    ConnectionRecord connectionRecord = MediaBrowserServiceCompat.this.b.get(serviceCallbacks.asBinder());
+                    if (connectionRecord == null) {
+                        Log.w("MBServiceCompat", "removeSubscription for callback that isn't registered id=" + str);
+                        return;
+                    }
+                    if (MediaBrowserServiceCompat.this.a(str, connectionRecord, iBinder)) {
+                        return;
+                    }
+                    Log.w("MBServiceCompat", "removeSubscription called for " + str + " which is not subscribed");
+                }
+            });
+        }
+
+        public void a(final String str, final ResultReceiver resultReceiver, final ServiceCallbacks serviceCallbacks) {
+            if (TextUtils.isEmpty(str) || resultReceiver == null) {
+                return;
+            }
+            MediaBrowserServiceCompat.this.d.a(new Runnable() { // from class: androidx.media.MediaBrowserServiceCompat.ServiceBinderImpl.5
+                @Override // java.lang.Runnable
+                public void run() {
+                    ConnectionRecord connectionRecord = MediaBrowserServiceCompat.this.b.get(serviceCallbacks.asBinder());
+                    if (connectionRecord != null) {
+                        MediaBrowserServiceCompat.this.a(str, connectionRecord, resultReceiver);
+                        return;
+                    }
+                    Log.w("MBServiceCompat", "getMediaItem for callback that isn't registered id=" + str);
+                }
+            });
+        }
+
+        public void a(final ServiceCallbacks serviceCallbacks, final String str, final int i, final int i2, final Bundle bundle) {
+            MediaBrowserServiceCompat.this.d.a(new Runnable() { // from class: androidx.media.MediaBrowserServiceCompat.ServiceBinderImpl.6
+                @Override // java.lang.Runnable
+                public void run() {
+                    IBinder asBinder = serviceCallbacks.asBinder();
+                    MediaBrowserServiceCompat.this.b.remove(asBinder);
+                    ConnectionRecord connectionRecord = MediaBrowserServiceCompat.this.new ConnectionRecord(str, i, i2, bundle, serviceCallbacks);
+                    MediaBrowserServiceCompat.this.b.put(asBinder, connectionRecord);
+                    try {
+                        asBinder.linkToDeath(connectionRecord, 0);
+                    } catch (RemoteException unused) {
+                        Log.w("MBServiceCompat", "IBinder is already dead.");
+                    }
+                }
+            });
+        }
+
+        public void a(final String str, final Bundle bundle, final ResultReceiver resultReceiver, final ServiceCallbacks serviceCallbacks) {
+            if (TextUtils.isEmpty(str) || resultReceiver == null) {
+                return;
+            }
+            MediaBrowserServiceCompat.this.d.a(new Runnable() { // from class: androidx.media.MediaBrowserServiceCompat.ServiceBinderImpl.8
+                @Override // java.lang.Runnable
+                public void run() {
+                    ConnectionRecord connectionRecord = MediaBrowserServiceCompat.this.b.get(serviceCallbacks.asBinder());
+                    if (connectionRecord != null) {
+                        MediaBrowserServiceCompat.this.b(str, bundle, connectionRecord, resultReceiver);
+                        return;
+                    }
+                    Log.w("MBServiceCompat", "search for callback that isn't registered query=" + str);
+                }
+            });
+        }
+    }
+
+    private interface ServiceCallbacks {
+        void a() throws RemoteException;
+
+        void a(String str, List<MediaBrowserCompat.MediaItem> list, Bundle bundle, Bundle bundle2) throws RemoteException;
+
+        IBinder asBinder();
+    }
+
+    private static class ServiceCallbacksCompat implements ServiceCallbacks {
+        final Messenger a;
+
+        ServiceCallbacksCompat(Messenger messenger) {
+            this.a = messenger;
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompat.ServiceCallbacks
+        public void a() throws RemoteException {
+            a(2, null);
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompat.ServiceCallbacks
+        public IBinder asBinder() {
+            return this.a.getBinder();
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompat.ServiceCallbacks
+        public void a(String str, List<MediaBrowserCompat.MediaItem> list, Bundle bundle, Bundle bundle2) throws RemoteException {
+            Bundle bundle3 = new Bundle();
+            bundle3.putString("data_media_item_id", str);
+            bundle3.putBundle("data_options", bundle);
+            bundle3.putBundle("data_notify_children_changed_options", bundle2);
+            if (list != null) {
+                bundle3.putParcelableArrayList("data_media_item_list", list instanceof ArrayList ? (ArrayList) list : new ArrayList<>(list));
+            }
+            a(3, bundle3);
+        }
+
+        private void a(int i, Bundle bundle) throws RemoteException {
+            Message obtain = Message.obtain();
+            obtain.what = i;
+            obtain.arg1 = 2;
+            obtain.setData(bundle);
+            this.a.send(obtain);
+        }
+    }
+
+    private final class ServiceHandler extends Handler {
+        private final ServiceBinderImpl a;
+
+        ServiceHandler() {
+            this.a = MediaBrowserServiceCompat.this.new ServiceBinderImpl();
+        }
+
+        public void a(Runnable runnable) {
+            if (Thread.currentThread() == getLooper().getThread()) {
+                runnable.run();
+            } else {
+                post(runnable);
+            }
+        }
+
+        @Override // android.os.Handler
+        public void handleMessage(Message message) {
+            Bundle data = message.getData();
+            switch (message.what) {
+                case 1:
+                    Bundle bundle = data.getBundle("data_root_hints");
+                    MediaSessionCompat.a(bundle);
+                    this.a.a(data.getString("data_package_name"), data.getInt("data_calling_pid"), data.getInt("data_calling_uid"), bundle, new ServiceCallbacksCompat(message.replyTo));
+                    break;
+                case 2:
+                    this.a.a(new ServiceCallbacksCompat(message.replyTo));
+                    break;
+                case 3:
+                    Bundle bundle2 = data.getBundle("data_options");
+                    MediaSessionCompat.a(bundle2);
+                    this.a.a(data.getString("data_media_item_id"), BundleCompat.a(data, "data_callback_token"), bundle2, new ServiceCallbacksCompat(message.replyTo));
+                    break;
+                case 4:
+                    this.a.a(data.getString("data_media_item_id"), BundleCompat.a(data, "data_callback_token"), new ServiceCallbacksCompat(message.replyTo));
+                    break;
+                case 5:
+                    this.a.a(data.getString("data_media_item_id"), (ResultReceiver) data.getParcelable("data_result_receiver"), new ServiceCallbacksCompat(message.replyTo));
+                    break;
+                case 6:
+                    Bundle bundle3 = data.getBundle("data_root_hints");
+                    MediaSessionCompat.a(bundle3);
+                    this.a.a(new ServiceCallbacksCompat(message.replyTo), data.getString("data_package_name"), data.getInt("data_calling_pid"), data.getInt("data_calling_uid"), bundle3);
+                    break;
+                case 7:
+                    this.a.b(new ServiceCallbacksCompat(message.replyTo));
+                    break;
+                case 8:
+                    Bundle bundle4 = data.getBundle("data_search_extras");
+                    MediaSessionCompat.a(bundle4);
+                    this.a.a(data.getString("data_search_query"), bundle4, (ResultReceiver) data.getParcelable("data_result_receiver"), new ServiceCallbacksCompat(message.replyTo));
+                    break;
+                case 9:
+                    Bundle bundle5 = data.getBundle("data_custom_action_extras");
+                    MediaSessionCompat.a(bundle5);
+                    this.a.b(data.getString("data_custom_action"), bundle5, (ResultReceiver) data.getParcelable("data_result_receiver"), new ServiceCallbacksCompat(message.replyTo));
+                    break;
+                default:
+                    Log.w("MBServiceCompat", "Unhandled message: " + message + "\n  Service version: 2\n  Client version: " + message.arg1);
+                    break;
+            }
+        }
+
+        @Override // android.os.Handler
+        public boolean sendMessageAtTime(Message message, long j) {
+            Bundle data = message.getData();
+            data.setClassLoader(MediaBrowserCompat.class.getClassLoader());
+            data.putInt("data_calling_uid", Binder.getCallingUid());
+            data.putInt("data_calling_pid", Binder.getCallingPid());
+            return super.sendMessageAtTime(message, j);
+        }
+    }
+
+    public abstract BrowserRoot a(String str, int i, Bundle bundle);
+
+    public void a(String str) {
+    }
+
+    public void a(String str, Bundle bundle) {
+    }
+
+    public abstract void a(String str, Result<List<MediaBrowserCompat.MediaItem>> result);
+
+    public void a(String str, Result<List<MediaBrowserCompat.MediaItem>> result, Bundle bundle) {
+        result.a(1);
+        a(str, result);
+    }
+
+    public void b(String str, Result<MediaBrowserCompat.MediaItem> result) {
+        result.a(2);
+        result.b((Result<MediaBrowserCompat.MediaItem>) null);
+    }
+
+    @Override // android.app.Service
+    public void dump(FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
+    }
+
+    @Override // android.app.Service
+    public IBinder onBind(Intent intent) {
+        return this.a.a(intent);
+    }
+
+    @Override // android.app.Service
+    public void onCreate() {
+        super.onCreate();
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 28) {
+            this.a = new MediaBrowserServiceImplApi28(this);
+        } else if (i >= 26) {
+            this.a = new MediaBrowserServiceImplApi26();
+        } else if (i >= 23) {
+            this.a = new MediaBrowserServiceImplApi23();
+        } else if (i >= 21) {
+            this.a = new MediaBrowserServiceImplApi21();
+        } else {
+            this.a = new MediaBrowserServiceImplBase();
+        }
+        this.a.a();
+    }
+
+    class MediaBrowserServiceImplApi21 implements MediaBrowserServiceImpl, MediaBrowserServiceCompatApi21.ServiceCompatProxy {
+        final List<Bundle> a = new ArrayList();
+        Object b;
+        Messenger c;
+
+        MediaBrowserServiceImplApi21() {
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImpl
+        public void a() {
+            this.b = MediaBrowserServiceCompatApi21.a(MediaBrowserServiceCompat.this, this);
+            MediaBrowserServiceCompatApi21.a(this.b);
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompatApi21.ServiceCompatProxy
+        public void b(String str, final MediaBrowserServiceCompatApi21.ResultWrapper<List<Parcel>> resultWrapper) {
+            MediaBrowserServiceCompat.this.a(str, new Result<List<MediaBrowserCompat.MediaItem>>(this, str) { // from class: androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImplApi21.2
+                /* JADX INFO: Access modifiers changed from: package-private */
+                @Override // androidx.media.MediaBrowserServiceCompat.Result
+                public void a(List<MediaBrowserCompat.MediaItem> list) {
+                    ArrayList arrayList;
+                    if (list != null) {
+                        arrayList = new ArrayList();
+                        for (MediaBrowserCompat.MediaItem mediaItem : list) {
+                            Parcel obtain = Parcel.obtain();
+                            mediaItem.writeToParcel(obtain, 0);
+                            arrayList.add(obtain);
+                        }
+                    } else {
+                        arrayList = null;
+                    }
+                    resultWrapper.a((MediaBrowserServiceCompatApi21.ResultWrapper) arrayList);
+                }
+            });
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImpl
+        public IBinder a(Intent intent) {
+            return MediaBrowserServiceCompatApi21.a(this.b, intent);
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompatApi21.ServiceCompatProxy
+        public MediaBrowserServiceCompatApi21.BrowserRoot a(String str, int i, Bundle bundle) {
+            Bundle bundle2;
+            if (bundle == null || bundle.getInt("extra_client_version", 0) == 0) {
+                bundle2 = null;
+            } else {
+                bundle.remove("extra_client_version");
+                this.c = new Messenger(MediaBrowserServiceCompat.this.d);
+                bundle2 = new Bundle();
+                bundle2.putInt("extra_service_version", 2);
+                BundleCompat.a(bundle2, "extra_messenger", this.c.getBinder());
+                MediaSessionCompat.Token token = MediaBrowserServiceCompat.this.e;
+                if (token != null) {
+                    IMediaSession extraBinder = token.getExtraBinder();
+                    BundleCompat.a(bundle2, "extra_session_binder", extraBinder == null ? null : extraBinder.asBinder());
+                } else {
+                    this.a.add(bundle2);
+                }
+            }
+            MediaBrowserServiceCompat mediaBrowserServiceCompat = MediaBrowserServiceCompat.this;
+            mediaBrowserServiceCompat.c = mediaBrowserServiceCompat.new ConnectionRecord(str, -1, i, bundle, null);
+            BrowserRoot a = MediaBrowserServiceCompat.this.a(str, i, bundle);
+            MediaBrowserServiceCompat.this.c = null;
+            if (a == null) {
+                return null;
+            }
+            if (bundle2 == null) {
+                a.a();
+                throw null;
+            }
+            a.a();
+            throw null;
+        }
+    }
+
+    class MediaBrowserServiceImplApi23 extends MediaBrowserServiceImplApi21 implements MediaBrowserServiceCompatApi23.ServiceCompatProxy {
+        MediaBrowserServiceImplApi23() {
+            super();
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImplApi21, androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImpl
+        public void a() {
+            this.b = MediaBrowserServiceCompatApi23.a(MediaBrowserServiceCompat.this, this);
+            MediaBrowserServiceCompatApi21.a(this.b);
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompatApi23.ServiceCompatProxy
+        public void a(String str, final MediaBrowserServiceCompatApi21.ResultWrapper<Parcel> resultWrapper) {
+            MediaBrowserServiceCompat.this.b(str, new Result<MediaBrowserCompat.MediaItem>(this, str) { // from class: androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImplApi23.1
+                /* JADX INFO: Access modifiers changed from: package-private */
+                @Override // androidx.media.MediaBrowserServiceCompat.Result
+                public void a(MediaBrowserCompat.MediaItem mediaItem) {
+                    if (mediaItem == null) {
+                        resultWrapper.a((MediaBrowserServiceCompatApi21.ResultWrapper) null);
+                        return;
+                    }
+                    Parcel obtain = Parcel.obtain();
+                    mediaItem.writeToParcel(obtain, 0);
+                    resultWrapper.a((MediaBrowserServiceCompatApi21.ResultWrapper) obtain);
+                }
+            });
+        }
+    }
+
+    class MediaBrowserServiceImplApi26 extends MediaBrowserServiceImplApi23 implements MediaBrowserServiceCompatApi26.ServiceCompatProxy {
+        MediaBrowserServiceImplApi26() {
+            super();
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImplApi23, androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImplApi21, androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImpl
+        public void a() {
+            this.b = MediaBrowserServiceCompatApi26.a(MediaBrowserServiceCompat.this, this);
+            MediaBrowserServiceCompatApi21.a(this.b);
+        }
+
+        @Override // androidx.media.MediaBrowserServiceCompatApi26.ServiceCompatProxy
+        public void a(String str, final MediaBrowserServiceCompatApi26.ResultWrapper resultWrapper, Bundle bundle) {
+            MediaBrowserServiceCompat.this.a(str, new Result<List<MediaBrowserCompat.MediaItem>>(this, str) { // from class: androidx.media.MediaBrowserServiceCompat.MediaBrowserServiceImplApi26.1
+                /* JADX INFO: Access modifiers changed from: package-private */
+                @Override // androidx.media.MediaBrowserServiceCompat.Result
+                public void a(List<MediaBrowserCompat.MediaItem> list) {
+                    ArrayList arrayList;
+                    if (list != null) {
+                        arrayList = new ArrayList();
+                        for (MediaBrowserCompat.MediaItem mediaItem : list) {
+                            Parcel obtain = Parcel.obtain();
+                            mediaItem.writeToParcel(obtain, 0);
+                            arrayList.add(obtain);
+                        }
+                    } else {
+                        arrayList = null;
+                    }
+                    resultWrapper.a(arrayList, a());
+                }
+            }, bundle);
+        }
+    }
+
+    public void a(String str, Bundle bundle, Result<Bundle> result) {
+        result.b((Bundle) null);
+    }
+
+    public void b(String str, Bundle bundle, Result<List<MediaBrowserCompat.MediaItem>> result) {
+        result.a(4);
+        result.b((Result<List<MediaBrowserCompat.MediaItem>>) null);
+    }
+
+    boolean a(String str, int i) {
+        if (str == null) {
+            return false;
+        }
+        for (String str2 : getPackageManager().getPackagesForUid(i)) {
+            if (str2.equals(str)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    void b(String str, Bundle bundle, ConnectionRecord connectionRecord, final ResultReceiver resultReceiver) {
+        Result<List<MediaBrowserCompat.MediaItem>> result = new Result<List<MediaBrowserCompat.MediaItem>>(this, str) { // from class: androidx.media.MediaBrowserServiceCompat.3
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // androidx.media.MediaBrowserServiceCompat.Result
+            public void a(List<MediaBrowserCompat.MediaItem> list) {
+                if ((a() & 4) != 0 || list == null) {
+                    resultReceiver.send(-1, null);
+                    return;
+                }
+                Bundle bundle2 = new Bundle();
+                bundle2.putParcelableArray("search_results", (Parcelable[]) list.toArray(new MediaBrowserCompat.MediaItem[0]));
+                resultReceiver.send(0, bundle2);
+            }
+        };
+        b(str, bundle, result);
+        if (result.b()) {
+            return;
+        }
+        throw new IllegalStateException("onSearch must call detach() or sendResult() before returning for query=" + str);
+    }
+
+    void a(String str, ConnectionRecord connectionRecord, IBinder iBinder, Bundle bundle) {
+        List<Pair<IBinder, Bundle>> list = connectionRecord.c.get(str);
+        if (list == null) {
+            list = new ArrayList<>();
+        }
+        for (Pair<IBinder, Bundle> pair : list) {
+            if (iBinder == pair.a && MediaBrowserCompatUtils.a(bundle, pair.b)) {
+                return;
+            }
+        }
+        list.add(new Pair<>(iBinder, bundle));
+        connectionRecord.c.put(str, list);
+        a(str, connectionRecord, bundle, (Bundle) null);
+        a(str, bundle);
+    }
+
+    boolean a(String str, ConnectionRecord connectionRecord, IBinder iBinder) {
+        boolean z = false;
+        try {
+            if (iBinder == null) {
+                return connectionRecord.c.remove(str) != null;
+            }
+            List<Pair<IBinder, Bundle>> list = connectionRecord.c.get(str);
+            if (list != null) {
+                Iterator<Pair<IBinder, Bundle>> it = list.iterator();
+                while (it.hasNext()) {
+                    if (iBinder == it.next().a) {
+                        it.remove();
+                        z = true;
+                    }
+                }
+                if (list.size() == 0) {
+                    connectionRecord.c.remove(str);
+                }
+            }
+            return z;
+        } finally {
+            a(str);
+        }
+    }
+
+    void a(final String str, final ConnectionRecord connectionRecord, final Bundle bundle, final Bundle bundle2) {
+        Result<List<MediaBrowserCompat.MediaItem>> result = new Result<List<MediaBrowserCompat.MediaItem>>(str) { // from class: androidx.media.MediaBrowserServiceCompat.1
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // androidx.media.MediaBrowserServiceCompat.Result
+            public void a(List<MediaBrowserCompat.MediaItem> list) {
+                if (MediaBrowserServiceCompat.this.b.get(connectionRecord.b.asBinder()) != connectionRecord) {
+                    if (MediaBrowserServiceCompat.f) {
+                        Log.d("MBServiceCompat", "Not sending onLoadChildren result for connection that has been disconnected. pkg=" + connectionRecord.a + " id=" + str);
+                        return;
+                    }
+                    return;
+                }
+                if ((a() & 1) != 0) {
+                    list = MediaBrowserServiceCompat.this.a(list, bundle);
+                }
+                try {
+                    connectionRecord.b.a(str, list, bundle, bundle2);
+                } catch (RemoteException unused) {
+                    Log.w("MBServiceCompat", "Calling onLoadChildren() failed for id=" + str + " package=" + connectionRecord.a);
+                }
+            }
+        };
+        if (bundle == null) {
+            a(str, result);
+        } else {
+            a(str, result, bundle);
+        }
+        if (result.b()) {
+            return;
+        }
+        throw new IllegalStateException("onLoadChildren must call detach() or sendResult() before returning for package=" + connectionRecord.a + " id=" + str);
+    }
+
+    List<MediaBrowserCompat.MediaItem> a(List<MediaBrowserCompat.MediaItem> list, Bundle bundle) {
+        if (list == null) {
+            return null;
+        }
+        int i = bundle.getInt("android.media.browse.extra.PAGE", -1);
+        int i2 = bundle.getInt("android.media.browse.extra.PAGE_SIZE", -1);
+        if (i == -1 && i2 == -1) {
+            return list;
+        }
+        int i3 = i2 * i;
+        int i4 = i3 + i2;
+        if (i >= 0 && i2 >= 1 && i3 < list.size()) {
+            if (i4 > list.size()) {
+                i4 = list.size();
+            }
+            return list.subList(i3, i4);
+        }
+        return Collections.emptyList();
+    }
+
+    void a(String str, ConnectionRecord connectionRecord, final ResultReceiver resultReceiver) {
+        Result<MediaBrowserCompat.MediaItem> result = new Result<MediaBrowserCompat.MediaItem>(this, str) { // from class: androidx.media.MediaBrowserServiceCompat.2
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // androidx.media.MediaBrowserServiceCompat.Result
+            public void a(MediaBrowserCompat.MediaItem mediaItem) {
+                if ((a() & 2) != 0) {
+                    resultReceiver.send(-1, null);
+                    return;
+                }
+                Bundle bundle = new Bundle();
+                bundle.putParcelable("media_item", mediaItem);
+                resultReceiver.send(0, bundle);
+            }
+        };
+        b(str, result);
+        if (result.b()) {
+            return;
+        }
+        throw new IllegalStateException("onLoadItem must call detach() or sendResult() before returning for id=" + str);
+    }
+
+    void a(String str, Bundle bundle, ConnectionRecord connectionRecord, final ResultReceiver resultReceiver) {
+        Result<Bundle> result = new Result<Bundle>(this, str) { // from class: androidx.media.MediaBrowserServiceCompat.4
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // androidx.media.MediaBrowserServiceCompat.Result
+            /* renamed from: c, reason: merged with bridge method [inline-methods] */
+            public void a(Bundle bundle2) {
+                resultReceiver.send(0, bundle2);
+            }
+
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // androidx.media.MediaBrowserServiceCompat.Result
+            void a(Bundle bundle2) {
+                resultReceiver.send(-1, bundle2);
+            }
+        };
+        a(str, bundle, result);
+        if (result.b()) {
+            return;
+        }
+        throw new IllegalStateException("onCustomAction must call detach() or sendResult() or sendError() before returning for action=" + str + " extras=" + bundle);
+    }
+}

sources/androidx/media/MediaBrowserServiceCompatApi21.java

@@ -0,0 +1,100 @@
+package androidx.media;
+
+import android.content.Context;
+import android.content.Intent;
+import android.media.browse.MediaBrowser;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.service.media.MediaBrowserService;
+import android.support.v4.media.session.MediaSessionCompat;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes.dex */
+class MediaBrowserServiceCompatApi21 {
+
+    static class BrowserRoot {
+        final String a;
+        final Bundle b;
+    }
+
+    static class MediaBrowserServiceAdaptor extends MediaBrowserService {
+        final ServiceCompatProxy a;
+
+        MediaBrowserServiceAdaptor(Context context, ServiceCompatProxy serviceCompatProxy) {
+            attachBaseContext(context);
+            this.a = serviceCompatProxy;
+        }
+
+        @Override // android.service.media.MediaBrowserService
+        public MediaBrowserService.BrowserRoot onGetRoot(String str, int i, Bundle bundle) {
+            MediaSessionCompat.a(bundle);
+            BrowserRoot a = this.a.a(str, i, bundle == null ? null : new Bundle(bundle));
+            if (a == null) {
+                return null;
+            }
+            return new MediaBrowserService.BrowserRoot(a.a, a.b);
+        }
+
+        @Override // android.service.media.MediaBrowserService
+        public void onLoadChildren(String str, MediaBrowserService.Result<List<MediaBrowser.MediaItem>> result) {
+            this.a.b(str, new ResultWrapper<>(result));
+        }
+    }
+
+    public interface ServiceCompatProxy {
+        BrowserRoot a(String str, int i, Bundle bundle);
+
+        void b(String str, ResultWrapper<List<Parcel>> resultWrapper);
+    }
+
+    public static Object a(Context context, ServiceCompatProxy serviceCompatProxy) {
+        return new MediaBrowserServiceAdaptor(context, serviceCompatProxy);
+    }
+
+    public static void a(Object obj) {
+        ((MediaBrowserService) obj).onCreate();
+    }
+
+    public static IBinder a(Object obj, Intent intent) {
+        return ((MediaBrowserService) obj).onBind(intent);
+    }
+
+    static class ResultWrapper<T> {
+        MediaBrowserService.Result a;
+
+        ResultWrapper(MediaBrowserService.Result result) {
+            this.a = result;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        public void a(T t) {
+            if (t instanceof List) {
+                this.a.sendResult(a((List<Parcel>) t));
+                return;
+            }
+            if (!(t instanceof Parcel)) {
+                this.a.sendResult(null);
+                return;
+            }
+            Parcel parcel = (Parcel) t;
+            parcel.setDataPosition(0);
+            this.a.sendResult(MediaBrowser.MediaItem.CREATOR.createFromParcel(parcel));
+            parcel.recycle();
+        }
+
+        List<MediaBrowser.MediaItem> a(List<Parcel> list) {
+            if (list == null) {
+                return null;
+            }
+            ArrayList arrayList = new ArrayList();
+            for (Parcel parcel : list) {
+                parcel.setDataPosition(0);
+                arrayList.add(MediaBrowser.MediaItem.CREATOR.createFromParcel(parcel));
+                parcel.recycle();
+            }
+            return arrayList;
+        }
+    }
+}

sources/androidx/media/MediaBrowserServiceCompatApi23.java

@@ -0,0 +1,30 @@
+package androidx.media;
+
+import android.content.Context;
+import android.media.browse.MediaBrowser;
+import android.os.Parcel;
+import android.service.media.MediaBrowserService;
+import androidx.media.MediaBrowserServiceCompatApi21;
+
+/* loaded from: classes.dex */
+class MediaBrowserServiceCompatApi23 {
+
+    static class MediaBrowserServiceAdaptor extends MediaBrowserServiceCompatApi21.MediaBrowserServiceAdaptor {
+        MediaBrowserServiceAdaptor(Context context, ServiceCompatProxy serviceCompatProxy) {
+            super(context, serviceCompatProxy);
+        }
+
+        @Override // android.service.media.MediaBrowserService
+        public void onLoadItem(String str, MediaBrowserService.Result<MediaBrowser.MediaItem> result) {
+            ((ServiceCompatProxy) this.a).a(str, new MediaBrowserServiceCompatApi21.ResultWrapper<>(result));
+        }
+    }
+
+    public interface ServiceCompatProxy extends MediaBrowserServiceCompatApi21.ServiceCompatProxy {
+        void a(String str, MediaBrowserServiceCompatApi21.ResultWrapper<Parcel> resultWrapper);
+    }
+
+    public static Object a(Context context, ServiceCompatProxy serviceCompatProxy) {
+        return new MediaBrowserServiceAdaptor(context, serviceCompatProxy);
+    }
+}

sources/androidx/media/MediaBrowserServiceCompatApi26.java

@@ -0,0 +1,77 @@
+package androidx.media;
+
+import android.content.Context;
+import android.media.browse.MediaBrowser;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.service.media.MediaBrowserService;
+import android.support.v4.media.session.MediaSessionCompat;
+import android.util.Log;
+import androidx.media.MediaBrowserServiceCompatApi23;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes.dex */
+class MediaBrowserServiceCompatApi26 {
+    static Field a;
+
+    static class MediaBrowserServiceAdaptor extends MediaBrowserServiceCompatApi23.MediaBrowserServiceAdaptor {
+        MediaBrowserServiceAdaptor(Context context, ServiceCompatProxy serviceCompatProxy) {
+            super(context, serviceCompatProxy);
+        }
+
+        @Override // android.service.media.MediaBrowserService
+        public void onLoadChildren(String str, MediaBrowserService.Result<List<MediaBrowser.MediaItem>> result, Bundle bundle) {
+            MediaSessionCompat.a(bundle);
+            ((ServiceCompatProxy) this.a).a(str, new ResultWrapper(result), bundle);
+        }
+    }
+
+    public interface ServiceCompatProxy extends MediaBrowserServiceCompatApi23.ServiceCompatProxy {
+        void a(String str, ResultWrapper resultWrapper, Bundle bundle);
+    }
+
+    static {
+        try {
+            a = MediaBrowserService.Result.class.getDeclaredField("mFlags");
+            a.setAccessible(true);
+        } catch (NoSuchFieldException e) {
+            Log.w("MBSCompatApi26", e);
+        }
+    }
+
+    public static Object a(Context context, ServiceCompatProxy serviceCompatProxy) {
+        return new MediaBrowserServiceAdaptor(context, serviceCompatProxy);
+    }
+
+    static class ResultWrapper {
+        MediaBrowserService.Result a;
+
+        ResultWrapper(MediaBrowserService.Result result) {
+            this.a = result;
+        }
+
+        public void a(List<Parcel> list, int i) {
+            try {
+                MediaBrowserServiceCompatApi26.a.setInt(this.a, i);
+            } catch (IllegalAccessException e) {
+                Log.w("MBSCompatApi26", e);
+            }
+            this.a.sendResult(a(list));
+        }
+
+        List<MediaBrowser.MediaItem> a(List<Parcel> list) {
+            if (list == null) {
+                return null;
+            }
+            ArrayList arrayList = new ArrayList();
+            for (Parcel parcel : list) {
+                parcel.setDataPosition(0);
+                arrayList.add(MediaBrowser.MediaItem.CREATOR.createFromParcel(parcel));
+                parcel.recycle();
+            }
+            return arrayList;
+        }
+    }
+}

sources/androidx/media/MediaSessionManager$RemoteUserInfoImpl.java

@@ -0,0 +1,5 @@
+package androidx.media;
+
+/* loaded from: classes.dex */
+interface MediaSessionManager$RemoteUserInfoImpl {
+}

sources/androidx/media/session/MediaButtonReceiver.java

@@ -0,0 +1,108 @@
+package androidx.media.session;
+
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.os.Build;
+import android.os.RemoteException;
+import android.support.v4.media.MediaBrowserCompat;
+import android.support.v4.media.session.MediaControllerCompat;
+import android.util.Log;
+import android.view.KeyEvent;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class MediaButtonReceiver extends BroadcastReceiver {
+
+    private static class MediaButtonConnectionCallback extends MediaBrowserCompat.ConnectionCallback {
+        private final Context c;
+        private final Intent d;
+        private final BroadcastReceiver.PendingResult e;
+        private MediaBrowserCompat f;
+
+        MediaButtonConnectionCallback(Context context, Intent intent, BroadcastReceiver.PendingResult pendingResult) {
+            this.c = context;
+            this.d = intent;
+            this.e = pendingResult;
+        }
+
+        private void d() {
+            this.f.b();
+            this.e.finish();
+        }
+
+        void a(MediaBrowserCompat mediaBrowserCompat) {
+            this.f = mediaBrowserCompat;
+        }
+
+        @Override // android.support.v4.media.MediaBrowserCompat.ConnectionCallback
+        public void b() {
+            d();
+        }
+
+        @Override // android.support.v4.media.MediaBrowserCompat.ConnectionCallback
+        public void c() {
+            d();
+        }
+
+        @Override // android.support.v4.media.MediaBrowserCompat.ConnectionCallback
+        public void a() {
+            try {
+                new MediaControllerCompat(this.c, this.f.c()).a((KeyEvent) this.d.getParcelableExtra("android.intent.extra.KEY_EVENT"));
+            } catch (RemoteException e) {
+                Log.e("MediaButtonReceiver", "Failed to create a media controller", e);
+            }
+            d();
+        }
+    }
+
+    private static void a(Context context, Intent intent) {
+        if (Build.VERSION.SDK_INT >= 26) {
+            context.startForegroundService(intent);
+        } else {
+            context.startService(intent);
+        }
+    }
+
+    @Override // android.content.BroadcastReceiver
+    public void onReceive(Context context, Intent intent) {
+        if (intent == null || !"android.intent.action.MEDIA_BUTTON".equals(intent.getAction()) || !intent.hasExtra("android.intent.extra.KEY_EVENT")) {
+            Log.d("MediaButtonReceiver", "Ignore unsupported intent: " + intent);
+            return;
+        }
+        ComponentName a = a(context, "android.intent.action.MEDIA_BUTTON");
+        if (a != null) {
+            intent.setComponent(a);
+            a(context, intent);
+            return;
+        }
+        ComponentName a2 = a(context, "android.media.browse.MediaBrowserService");
+        if (a2 == null) {
+            throw new IllegalStateException("Could not find any Service that handles android.intent.action.MEDIA_BUTTON or implements a media browser service.");
+        }
+        BroadcastReceiver.PendingResult goAsync = goAsync();
+        Context applicationContext = context.getApplicationContext();
+        MediaButtonConnectionCallback mediaButtonConnectionCallback = new MediaButtonConnectionCallback(applicationContext, intent, goAsync);
+        MediaBrowserCompat mediaBrowserCompat = new MediaBrowserCompat(applicationContext, a2, mediaButtonConnectionCallback, null);
+        mediaButtonConnectionCallback.a(mediaBrowserCompat);
+        mediaBrowserCompat.a();
+    }
+
+    private static ComponentName a(Context context, String str) {
+        PackageManager packageManager = context.getPackageManager();
+        Intent intent = new Intent(str);
+        intent.setPackage(context.getPackageName());
+        List<ResolveInfo> queryIntentServices = packageManager.queryIntentServices(intent, 0);
+        if (queryIntentServices.size() == 1) {
+            ResolveInfo resolveInfo = queryIntentServices.get(0);
+            return new ComponentName(resolveInfo.serviceInfo.packageName, resolveInfo.serviceInfo.name);
+        }
+        if (queryIntentServices.isEmpty()) {
+            return null;
+        }
+        throw new IllegalStateException("Expected 1 service that handles " + str + ", found " + queryIntentServices.size());
+    }
+}