Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/media/AudioAttributesCompat.java

@@ -0,0 +1,288 @@
+package androidx.media;
+
+import android.media.AudioAttributes;
+import android.util.SparseIntArray;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.media.AudioAttributesImpl;
+import androidx.media.AudioAttributesImplApi26;
+import androidx.media.AudioAttributesImplBase;
+import androidx.versionedparcelable.VersionedParcelable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes.dex */
+public class AudioAttributesCompat implements VersionedParcelable {
+    public static final int CONTENT_TYPE_MOVIE = 3;
+    public static final int CONTENT_TYPE_MUSIC = 2;
+    public static final int CONTENT_TYPE_SONIFICATION = 4;
+    public static final int CONTENT_TYPE_SPEECH = 1;
+    public static final int CONTENT_TYPE_UNKNOWN = 0;
+    static final int FLAG_ALL = 1023;
+    static final int FLAG_ALL_PUBLIC = 273;
+    public static final int FLAG_AUDIBILITY_ENFORCED = 1;
+    static final int FLAG_BEACON = 8;
+    static final int FLAG_BYPASS_INTERRUPTION_POLICY = 64;
+    static final int FLAG_BYPASS_MUTE = 128;
+    static final int FLAG_DEEP_BUFFER = 512;
+    public static final int FLAG_HW_AV_SYNC = 16;
+    static final int FLAG_HW_HOTWORD = 32;
+    static final int FLAG_LOW_LATENCY = 256;
+    static final int FLAG_SCO = 4;
+    static final int FLAG_SECURE = 2;
+    static final int INVALID_STREAM_TYPE = -1;
+    private static final int[] SDK_USAGES;
+    private static final int SUPPRESSIBLE_CALL = 2;
+    private static final int SUPPRESSIBLE_NOTIFICATION = 1;
+    private static final SparseIntArray SUPPRESSIBLE_USAGES;
+    static final String TAG = "AudioAttributesCompat";
+    public static final int USAGE_ALARM = 4;
+    public static final int USAGE_ASSISTANCE_ACCESSIBILITY = 11;
+    public static final int USAGE_ASSISTANCE_NAVIGATION_GUIDANCE = 12;
+    public static final int USAGE_ASSISTANCE_SONIFICATION = 13;
+    public static final int USAGE_ASSISTANT = 16;
+    public static final int USAGE_GAME = 14;
+    public static final int USAGE_MEDIA = 1;
+    public static final int USAGE_NOTIFICATION = 5;
+    public static final int USAGE_NOTIFICATION_COMMUNICATION_DELAYED = 9;
+    public static final int USAGE_NOTIFICATION_COMMUNICATION_INSTANT = 8;
+    public static final int USAGE_NOTIFICATION_COMMUNICATION_REQUEST = 7;
+    public static final int USAGE_NOTIFICATION_EVENT = 10;
+    public static final int USAGE_NOTIFICATION_RINGTONE = 6;
+    public static final int USAGE_UNKNOWN = 0;
+    static final int USAGE_VIRTUAL_SOURCE = 15;
+    public static final int USAGE_VOICE_COMMUNICATION = 2;
+    public static final int USAGE_VOICE_COMMUNICATION_SIGNALLING = 3;
+    static boolean sForceLegacyBehavior;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public AudioAttributesImpl mImpl;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface AttributeContentType {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface AttributeUsage {
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static void setForceLegacyBehavior(boolean z) {
+        sForceLegacyBehavior = z;
+    }
+
+    static {
+        SparseIntArray sparseIntArray = new SparseIntArray();
+        SUPPRESSIBLE_USAGES = sparseIntArray;
+        sparseIntArray.put(5, 1);
+        sparseIntArray.put(6, 2);
+        sparseIntArray.put(7, 2);
+        sparseIntArray.put(8, 1);
+        sparseIntArray.put(9, 1);
+        sparseIntArray.put(10, 1);
+        SDK_USAGES = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16};
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public AudioAttributesCompat() {
+    }
+
+    public AudioAttributesCompat(AudioAttributesImpl audioAttributesImpl) {
+        this.mImpl = audioAttributesImpl;
+    }
+
+    public int getVolumeControlStream() {
+        return this.mImpl.getVolumeControlStream();
+    }
+
+    @Nullable
+    public Object unwrap() {
+        return this.mImpl.getAudioAttributes();
+    }
+
+    public int getLegacyStreamType() {
+        return this.mImpl.getLegacyStreamType();
+    }
+
+    @Nullable
+    public static AudioAttributesCompat wrap(@NonNull Object obj) {
+        if (sForceLegacyBehavior) {
+            return null;
+        }
+        return new AudioAttributesCompat(new AudioAttributesImplApi26((AudioAttributes) obj));
+    }
+
+    public int getContentType() {
+        return this.mImpl.getContentType();
+    }
+
+    public int getUsage() {
+        return this.mImpl.getUsage();
+    }
+
+    public int getFlags() {
+        return this.mImpl.getFlags();
+    }
+
+    public static class Builder {
+        final AudioAttributesImpl.Builder mBuilderImpl;
+
+        public Builder() {
+            if (AudioAttributesCompat.sForceLegacyBehavior) {
+                this.mBuilderImpl = new AudioAttributesImplBase.Builder();
+            } else {
+                this.mBuilderImpl = new AudioAttributesImplApi26.Builder();
+            }
+        }
+
+        public Builder(AudioAttributesCompat audioAttributesCompat) {
+            if (AudioAttributesCompat.sForceLegacyBehavior) {
+                this.mBuilderImpl = new AudioAttributesImplBase.Builder(audioAttributesCompat);
+            } else {
+                this.mBuilderImpl = new AudioAttributesImplApi26.Builder(audioAttributesCompat.unwrap());
+            }
+        }
+
+        public AudioAttributesCompat build() {
+            return new AudioAttributesCompat(this.mBuilderImpl.build());
+        }
+
+        public Builder setUsage(int i) {
+            this.mBuilderImpl.setUsage(i);
+            return this;
+        }
+
+        public Builder setContentType(int i) {
+            this.mBuilderImpl.setContentType(i);
+            return this;
+        }
+
+        public Builder setFlags(int i) {
+            this.mBuilderImpl.setFlags(i);
+            return this;
+        }
+
+        public Builder setLegacyStreamType(int i) {
+            this.mBuilderImpl.setLegacyStreamType(i);
+            return this;
+        }
+    }
+
+    public int hashCode() {
+        return this.mImpl.hashCode();
+    }
+
+    public String toString() {
+        return this.mImpl.toString();
+    }
+
+    public static String usageToString(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 static abstract class AudioManagerHidden {
+        public static final int STREAM_ACCESSIBILITY = 10;
+        public static final int STREAM_BLUETOOTH_SCO = 6;
+        public static final int STREAM_SYSTEM_ENFORCED = 7;
+        public static final int STREAM_TTS = 9;
+
+        private AudioManagerHidden() {
+        }
+    }
+
+    public int getRawLegacyStreamType() {
+        return this.mImpl.getRawLegacyStreamType();
+    }
+
+    public static int toVolumeStreamType(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:
+            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");
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof AudioAttributesCompat)) {
+            return false;
+        }
+        AudioAttributesCompat audioAttributesCompat = (AudioAttributesCompat) obj;
+        AudioAttributesImpl audioAttributesImpl = this.mImpl;
+        if (audioAttributesImpl == null) {
+            return audioAttributesCompat.mImpl == null;
+        }
+        return audioAttributesImpl.equals(audioAttributesCompat.mImpl);
+    }
+}

decompiled/sources/androidx/media/AudioAttributesCompatParcelizer.java

@@ -0,0 +1,19 @@
+package androidx.media;
+
+import androidx.annotation.RestrictTo;
+import androidx.versionedparcelable.VersionedParcel;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public class AudioAttributesCompatParcelizer {
+    public static AudioAttributesCompat read(VersionedParcel versionedParcel) {
+        AudioAttributesCompat audioAttributesCompat = new AudioAttributesCompat();
+        audioAttributesCompat.mImpl = (AudioAttributesImpl) versionedParcel.readVersionedParcelable(audioAttributesCompat.mImpl, 1);
+        return audioAttributesCompat;
+    }
+
+    public static void write(AudioAttributesCompat audioAttributesCompat, VersionedParcel versionedParcel) {
+        versionedParcel.setSerializationFlags(false, false);
+        versionedParcel.writeVersionedParcelable(audioAttributesCompat.mImpl, 1);
+    }
+}

decompiled/sources/androidx/media/AudioAttributesImpl.java

@@ -0,0 +1,43 @@
+package androidx.media;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.versionedparcelable.VersionedParcelable;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public interface AudioAttributesImpl extends VersionedParcelable {
+
+    public interface Builder {
+        @NonNull
+        AudioAttributesImpl build();
+
+        @NonNull
+        Builder setContentType(int i);
+
+        @NonNull
+        Builder setFlags(int i);
+
+        @NonNull
+        Builder setLegacyStreamType(int i);
+
+        @NonNull
+        Builder setUsage(int i);
+    }
+
+    @Nullable
+    Object getAudioAttributes();
+
+    int getContentType();
+
+    int getFlags();
+
+    int getLegacyStreamType();
+
+    int getRawLegacyStreamType();
+
+    int getUsage();
+
+    int getVolumeControlStream();
+}

decompiled/sources/androidx/media/AudioAttributesImplApi21.java

@@ -0,0 +1,138 @@
+package androidx.media;
+
+import android.annotation.SuppressLint;
+import android.media.AudioAttributes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.media.AudioAttributesImpl;
+
+@RequiresApi(21)
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public class AudioAttributesImplApi21 implements AudioAttributesImpl {
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public AudioAttributes mAudioAttributes;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public int mLegacyStreamType;
+
+    @Override // androidx.media.AudioAttributesImpl
+    @Nullable
+    public Object getAudioAttributes() {
+        return this.mAudioAttributes;
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getRawLegacyStreamType() {
+        return this.mLegacyStreamType;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public AudioAttributesImplApi21() {
+        this.mLegacyStreamType = -1;
+    }
+
+    public AudioAttributesImplApi21(AudioAttributes audioAttributes) {
+        this(audioAttributes, -1);
+    }
+
+    public AudioAttributesImplApi21(AudioAttributes audioAttributes, int i) {
+        this.mAudioAttributes = audioAttributes;
+        this.mLegacyStreamType = i;
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    @SuppressLint({"NewApi"})
+    public int getVolumeControlStream() {
+        return AudioAttributesCompat.toVolumeStreamType(true, getFlags(), getUsage());
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getLegacyStreamType() {
+        int i = this.mLegacyStreamType;
+        return i != -1 ? i : AudioAttributesCompat.toVolumeStreamType(false, getFlags(), getUsage());
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getContentType() {
+        return this.mAudioAttributes.getContentType();
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getUsage() {
+        return this.mAudioAttributes.getUsage();
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getFlags() {
+        return this.mAudioAttributes.getFlags();
+    }
+
+    public int hashCode() {
+        return this.mAudioAttributes.hashCode();
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof AudioAttributesImplApi21) {
+            return this.mAudioAttributes.equals(((AudioAttributesImplApi21) obj).mAudioAttributes);
+        }
+        return false;
+    }
+
+    @NonNull
+    public String toString() {
+        return "AudioAttributesCompat: audioattributes=" + this.mAudioAttributes;
+    }
+
+    public static class Builder implements AudioAttributesImpl.Builder {
+        final AudioAttributes.Builder mFwkBuilder;
+
+        public Builder() {
+            this.mFwkBuilder = new AudioAttributes.Builder();
+        }
+
+        public Builder(Object obj) {
+            this.mFwkBuilder = new AudioAttributes.Builder((AudioAttributes) obj);
+        }
+
+        @Override // androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public AudioAttributesImpl build() {
+            return new AudioAttributesImplApi21(this.mFwkBuilder.build());
+        }
+
+        @Override // androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public Builder setUsage(int i) {
+            if (i == 16) {
+                i = 12;
+            }
+            this.mFwkBuilder.setUsage(i);
+            return this;
+        }
+
+        @Override // androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public Builder setContentType(int i) {
+            this.mFwkBuilder.setContentType(i);
+            return this;
+        }
+
+        @Override // androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public Builder setFlags(int i) {
+            this.mFwkBuilder.setFlags(i);
+            return this;
+        }
+
+        @Override // androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public Builder setLegacyStreamType(int i) {
+            this.mFwkBuilder.setLegacyStreamType(i);
+            return this;
+        }
+    }
+}

decompiled/sources/androidx/media/AudioAttributesImplApi21Parcelizer.java

@@ -0,0 +1,22 @@
+package androidx.media;
+
+import android.media.AudioAttributes;
+import androidx.annotation.RestrictTo;
+import androidx.versionedparcelable.VersionedParcel;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public class AudioAttributesImplApi21Parcelizer {
+    public static AudioAttributesImplApi21 read(VersionedParcel versionedParcel) {
+        AudioAttributesImplApi21 audioAttributesImplApi21 = new AudioAttributesImplApi21();
+        audioAttributesImplApi21.mAudioAttributes = (AudioAttributes) versionedParcel.readParcelable(audioAttributesImplApi21.mAudioAttributes, 1);
+        audioAttributesImplApi21.mLegacyStreamType = versionedParcel.readInt(audioAttributesImplApi21.mLegacyStreamType, 2);
+        return audioAttributesImplApi21;
+    }
+
+    public static void write(AudioAttributesImplApi21 audioAttributesImplApi21, VersionedParcel versionedParcel) {
+        versionedParcel.setSerializationFlags(false, false);
+        versionedParcel.writeParcelable(audioAttributesImplApi21.mAudioAttributes, 1);
+        versionedParcel.writeInt(audioAttributesImplApi21.mLegacyStreamType, 2);
+    }
+}

decompiled/sources/androidx/media/AudioAttributesImplApi26.java

@@ -0,0 +1,47 @@
+package androidx.media;
+
+import android.media.AudioAttributes;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.media.AudioAttributesImplApi21;
+
+@RequiresApi(26)
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public class AudioAttributesImplApi26 extends AudioAttributesImplApi21 {
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public AudioAttributesImplApi26() {
+    }
+
+    public AudioAttributesImplApi26(AudioAttributes audioAttributes) {
+        super(audioAttributes, -1);
+    }
+
+    @Override // androidx.media.AudioAttributesImplApi21, androidx.media.AudioAttributesImpl
+    public int getVolumeControlStream() {
+        return this.mAudioAttributes.getVolumeControlStream();
+    }
+
+    public static class Builder extends AudioAttributesImplApi21.Builder {
+        public Builder() {
+        }
+
+        public Builder(Object obj) {
+            super(obj);
+        }
+
+        @Override // androidx.media.AudioAttributesImplApi21.Builder, androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public AudioAttributesImpl build() {
+            return new AudioAttributesImplApi26(this.mFwkBuilder.build());
+        }
+
+        @Override // androidx.media.AudioAttributesImplApi21.Builder, androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public Builder setUsage(int i) {
+            this.mFwkBuilder.setUsage(i);
+            return this;
+        }
+    }
+}

decompiled/sources/androidx/media/AudioAttributesImplApi26Parcelizer.java

@@ -0,0 +1,22 @@
+package androidx.media;
+
+import android.media.AudioAttributes;
+import androidx.annotation.RestrictTo;
+import androidx.versionedparcelable.VersionedParcel;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public class AudioAttributesImplApi26Parcelizer {
+    public static AudioAttributesImplApi26 read(VersionedParcel versionedParcel) {
+        AudioAttributesImplApi26 audioAttributesImplApi26 = new AudioAttributesImplApi26();
+        audioAttributesImplApi26.mAudioAttributes = (AudioAttributes) versionedParcel.readParcelable(audioAttributesImplApi26.mAudioAttributes, 1);
+        audioAttributesImplApi26.mLegacyStreamType = versionedParcel.readInt(audioAttributesImplApi26.mLegacyStreamType, 2);
+        return audioAttributesImplApi26;
+    }
+
+    public static void write(AudioAttributesImplApi26 audioAttributesImplApi26, VersionedParcel versionedParcel) {
+        versionedParcel.setSerializationFlags(false, false);
+        versionedParcel.writeParcelable(audioAttributesImplApi26.mAudioAttributes, 1);
+        versionedParcel.writeInt(audioAttributesImplApi26.mLegacyStreamType, 2);
+    }
+}

decompiled/sources/androidx/media/AudioAttributesImplBase.java

@@ -0,0 +1,256 @@
+package androidx.media;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.media.AudioAttributesImpl;
+import com.mbridge.msdk.newreward.player.view.floatview.FloatWebTemplateView;
+import java.util.Arrays;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public class AudioAttributesImplBase implements AudioAttributesImpl {
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public int mContentType;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public int mFlags;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public int mLegacyStream;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public int mUsage;
+
+    public static int usageForStreamType(int i) {
+        switch (i) {
+        }
+        return 2;
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    @Nullable
+    public Object getAudioAttributes() {
+        return null;
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getContentType() {
+        return this.mContentType;
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getRawLegacyStreamType() {
+        return this.mLegacyStream;
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getUsage() {
+        return this.mUsage;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public AudioAttributesImplBase() {
+        this.mUsage = 0;
+        this.mContentType = 0;
+        this.mFlags = 0;
+        this.mLegacyStream = -1;
+    }
+
+    public AudioAttributesImplBase(int i, int i2, int i3, int i4) {
+        this.mContentType = i;
+        this.mFlags = i2;
+        this.mUsage = i3;
+        this.mLegacyStream = i4;
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getVolumeControlStream() {
+        return AudioAttributesCompat.toVolumeStreamType(true, this.mFlags, this.mUsage);
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getLegacyStreamType() {
+        int i = this.mLegacyStream;
+        return i != -1 ? i : AudioAttributesCompat.toVolumeStreamType(false, this.mFlags, this.mUsage);
+    }
+
+    @Override // androidx.media.AudioAttributesImpl
+    public int getFlags() {
+        int i = this.mFlags;
+        int legacyStreamType = getLegacyStreamType();
+        if (legacyStreamType == 6) {
+            i |= 4;
+        } else if (legacyStreamType == 7) {
+            i |= 1;
+        }
+        return i & FloatWebTemplateView.FLOAT_MINI_CARD;
+    }
+
+    public int hashCode() {
+        return Arrays.hashCode(new Object[]{Integer.valueOf(this.mContentType), Integer.valueOf(this.mFlags), Integer.valueOf(this.mUsage), Integer.valueOf(this.mLegacyStream)});
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof AudioAttributesImplBase)) {
+            return false;
+        }
+        AudioAttributesImplBase audioAttributesImplBase = (AudioAttributesImplBase) obj;
+        return this.mContentType == audioAttributesImplBase.getContentType() && this.mFlags == audioAttributesImplBase.getFlags() && this.mUsage == audioAttributesImplBase.getUsage() && this.mLegacyStream == audioAttributesImplBase.mLegacyStream;
+    }
+
+    @NonNull
+    public String toString() {
+        StringBuilder sb = new StringBuilder("AudioAttributesCompat:");
+        if (this.mLegacyStream != -1) {
+            sb.append(" stream=");
+            sb.append(this.mLegacyStream);
+            sb.append(" derived");
+        }
+        sb.append(" usage=");
+        sb.append(AudioAttributesCompat.usageToString(this.mUsage));
+        sb.append(" content=");
+        sb.append(this.mContentType);
+        sb.append(" flags=0x");
+        sb.append(Integer.toHexString(this.mFlags).toUpperCase());
+        return sb.toString();
+    }
+
+    public static class Builder implements AudioAttributesImpl.Builder {
+        private int mContentType;
+        private int mFlags;
+        private int mLegacyStream;
+        private int mUsage;
+
+        @Override // androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public Builder setContentType(int i) {
+            if (i == 0 || i == 1 || i == 2 || i == 3 || i == 4) {
+                this.mContentType = i;
+            } else {
+                this.mContentType = 0;
+            }
+            return this;
+        }
+
+        @Override // androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public Builder setFlags(int i) {
+            this.mFlags = (i & 1023) | this.mFlags;
+            return this;
+        }
+
+        @Override // androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public Builder setUsage(int i) {
+            switch (i) {
+                case 0:
+                case 1:
+                case 2:
+                case 3:
+                case 4:
+                case 5:
+                case 6:
+                case 7:
+                case 8:
+                case 9:
+                case 10:
+                case 11:
+                case 12:
+                case 13:
+                case 14:
+                case 15:
+                    this.mUsage = i;
+                    return this;
+                case 16:
+                    this.mUsage = 12;
+                    return this;
+                default:
+                    this.mUsage = 0;
+                    return this;
+            }
+        }
+
+        public Builder() {
+            this.mUsage = 0;
+            this.mContentType = 0;
+            this.mFlags = 0;
+            this.mLegacyStream = -1;
+        }
+
+        public Builder(AudioAttributesCompat audioAttributesCompat) {
+            this.mUsage = 0;
+            this.mContentType = 0;
+            this.mFlags = 0;
+            this.mLegacyStream = -1;
+            this.mUsage = audioAttributesCompat.getUsage();
+            this.mContentType = audioAttributesCompat.getContentType();
+            this.mFlags = audioAttributesCompat.getFlags();
+            this.mLegacyStream = audioAttributesCompat.getRawLegacyStreamType();
+        }
+
+        @Override // androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public AudioAttributesImpl build() {
+            return new AudioAttributesImplBase(this.mContentType, this.mFlags, this.mUsage, this.mLegacyStream);
+        }
+
+        @Override // androidx.media.AudioAttributesImpl.Builder
+        @NonNull
+        public Builder setLegacyStreamType(int i) {
+            if (i == 10) {
+                throw new IllegalArgumentException("STREAM_ACCESSIBILITY is not a legacy stream type that was used for audio playback");
+            }
+            this.mLegacyStream = i;
+            return setInternalLegacyStreamType(i);
+        }
+
+        /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+        private Builder setInternalLegacyStreamType(int i) {
+            switch (i) {
+                case 0:
+                    this.mContentType = 1;
+                    break;
+                case 1:
+                    this.mContentType = 4;
+                    break;
+                case 2:
+                    this.mContentType = 4;
+                    break;
+                case 3:
+                    this.mContentType = 2;
+                    break;
+                case 4:
+                    this.mContentType = 4;
+                    break;
+                case 5:
+                    this.mContentType = 4;
+                    break;
+                case 6:
+                    this.mContentType = 1;
+                    this.mFlags |= 4;
+                    break;
+                case 7:
+                    this.mFlags = 1 | this.mFlags;
+                    this.mContentType = 4;
+                    break;
+                case 8:
+                    this.mContentType = 4;
+                    break;
+                case 9:
+                    this.mContentType = 4;
+                    break;
+                case 10:
+                    this.mContentType = 1;
+                    break;
+                default:
+                    Log.e("AudioAttributesCompat", "Invalid stream type " + i + " for AudioAttributesCompat");
+                    break;
+            }
+            this.mUsage = AudioAttributesImplBase.usageForStreamType(i);
+            return this;
+        }
+    }
+}

decompiled/sources/androidx/media/AudioAttributesImplBaseParcelizer.java

@@ -0,0 +1,25 @@
+package androidx.media;
+
+import androidx.annotation.RestrictTo;
+import androidx.versionedparcelable.VersionedParcel;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public class AudioAttributesImplBaseParcelizer {
+    public static AudioAttributesImplBase read(VersionedParcel versionedParcel) {
+        AudioAttributesImplBase audioAttributesImplBase = new AudioAttributesImplBase();
+        audioAttributesImplBase.mUsage = versionedParcel.readInt(audioAttributesImplBase.mUsage, 1);
+        audioAttributesImplBase.mContentType = versionedParcel.readInt(audioAttributesImplBase.mContentType, 2);
+        audioAttributesImplBase.mFlags = versionedParcel.readInt(audioAttributesImplBase.mFlags, 3);
+        audioAttributesImplBase.mLegacyStream = versionedParcel.readInt(audioAttributesImplBase.mLegacyStream, 4);
+        return audioAttributesImplBase;
+    }
+
+    public static void write(AudioAttributesImplBase audioAttributesImplBase, VersionedParcel versionedParcel) {
+        versionedParcel.setSerializationFlags(false, false);
+        versionedParcel.writeInt(audioAttributesImplBase.mUsage, 1);
+        versionedParcel.writeInt(audioAttributesImplBase.mContentType, 2);
+        versionedParcel.writeInt(audioAttributesImplBase.mFlags, 3);
+        versionedParcel.writeInt(audioAttributesImplBase.mLegacyStream, 4);
+    }
+}

decompiled/sources/androidx/media/AudioFocusRequestCompat.java

@@ -0,0 +1,188 @@
+package androidx.media;
+
+import android.media.AudioAttributes;
+import android.media.AudioFocusRequest;
+import android.media.AudioManager;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.core.util.ObjectsCompat;
+import androidx.media.AudioAttributesCompat;
+
+/* loaded from: classes.dex */
+public class AudioFocusRequestCompat {
+    static final AudioAttributesCompat FOCUS_DEFAULT_ATTR = new AudioAttributesCompat.Builder().setUsage(1).build();
+    private final AudioAttributesCompat mAudioAttributesCompat;
+    private final Handler mFocusChangeHandler;
+    private final int mFocusGain;
+    private final Object mFrameworkAudioFocusRequest;
+    private final AudioManager.OnAudioFocusChangeListener mOnAudioFocusChangeListener;
+    private final boolean mPauseOnDuck;
+
+    @NonNull
+    public AudioAttributesCompat getAudioAttributesCompat() {
+        return this.mAudioAttributesCompat;
+    }
+
+    @NonNull
+    public Handler getFocusChangeHandler() {
+        return this.mFocusChangeHandler;
+    }
+
+    public int getFocusGain() {
+        return this.mFocusGain;
+    }
+
+    @NonNull
+    public AudioManager.OnAudioFocusChangeListener getOnAudioFocusChangeListener() {
+        return this.mOnAudioFocusChangeListener;
+    }
+
+    public boolean willPauseWhenDucked() {
+        return this.mPauseOnDuck;
+    }
+
+    public AudioFocusRequestCompat(int i, AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener, Handler handler, AudioAttributesCompat audioAttributesCompat, boolean z) {
+        this.mFocusGain = i;
+        this.mFocusChangeHandler = handler;
+        this.mAudioAttributesCompat = audioAttributesCompat;
+        this.mPauseOnDuck = z;
+        this.mOnAudioFocusChangeListener = onAudioFocusChangeListener;
+        this.mFrameworkAudioFocusRequest = new AudioFocusRequest.Builder(i).setAudioAttributes(getAudioAttributes()).setWillPauseWhenDucked(z).setOnAudioFocusChangeListener(onAudioFocusChangeListener, handler).build();
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof AudioFocusRequestCompat)) {
+            return false;
+        }
+        AudioFocusRequestCompat audioFocusRequestCompat = (AudioFocusRequestCompat) obj;
+        return this.mFocusGain == audioFocusRequestCompat.mFocusGain && this.mPauseOnDuck == audioFocusRequestCompat.mPauseOnDuck && ObjectsCompat.equals(this.mOnAudioFocusChangeListener, audioFocusRequestCompat.mOnAudioFocusChangeListener) && ObjectsCompat.equals(this.mFocusChangeHandler, audioFocusRequestCompat.mFocusChangeHandler) && ObjectsCompat.equals(this.mAudioAttributesCompat, audioFocusRequestCompat.mAudioAttributesCompat);
+    }
+
+    public int hashCode() {
+        return ObjectsCompat.hash(Integer.valueOf(this.mFocusGain), this.mOnAudioFocusChangeListener, this.mFocusChangeHandler, this.mAudioAttributesCompat, Boolean.valueOf(this.mPauseOnDuck));
+    }
+
+    @RequiresApi(21)
+    public AudioAttributes getAudioAttributes() {
+        AudioAttributesCompat audioAttributesCompat = this.mAudioAttributesCompat;
+        if (audioAttributesCompat != null) {
+            return (AudioAttributes) audioAttributesCompat.unwrap();
+        }
+        return null;
+    }
+
+    @RequiresApi(26)
+    public AudioFocusRequest getAudioFocusRequest() {
+        return (AudioFocusRequest) this.mFrameworkAudioFocusRequest;
+    }
+
+    public static final class Builder {
+        private AudioAttributesCompat mAudioAttributesCompat;
+        private Handler mFocusChangeHandler;
+        private int mFocusGain;
+        private AudioManager.OnAudioFocusChangeListener mOnAudioFocusChangeListener;
+        private boolean mPauseOnDuck;
+
+        private static boolean isValidFocusGain(int i) {
+            return i == 1 || i == 2 || i == 3 || i == 4;
+        }
+
+        @NonNull
+        public Builder setWillPauseWhenDucked(boolean z) {
+            this.mPauseOnDuck = z;
+            return this;
+        }
+
+        public Builder(int i) {
+            this.mAudioAttributesCompat = AudioFocusRequestCompat.FOCUS_DEFAULT_ATTR;
+            setFocusGain(i);
+        }
+
+        public Builder(@NonNull AudioFocusRequestCompat audioFocusRequestCompat) {
+            this.mAudioAttributesCompat = AudioFocusRequestCompat.FOCUS_DEFAULT_ATTR;
+            if (audioFocusRequestCompat == null) {
+                throw new IllegalArgumentException("AudioFocusRequestCompat to copy must not be null");
+            }
+            this.mFocusGain = audioFocusRequestCompat.getFocusGain();
+            this.mOnAudioFocusChangeListener = audioFocusRequestCompat.getOnAudioFocusChangeListener();
+            this.mFocusChangeHandler = audioFocusRequestCompat.getFocusChangeHandler();
+            this.mAudioAttributesCompat = audioFocusRequestCompat.getAudioAttributesCompat();
+            this.mPauseOnDuck = audioFocusRequestCompat.willPauseWhenDucked();
+        }
+
+        @NonNull
+        public Builder setFocusGain(int i) {
+            if (isValidFocusGain(i)) {
+                this.mFocusGain = i;
+                return this;
+            }
+            throw new IllegalArgumentException("Illegal audio focus gain type " + i);
+        }
+
+        @NonNull
+        public Builder setOnAudioFocusChangeListener(@NonNull AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener) {
+            return setOnAudioFocusChangeListener(onAudioFocusChangeListener, new Handler(Looper.getMainLooper()));
+        }
+
+        @NonNull
+        public Builder setOnAudioFocusChangeListener(@NonNull AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener, @NonNull Handler handler) {
+            if (onAudioFocusChangeListener == null) {
+                throw new IllegalArgumentException("OnAudioFocusChangeListener must not be null");
+            }
+            if (handler == null) {
+                throw new IllegalArgumentException("Handler must not be null");
+            }
+            this.mOnAudioFocusChangeListener = onAudioFocusChangeListener;
+            this.mFocusChangeHandler = handler;
+            return this;
+        }
+
+        @NonNull
+        public Builder setAudioAttributes(@NonNull AudioAttributesCompat audioAttributesCompat) {
+            if (audioAttributesCompat == null) {
+                throw new NullPointerException("Illegal null AudioAttributes");
+            }
+            this.mAudioAttributesCompat = audioAttributesCompat;
+            return this;
+        }
+
+        public AudioFocusRequestCompat build() {
+            if (this.mOnAudioFocusChangeListener == null) {
+                throw new IllegalStateException("Can't build an AudioFocusRequestCompat instance without a listener");
+            }
+            return new AudioFocusRequestCompat(this.mFocusGain, this.mOnAudioFocusChangeListener, this.mFocusChangeHandler, this.mAudioAttributesCompat, this.mPauseOnDuck);
+        }
+    }
+
+    public static class OnAudioFocusChangeListenerHandlerCompat implements Handler.Callback, AudioManager.OnAudioFocusChangeListener {
+        private static final int FOCUS_CHANGE = 2782386;
+        private final Handler mHandler;
+        private final AudioManager.OnAudioFocusChangeListener mListener;
+
+        public OnAudioFocusChangeListenerHandlerCompat(@NonNull AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener, @NonNull Handler handler) {
+            this.mListener = onAudioFocusChangeListener;
+            this.mHandler = new Handler(handler.getLooper(), this);
+        }
+
+        @Override // android.media.AudioManager.OnAudioFocusChangeListener
+        public void onAudioFocusChange(int i) {
+            Handler handler = this.mHandler;
+            handler.sendMessage(Message.obtain(handler, FOCUS_CHANGE, i, 0));
+        }
+
+        @Override // android.os.Handler.Callback
+        public boolean handleMessage(Message message) {
+            if (message.what != FOCUS_CHANGE) {
+                return false;
+            }
+            this.mListener.onAudioFocusChange(message.arg1);
+            return true;
+        }
+    }
+}

decompiled/sources/androidx/media/AudioManagerCompat$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.media;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class AudioManagerCompat$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/media/AudioManagerCompat.java

@@ -0,0 +1,53 @@
+package androidx.media;
+
+import android.media.AudioManager;
+import android.os.Build;
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public final class AudioManagerCompat {
+    public static final int AUDIOFOCUS_GAIN = 1;
+    public static final int AUDIOFOCUS_GAIN_TRANSIENT = 2;
+    public static final int AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE = 4;
+    public static final int AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK = 3;
+    private static final String TAG = "AudioManCompat";
+
+    public static int requestAudioFocus(@NonNull AudioManager audioManager, @NonNull AudioFocusRequestCompat audioFocusRequestCompat) {
+        if (audioManager == null) {
+            throw new IllegalArgumentException("AudioManager must not be null");
+        }
+        if (audioFocusRequestCompat == null) {
+            throw new IllegalArgumentException("AudioFocusRequestCompat must not be null");
+        }
+        return audioManager.requestAudioFocus(audioFocusRequestCompat.getAudioFocusRequest());
+    }
+
+    public static int abandonAudioFocusRequest(@NonNull AudioManager audioManager, @NonNull AudioFocusRequestCompat audioFocusRequestCompat) {
+        if (audioManager == null) {
+            throw new IllegalArgumentException("AudioManager must not be null");
+        }
+        if (audioFocusRequestCompat == null) {
+            throw new IllegalArgumentException("AudioFocusRequestCompat must not be null");
+        }
+        return audioManager.abandonAudioFocusRequest(audioFocusRequestCompat.getAudioFocusRequest());
+    }
+
+    @IntRange(from = 0)
+    public static int getStreamMaxVolume(@NonNull AudioManager audioManager, int i) {
+        return audioManager.getStreamMaxVolume(i);
+    }
+
+    @IntRange(from = 0)
+    public static int getStreamMinVolume(@NonNull AudioManager audioManager, int i) {
+        int streamMinVolume;
+        if (Build.VERSION.SDK_INT < 28) {
+            return 0;
+        }
+        streamMinVolume = audioManager.getStreamMinVolume(i);
+        return streamMinVolume;
+    }
+
+    private AudioManagerCompat() {
+    }
+}

decompiled/sources/androidx/media/MediaBrowserCompatUtils.java

@@ -0,0 +1,44 @@
+package androidx.media;
+
+import android.os.Bundle;
+import android.support.v4.media.MediaBrowserCompat;
+import androidx.annotation.RestrictTo;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public class MediaBrowserCompatUtils {
+    public static boolean areSameOptions(Bundle bundle, Bundle bundle2) {
+        if (bundle == bundle2) {
+            return true;
+        }
+        return bundle == null ? bundle2.getInt(MediaBrowserCompat.EXTRA_PAGE, -1) == -1 && bundle2.getInt(MediaBrowserCompat.EXTRA_PAGE_SIZE, -1) == -1 : bundle2 == null ? bundle.getInt(MediaBrowserCompat.EXTRA_PAGE, -1) == -1 && bundle.getInt(MediaBrowserCompat.EXTRA_PAGE_SIZE, -1) == -1 : bundle.getInt(MediaBrowserCompat.EXTRA_PAGE, -1) == bundle2.getInt(MediaBrowserCompat.EXTRA_PAGE, -1) && bundle.getInt(MediaBrowserCompat.EXTRA_PAGE_SIZE, -1) == bundle2.getInt(MediaBrowserCompat.EXTRA_PAGE_SIZE, -1);
+    }
+
+    public static boolean hasDuplicatedItems(Bundle bundle, Bundle bundle2) {
+        int i;
+        int i2;
+        int i3;
+        int i4 = bundle == null ? -1 : bundle.getInt(MediaBrowserCompat.EXTRA_PAGE, -1);
+        int i5 = bundle2 == null ? -1 : bundle2.getInt(MediaBrowserCompat.EXTRA_PAGE, -1);
+        int i6 = bundle == null ? -1 : bundle.getInt(MediaBrowserCompat.EXTRA_PAGE_SIZE, -1);
+        int i7 = bundle2 == null ? -1 : bundle2.getInt(MediaBrowserCompat.EXTRA_PAGE_SIZE, -1);
+        int i8 = Integer.MAX_VALUE;
+        if (i4 == -1 || i6 == -1) {
+            i = Integer.MAX_VALUE;
+            i2 = 0;
+        } else {
+            i2 = i4 * i6;
+            i = (i6 + i2) - 1;
+        }
+        if (i5 == -1 || i7 == -1) {
+            i3 = 0;
+        } else {
+            i3 = i5 * i7;
+            i8 = (i7 + i3) - 1;
+        }
+        return i >= i3 && i8 >= i2;
+    }
+
+    private MediaBrowserCompatUtils() {
+    }
+}

decompiled/sources/androidx/media/MediaBrowserProtocol.java

@@ -0,0 +1,48 @@
+package androidx.media;
+
+import androidx.annotation.RestrictTo;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public class MediaBrowserProtocol {
+    public static final int CLIENT_MSG_ADD_SUBSCRIPTION = 3;
+    public static final int CLIENT_MSG_CONNECT = 1;
+    public static final int CLIENT_MSG_DISCONNECT = 2;
+    public static final int CLIENT_MSG_GET_MEDIA_ITEM = 5;
+    public static final int CLIENT_MSG_REGISTER_CALLBACK_MESSENGER = 6;
+    public static final int CLIENT_MSG_REMOVE_SUBSCRIPTION = 4;
+    public static final int CLIENT_MSG_SEARCH = 8;
+    public static final int CLIENT_MSG_SEND_CUSTOM_ACTION = 9;
+    public static final int CLIENT_MSG_UNREGISTER_CALLBACK_MESSENGER = 7;
+    public static final int CLIENT_VERSION_1 = 1;
+    public static final int CLIENT_VERSION_CURRENT = 1;
+    public static final String DATA_CALLBACK_TOKEN = "data_callback_token";
+    public static final String DATA_CALLING_PID = "data_calling_pid";
+    public static final String DATA_CALLING_UID = "data_calling_uid";
+    public static final String DATA_CUSTOM_ACTION = "data_custom_action";
+    public static final String DATA_CUSTOM_ACTION_EXTRAS = "data_custom_action_extras";
+    public static final String DATA_MEDIA_ITEM_ID = "data_media_item_id";
+    public static final String DATA_MEDIA_ITEM_LIST = "data_media_item_list";
+    public static final String DATA_MEDIA_SESSION_TOKEN = "data_media_session_token";
+    public static final String DATA_NOTIFY_CHILDREN_CHANGED_OPTIONS = "data_notify_children_changed_options";
+    public static final String DATA_OPTIONS = "data_options";
+    public static final String DATA_PACKAGE_NAME = "data_package_name";
+    public static final String DATA_RESULT_RECEIVER = "data_result_receiver";
+    public static final String DATA_ROOT_HINTS = "data_root_hints";
+    public static final String DATA_SEARCH_EXTRAS = "data_search_extras";
+    public static final String DATA_SEARCH_QUERY = "data_search_query";
+    public static final String EXTRA_CALLING_PID = "extra_calling_pid";
+    public static final String EXTRA_CLIENT_VERSION = "extra_client_version";
+    public static final String EXTRA_MESSENGER_BINDER = "extra_messenger";
+    public static final String EXTRA_SERVICE_VERSION = "extra_service_version";
+    public static final String EXTRA_SESSION_BINDER = "extra_session_binder";
+    public static final int SERVICE_MSG_ON_CONNECT = 1;
+    public static final int SERVICE_MSG_ON_CONNECT_FAILED = 2;
+    public static final int SERVICE_MSG_ON_LOAD_CHILDREN = 3;
+    public static final int SERVICE_VERSION_1 = 1;
+    public static final int SERVICE_VERSION_2 = 2;
+    public static final int SERVICE_VERSION_CURRENT = 2;
+
+    private MediaBrowserProtocol() {
+    }
+}

decompiled/sources/androidx/media/MediaBrowserServiceCompat$MediaBrowserServiceImplApi28$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.media;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class MediaBrowserServiceCompat$MediaBrowserServiceImplApi28$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/media/MediaSessionManager.java

@@ -0,0 +1,139 @@
+package androidx.media;
+
+import android.content.Context;
+import android.media.session.MediaSessionManager;
+import android.os.Build;
+import android.text.TextUtils;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.media.MediaSessionManagerImplApi28;
+import androidx.media.MediaSessionManagerImplBase;
+
+/* loaded from: classes.dex */
+public final class MediaSessionManager {
+    private static volatile MediaSessionManager sSessionManager;
+    MediaSessionManagerImpl mImpl;
+    static final String TAG = "MediaSessionManager";
+    static final boolean DEBUG = Log.isLoggable(TAG, 3);
+    private static final Object sLock = new Object();
+
+    public interface MediaSessionManagerImpl {
+        Context getContext();
+
+        boolean isTrustedForMediaControl(RemoteUserInfoImpl remoteUserInfoImpl);
+    }
+
+    public interface RemoteUserInfoImpl {
+        String getPackageName();
+
+        int getPid();
+
+        int getUid();
+    }
+
+    @NonNull
+    public static MediaSessionManager getSessionManager(@NonNull Context context) {
+        MediaSessionManager mediaSessionManager;
+        if (context == null) {
+            throw new IllegalArgumentException("context cannot be null");
+        }
+        synchronized (sLock) {
+            try {
+                if (sSessionManager == null) {
+                    sSessionManager = new MediaSessionManager(context.getApplicationContext());
+                }
+                mediaSessionManager = sSessionManager;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return mediaSessionManager;
+    }
+
+    private MediaSessionManager(Context context) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            this.mImpl = new MediaSessionManagerImplApi28(context);
+        } else {
+            this.mImpl = new MediaSessionManagerImplApi21(context);
+        }
+    }
+
+    public boolean isTrustedForMediaControl(@NonNull RemoteUserInfo remoteUserInfo) {
+        if (remoteUserInfo == null) {
+            throw new IllegalArgumentException("userInfo should not be null");
+        }
+        return this.mImpl.isTrustedForMediaControl(remoteUserInfo.mImpl);
+    }
+
+    public Context getContext() {
+        return this.mImpl.getContext();
+    }
+
+    public static final class RemoteUserInfo {
+        public static final String LEGACY_CONTROLLER = "android.media.session.MediaController";
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+        public static final int UNKNOWN_PID = -1;
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+        public static final int UNKNOWN_UID = -1;
+        RemoteUserInfoImpl mImpl;
+
+        public RemoteUserInfo(@NonNull String str, int i, int i2) {
+            if (str == null) {
+                throw new NullPointerException("package shouldn't be null");
+            }
+            if (TextUtils.isEmpty(str)) {
+                throw new IllegalArgumentException("packageName should be nonempty");
+            }
+            if (Build.VERSION.SDK_INT >= 28) {
+                this.mImpl = new MediaSessionManagerImplApi28.RemoteUserInfoImplApi28(str, i, i2);
+            } else {
+                this.mImpl = new MediaSessionManagerImplBase.RemoteUserInfoImplBase(str, i, i2);
+            }
+        }
+
+        @RequiresApi(28)
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public RemoteUserInfo(MediaSessionManager.RemoteUserInfo remoteUserInfo) {
+            String packageName = MediaSessionManagerImplApi28.RemoteUserInfoImplApi28.getPackageName(remoteUserInfo);
+            if (packageName == null) {
+                throw new NullPointerException("package shouldn't be null");
+            }
+            if (TextUtils.isEmpty(packageName)) {
+                throw new IllegalArgumentException("packageName should be nonempty");
+            }
+            this.mImpl = new MediaSessionManagerImplApi28.RemoteUserInfoImplApi28(remoteUserInfo);
+        }
+
+        @NonNull
+        public String getPackageName() {
+            return this.mImpl.getPackageName();
+        }
+
+        public int getPid() {
+            return this.mImpl.getPid();
+        }
+
+        public int getUid() {
+            return this.mImpl.getUid();
+        }
+
+        public boolean equals(@Nullable Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj instanceof RemoteUserInfo) {
+                return this.mImpl.equals(((RemoteUserInfo) obj).mImpl);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return this.mImpl.hashCode();
+        }
+    }
+}

decompiled/sources/androidx/media/MediaSessionManagerImplApi21.java

@@ -0,0 +1,24 @@
+package androidx.media;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.media.MediaSessionManager;
+
+@RequiresApi(21)
+/* loaded from: classes.dex */
+class MediaSessionManagerImplApi21 extends MediaSessionManagerImplBase {
+    public MediaSessionManagerImplApi21(Context context) {
+        super(context);
+        this.mContext = context;
+    }
+
+    @Override // androidx.media.MediaSessionManagerImplBase, androidx.media.MediaSessionManager.MediaSessionManagerImpl
+    public boolean isTrustedForMediaControl(@NonNull MediaSessionManager.RemoteUserInfoImpl remoteUserInfoImpl) {
+        return hasMediaControlPermission(remoteUserInfoImpl) || super.isTrustedForMediaControl(remoteUserInfoImpl);
+    }
+
+    private boolean hasMediaControlPermission(@NonNull MediaSessionManager.RemoteUserInfoImpl remoteUserInfoImpl) {
+        return getContext().checkPermission("android.permission.MEDIA_CONTENT_CONTROL", remoteUserInfoImpl.getPid(), remoteUserInfoImpl.getUid()) == 0;
+    }
+}

decompiled/sources/androidx/media/MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.media;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/media/MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.media;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/media/MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.media;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/media/MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,10 @@
+package androidx.media;
+
+import android.media.session.MediaSessionManager;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline3 {
+    public static /* synthetic */ MediaSessionManager.RemoteUserInfo m(String str, int i, int i2) {
+        return new MediaSessionManager.RemoteUserInfo(str, i, i2);
+    }
+}

decompiled/sources/androidx/media/MediaSessionManagerImplApi28.java

@@ -0,0 +1,57 @@
+package androidx.media;
+
+import android.content.Context;
+import android.media.session.MediaSessionManager;
+import androidx.annotation.RequiresApi;
+import androidx.media.MediaSessionManager;
+import androidx.media.MediaSessionManagerImplBase;
+
+@RequiresApi(28)
+/* loaded from: classes.dex */
+class MediaSessionManagerImplApi28 extends MediaSessionManagerImplApi21 {
+    android.media.session.MediaSessionManager mObject;
+
+    public MediaSessionManagerImplApi28(Context context) {
+        super(context);
+        this.mObject = (android.media.session.MediaSessionManager) context.getSystemService("media_session");
+    }
+
+    @Override // androidx.media.MediaSessionManagerImplApi21, androidx.media.MediaSessionManagerImplBase, androidx.media.MediaSessionManager.MediaSessionManagerImpl
+    public boolean isTrustedForMediaControl(MediaSessionManager.RemoteUserInfoImpl remoteUserInfoImpl) {
+        return super.isTrustedForMediaControl(remoteUserInfoImpl);
+    }
+
+    @RequiresApi(28)
+    public static final class RemoteUserInfoImplApi28 extends MediaSessionManagerImplBase.RemoteUserInfoImplBase {
+        final MediaSessionManager.RemoteUserInfo mObject;
+
+        public RemoteUserInfoImplApi28(String str, int i, int i2) {
+            super(str, i, i2);
+            this.mObject = MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline3.m(str, i, i2);
+        }
+
+        /* JADX WARN: Illegal instructions before constructor call */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public RemoteUserInfoImplApi28(android.media.session.MediaSessionManager.RemoteUserInfo r4) {
+            /*
+                r3 = this;
+                java.lang.String r0 = androidx.media.MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline0.m(r4)
+                int r1 = androidx.media.MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline1.m(r4)
+                int r2 = androidx.media.MediaSessionManagerImplApi28$RemoteUserInfoImplApi28$$ExternalSyntheticApiModelOutline2.m(r4)
+                r3.<init>(r0, r1, r2)
+                r3.mObject = r4
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: androidx.media.MediaSessionManagerImplApi28.RemoteUserInfoImplApi28.<init>(android.media.session.MediaSessionManager$RemoteUserInfo):void");
+        }
+
+        public static String getPackageName(MediaSessionManager.RemoteUserInfo remoteUserInfo) {
+            String packageName;
+            packageName = remoteUserInfo.getPackageName();
+            return packageName;
+        }
+    }
+}

decompiled/sources/androidx/media/MediaSessionManagerImplBase.java

@@ -0,0 +1,110 @@
+package androidx.media;
+
+import android.content.ComponentName;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.provider.Settings;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.core.util.ObjectsCompat;
+import androidx.media.MediaSessionManager;
+import com.facebook.internal.security.CertificateUtil;
+
+/* loaded from: classes.dex */
+class MediaSessionManagerImplBase implements MediaSessionManager.MediaSessionManagerImpl {
+    private static final boolean DEBUG = MediaSessionManager.DEBUG;
+    private static final String ENABLED_NOTIFICATION_LISTENERS = "enabled_notification_listeners";
+    private static final String PERMISSION_MEDIA_CONTENT_CONTROL = "android.permission.MEDIA_CONTENT_CONTROL";
+    private static final String PERMISSION_STATUS_BAR_SERVICE = "android.permission.STATUS_BAR_SERVICE";
+    private static final String TAG = "MediaSessionManager";
+    ContentResolver mContentResolver;
+    Context mContext;
+
+    @Override // androidx.media.MediaSessionManager.MediaSessionManagerImpl
+    public Context getContext() {
+        return this.mContext;
+    }
+
+    public MediaSessionManagerImplBase(Context context) {
+        this.mContext = context;
+        this.mContentResolver = context.getContentResolver();
+    }
+
+    @Override // androidx.media.MediaSessionManager.MediaSessionManagerImpl
+    public boolean isTrustedForMediaControl(@NonNull MediaSessionManager.RemoteUserInfoImpl remoteUserInfoImpl) {
+        try {
+            if (this.mContext.getPackageManager().getApplicationInfo(remoteUserInfoImpl.getPackageName(), 0) == null) {
+                return false;
+            }
+            return isPermissionGranted(remoteUserInfoImpl, PERMISSION_STATUS_BAR_SERVICE) || isPermissionGranted(remoteUserInfoImpl, PERMISSION_MEDIA_CONTENT_CONTROL) || remoteUserInfoImpl.getUid() == 1000 || isEnabledNotificationListener(remoteUserInfoImpl);
+        } catch (PackageManager.NameNotFoundException unused) {
+            if (DEBUG) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Package ");
+                sb.append(remoteUserInfoImpl.getPackageName());
+                sb.append(" doesn't exist");
+            }
+            return false;
+        }
+    }
+
+    private boolean isPermissionGranted(MediaSessionManager.RemoteUserInfoImpl remoteUserInfoImpl, String str) {
+        return remoteUserInfoImpl.getPid() < 0 ? this.mContext.getPackageManager().checkPermission(str, remoteUserInfoImpl.getPackageName()) == 0 : this.mContext.checkPermission(str, remoteUserInfoImpl.getPid(), remoteUserInfoImpl.getUid()) == 0;
+    }
+
+    public boolean isEnabledNotificationListener(@NonNull MediaSessionManager.RemoteUserInfoImpl remoteUserInfoImpl) {
+        String string = Settings.Secure.getString(this.mContentResolver, ENABLED_NOTIFICATION_LISTENERS);
+        if (string != null) {
+            for (String str : string.split(CertificateUtil.DELIMITER)) {
+                ComponentName unflattenFromString = ComponentName.unflattenFromString(str);
+                if (unflattenFromString != null && unflattenFromString.getPackageName().equals(remoteUserInfoImpl.getPackageName())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public static class RemoteUserInfoImplBase implements MediaSessionManager.RemoteUserInfoImpl {
+        private String mPackageName;
+        private int mPid;
+        private int mUid;
+
+        @Override // androidx.media.MediaSessionManager.RemoteUserInfoImpl
+        public String getPackageName() {
+            return this.mPackageName;
+        }
+
+        @Override // androidx.media.MediaSessionManager.RemoteUserInfoImpl
+        public int getPid() {
+            return this.mPid;
+        }
+
+        @Override // androidx.media.MediaSessionManager.RemoteUserInfoImpl
+        public int getUid() {
+            return this.mUid;
+        }
+
+        public RemoteUserInfoImplBase(String str, int i, int i2) {
+            this.mPackageName = str;
+            this.mPid = i;
+            this.mUid = i2;
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof RemoteUserInfoImplBase)) {
+                return false;
+            }
+            RemoteUserInfoImplBase remoteUserInfoImplBase = (RemoteUserInfoImplBase) obj;
+            return (this.mPid < 0 || remoteUserInfoImplBase.mPid < 0) ? TextUtils.equals(this.mPackageName, remoteUserInfoImplBase.mPackageName) && this.mUid == remoteUserInfoImplBase.mUid : TextUtils.equals(this.mPackageName, remoteUserInfoImplBase.mPackageName) && this.mPid == remoteUserInfoImplBase.mPid && this.mUid == remoteUserInfoImplBase.mUid;
+        }
+
+        public int hashCode() {
+            return ObjectsCompat.hash(this.mPackageName, Integer.valueOf(this.mUid));
+        }
+    }
+}

decompiled/sources/androidx/media/R.java

@@ -0,0 +1,267 @@
+package androidx.media;
+
+/* loaded from: classes.dex */
+public final class R {
+
+    public static final class attr {
+        public static int alpha = 0x7f040055;
+        public static int font = 0x7f0400d8;
+        public static int fontProviderAuthority = 0x7f0400da;
+        public static int fontProviderCerts = 0x7f0400db;
+        public static int fontProviderFetchStrategy = 0x7f0400dd;
+        public static int fontProviderFetchTimeout = 0x7f0400de;
+        public static int fontProviderPackage = 0x7f0400df;
+        public static int fontProviderQuery = 0x7f0400e0;
+        public static int fontStyle = 0x7f0400e2;
+        public static int fontVariationSettings = 0x7f0400e3;
+        public static int fontWeight = 0x7f0400e4;
+        public static int ttcIndex = 0x7f04019c;
+
+        private attr() {
+        }
+    }
+
+    public static final class color {
+        public static int androidx_core_ripple_material_light = 0x7f060025;
+        public static int androidx_core_secondary_text_default_material_light = 0x7f060026;
+        public static int notification_action_color_filter = 0x7f0600e7;
+        public static int notification_icon_bg_color = 0x7f0600e8;
+        public static int notification_material_background_media_default_color = 0x7f0600e9;
+        public static int primary_text_default_material_dark = 0x7f0600ee;
+        public static int secondary_text_default_material_dark = 0x7f0600f4;
+
+        private color() {
+        }
+    }
+
+    public static final class dimen {
+        public static int compat_button_inset_horizontal_material = 0x7f070095;
+        public static int compat_button_inset_vertical_material = 0x7f070096;
+        public static int compat_button_padding_horizontal_material = 0x7f070097;
+        public static int compat_button_padding_vertical_material = 0x7f070098;
+        public static int compat_control_corner_material = 0x7f070099;
+        public static int compat_notification_large_icon_max_height = 0x7f07009a;
+        public static int compat_notification_large_icon_max_width = 0x7f07009b;
+        public static int notification_action_icon_size = 0x7f070105;
+        public static int notification_action_text_size = 0x7f070106;
+        public static int notification_big_circle_margin = 0x7f070107;
+        public static int notification_content_margin_start = 0x7f070108;
+        public static int notification_large_icon_height = 0x7f070109;
+        public static int notification_large_icon_width = 0x7f07010a;
+        public static int notification_main_column_padding_top = 0x7f07010b;
+        public static int notification_media_narrow_margin = 0x7f07010c;
+        public static int notification_right_icon_size = 0x7f07010d;
+        public static int notification_right_side_padding_top = 0x7f07010e;
+        public static int notification_small_icon_background_padding = 0x7f07010f;
+        public static int notification_small_icon_size_as_large = 0x7f070110;
+        public static int notification_subtext_size = 0x7f070111;
+        public static int notification_top_pad = 0x7f070112;
+        public static int notification_top_pad_large_text = 0x7f070113;
+
+        private dimen() {
+        }
+    }
+
+    public static final class drawable {
+        public static int notification_action_background = 0x7f080241;
+        public static int notification_bg = 0x7f080242;
+        public static int notification_bg_low = 0x7f080243;
+        public static int notification_bg_low_normal = 0x7f080244;
+        public static int notification_bg_low_pressed = 0x7f080245;
+        public static int notification_bg_normal = 0x7f080246;
+        public static int notification_bg_normal_pressed = 0x7f080247;
+        public static int notification_icon_background = 0x7f080248;
+        public static int notification_template_icon_bg = 0x7f08024a;
+        public static int notification_template_icon_low_bg = 0x7f08024b;
+        public static int notification_tile_bg = 0x7f08024c;
+        public static int notify_panel_notification_icon_bg = 0x7f08024d;
+
+        private drawable() {
+        }
+    }
+
+    public static final class id {
+        public static int accessibility_action_clickable_span = 0x7f0a0009;
+        public static int accessibility_custom_action_0 = 0x7f0a000a;
+        public static int accessibility_custom_action_1 = 0x7f0a000b;
+        public static int accessibility_custom_action_10 = 0x7f0a000c;
+        public static int accessibility_custom_action_11 = 0x7f0a000d;
+        public static int accessibility_custom_action_12 = 0x7f0a000e;
+        public static int accessibility_custom_action_13 = 0x7f0a000f;
+        public static int accessibility_custom_action_14 = 0x7f0a0010;
+        public static int accessibility_custom_action_15 = 0x7f0a0011;
+        public static int accessibility_custom_action_16 = 0x7f0a0012;
+        public static int accessibility_custom_action_17 = 0x7f0a0013;
+        public static int accessibility_custom_action_18 = 0x7f0a0014;
+        public static int accessibility_custom_action_19 = 0x7f0a0015;
+        public static int accessibility_custom_action_2 = 0x7f0a0016;
+        public static int accessibility_custom_action_20 = 0x7f0a0017;
+        public static int accessibility_custom_action_21 = 0x7f0a0018;
+        public static int accessibility_custom_action_22 = 0x7f0a0019;
+        public static int accessibility_custom_action_23 = 0x7f0a001a;
+        public static int accessibility_custom_action_24 = 0x7f0a001b;
+        public static int accessibility_custom_action_25 = 0x7f0a001c;
+        public static int accessibility_custom_action_26 = 0x7f0a001d;
+        public static int accessibility_custom_action_27 = 0x7f0a001e;
+        public static int accessibility_custom_action_28 = 0x7f0a001f;
+        public static int accessibility_custom_action_29 = 0x7f0a0020;
+        public static int accessibility_custom_action_3 = 0x7f0a0021;
+        public static int accessibility_custom_action_30 = 0x7f0a0022;
+        public static int accessibility_custom_action_31 = 0x7f0a0023;
+        public static int accessibility_custom_action_4 = 0x7f0a0024;
+        public static int accessibility_custom_action_5 = 0x7f0a0025;
+        public static int accessibility_custom_action_6 = 0x7f0a0026;
+        public static int accessibility_custom_action_7 = 0x7f0a0027;
+        public static int accessibility_custom_action_8 = 0x7f0a0028;
+        public static int accessibility_custom_action_9 = 0x7f0a0029;
+        public static int action0 = 0x7f0a002a;
+        public static int action_container = 0x7f0a0032;
+        public static int action_divider = 0x7f0a0034;
+        public static int action_image = 0x7f0a0035;
+        public static int action_text = 0x7f0a003c;
+        public static int actions = 0x7f0a003d;
+        public static int async = 0x7f0a0088;
+        public static int blocking = 0x7f0a0091;
+        public static int cancel_action = 0x7f0a009f;
+        public static int chronometer = 0x7f0a00a6;
+        public static int dialog_button = 0x7f0a00c1;
+        public static int end_padder = 0x7f0a00c9;
+        public static int forever = 0x7f0a0107;
+        public static int icon = 0x7f0a014a;
+        public static int icon_group = 0x7f0a014b;
+        public static int info = 0x7f0a0151;
+        public static int italic = 0x7f0a0156;
+        public static int line1 = 0x7f0a015d;
+        public static int line3 = 0x7f0a015e;
+        public static int media_actions = 0x7f0a021d;
+        public static int media_controller_compat_view_tag = 0x7f0a021e;
+        public static int normal = 0x7f0a022f;
+        public static int notification_background = 0x7f0a0230;
+        public static int notification_main_column = 0x7f0a0231;
+        public static int notification_main_column_container = 0x7f0a0232;
+        public static int right_icon = 0x7f0a0248;
+        public static int right_side = 0x7f0a0249;
+        public static int status_bar_latest_event_content = 0x7f0a0269;
+        public static int tag_accessibility_actions = 0x7f0a0270;
+        public static int tag_accessibility_clickable_spans = 0x7f0a0271;
+        public static int tag_accessibility_heading = 0x7f0a0272;
+        public static int tag_accessibility_pane_title = 0x7f0a0273;
+        public static int tag_screen_reader_focusable = 0x7f0a0277;
+        public static int tag_transition_group = 0x7f0a0279;
+        public static int tag_unhandled_key_event_manager = 0x7f0a027a;
+        public static int tag_unhandled_key_listeners = 0x7f0a027b;
+        public static int text = 0x7f0a027d;
+        public static int text2 = 0x7f0a027e;
+        public static int time = 0x7f0a0283;
+        public static int title = 0x7f0a0284;
+
+        private id() {
+        }
+    }
+
+    public static final class integer {
+        public static int cancel_button_image_alpha = 0x7f0b0005;
+        public static int status_bar_notification_info_maxnum = 0x7f0b0014;
+
+        private integer() {
+        }
+    }
+
+    public static final class layout {
+        public static int custom_dialog = 0x7f0d0033;
+        public static int notification_action = 0x7f0d009f;
+        public static int notification_action_tombstone = 0x7f0d00a0;
+        public static int notification_media_action = 0x7f0d00a1;
+        public static int notification_media_cancel_action = 0x7f0d00a2;
+        public static int notification_template_big_media = 0x7f0d00a3;
+        public static int notification_template_big_media_custom = 0x7f0d00a4;
+        public static int notification_template_big_media_narrow = 0x7f0d00a5;
+        public static int notification_template_big_media_narrow_custom = 0x7f0d00a6;
+        public static int notification_template_custom_big = 0x7f0d00a7;
+        public static int notification_template_icon_group = 0x7f0d00a8;
+        public static int notification_template_lines_media = 0x7f0d00a9;
+        public static int notification_template_media = 0x7f0d00aa;
+        public static int notification_template_media_custom = 0x7f0d00ab;
+        public static int notification_template_part_chronometer = 0x7f0d00ac;
+        public static int notification_template_part_time = 0x7f0d00ad;
+
+        private layout() {
+        }
+    }
+
+    public static final class string {
+        public static int status_bar_notification_info_overflow = 0x7f120187;
+
+        private string() {
+        }
+    }
+
+    public static final class style {
+        public static int TextAppearance_Compat_Notification = 0x7f130147;
+        public static int TextAppearance_Compat_Notification_Info = 0x7f130148;
+        public static int TextAppearance_Compat_Notification_Info_Media = 0x7f130149;
+        public static int TextAppearance_Compat_Notification_Line2 = 0x7f13014a;
+        public static int TextAppearance_Compat_Notification_Line2_Media = 0x7f13014b;
+        public static int TextAppearance_Compat_Notification_Media = 0x7f13014c;
+        public static int TextAppearance_Compat_Notification_Time = 0x7f13014d;
+        public static int TextAppearance_Compat_Notification_Time_Media = 0x7f13014e;
+        public static int TextAppearance_Compat_Notification_Title = 0x7f13014f;
+        public static int TextAppearance_Compat_Notification_Title_Media = 0x7f130150;
+        public static int Widget_Compat_NotificationActionContainer = 0x7f1301c1;
+        public static int Widget_Compat_NotificationActionText = 0x7f1301c2;
+
+        private style() {
+        }
+    }
+
+    public static final class styleable {
+        public static int ColorStateListItem_alpha = 0x00000003;
+        public static int ColorStateListItem_android_alpha = 0x00000001;
+        public static int ColorStateListItem_android_color = 0x00000000;
+        public static int ColorStateListItem_android_lStar = 0x00000002;
+        public static int ColorStateListItem_lStar = 0x00000004;
+        public static int FontFamilyFont_android_font = 0x00000000;
+        public static int FontFamilyFont_android_fontStyle = 0x00000002;
+        public static int FontFamilyFont_android_fontVariationSettings = 0x00000004;
+        public static int FontFamilyFont_android_fontWeight = 0x00000001;
+        public static int FontFamilyFont_android_ttcIndex = 0x00000003;
+        public static int FontFamilyFont_font = 0x00000005;
+        public static int FontFamilyFont_fontStyle = 0x00000006;
+        public static int FontFamilyFont_fontVariationSettings = 0x00000007;
+        public static int FontFamilyFont_fontWeight = 0x00000008;
+        public static int FontFamilyFont_ttcIndex = 0x00000009;
+        public static int FontFamily_fontProviderAuthority = 0x00000000;
+        public static int FontFamily_fontProviderCerts = 0x00000001;
+        public static int FontFamily_fontProviderFallbackQuery = 0x00000002;
+        public static int FontFamily_fontProviderFetchStrategy = 0x00000003;
+        public static int FontFamily_fontProviderFetchTimeout = 0x00000004;
+        public static int FontFamily_fontProviderPackage = 0x00000005;
+        public static int FontFamily_fontProviderQuery = 0x00000006;
+        public static int FontFamily_fontProviderSystemFontFamily = 0x00000007;
+        public static int GradientColorItem_android_color = 0x00000000;
+        public static int GradientColorItem_android_offset = 0x00000001;
+        public static int GradientColor_android_centerColor = 0x00000007;
+        public static int GradientColor_android_centerX = 0x00000003;
+        public static int GradientColor_android_centerY = 0x00000004;
+        public static int GradientColor_android_endColor = 0x00000001;
+        public static int GradientColor_android_endX = 0x0000000a;
+        public static int GradientColor_android_endY = 0x0000000b;
+        public static int GradientColor_android_gradientRadius = 0x00000005;
+        public static int GradientColor_android_startColor = 0x00000000;
+        public static int GradientColor_android_startX = 0x00000008;
+        public static int GradientColor_android_startY = 0x00000009;
+        public static int GradientColor_android_tileMode = 0x00000006;
+        public static int GradientColor_android_type = 0x00000002;
+        public static int[] ColorStateListItem = {android.R.attr.color, android.R.attr.alpha, android.R.attr.lStar, com.ea.games.r3_row.R.attr.alpha, com.ea.games.r3_row.R.attr.lStar};
+        public static int[] FontFamily = {com.ea.games.r3_row.R.attr.fontProviderAuthority, com.ea.games.r3_row.R.attr.fontProviderCerts, com.ea.games.r3_row.R.attr.fontProviderFallbackQuery, com.ea.games.r3_row.R.attr.fontProviderFetchStrategy, com.ea.games.r3_row.R.attr.fontProviderFetchTimeout, com.ea.games.r3_row.R.attr.fontProviderPackage, com.ea.games.r3_row.R.attr.fontProviderQuery, com.ea.games.r3_row.R.attr.fontProviderSystemFontFamily};
+        public static int[] FontFamilyFont = {android.R.attr.font, android.R.attr.fontWeight, android.R.attr.fontStyle, android.R.attr.ttcIndex, android.R.attr.fontVariationSettings, com.ea.games.r3_row.R.attr.font, com.ea.games.r3_row.R.attr.fontStyle, com.ea.games.r3_row.R.attr.fontVariationSettings, com.ea.games.r3_row.R.attr.fontWeight, com.ea.games.r3_row.R.attr.ttcIndex};
+        public static int[] GradientColor = {android.R.attr.startColor, android.R.attr.endColor, android.R.attr.type, android.R.attr.centerX, android.R.attr.centerY, android.R.attr.gradientRadius, android.R.attr.tileMode, android.R.attr.centerColor, android.R.attr.startX, android.R.attr.startY, android.R.attr.endX, android.R.attr.endY};
+        public static int[] GradientColorItem = {android.R.attr.color, android.R.attr.offset};
+
+        private styleable() {
+        }
+    }
+
+    private R() {
+    }
+}

decompiled/sources/androidx/media/VolumeProviderCompat.java

@@ -0,0 +1,110 @@
+package androidx.media;
+
+import android.media.VolumeProvider;
+import android.os.Build;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes.dex */
+public abstract class VolumeProviderCompat {
+    public static final int VOLUME_CONTROL_ABSOLUTE = 2;
+    public static final int VOLUME_CONTROL_FIXED = 0;
+    public static final int VOLUME_CONTROL_RELATIVE = 1;
+    private Callback mCallback;
+    private final String mControlId;
+    private final int mControlType;
+    private int mCurrentVolume;
+    private final int mMaxVolume;
+    private VolumeProvider mVolumeProviderFwk;
+
+    public static abstract class Callback {
+        public abstract void onVolumeChanged(VolumeProviderCompat volumeProviderCompat);
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface ControlType {
+    }
+
+    public final int getCurrentVolume() {
+        return this.mCurrentVolume;
+    }
+
+    public final int getMaxVolume() {
+        return this.mMaxVolume;
+    }
+
+    public final int getVolumeControl() {
+        return this.mControlType;
+    }
+
+    @Nullable
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public final String getVolumeControlId() {
+        return this.mControlId;
+    }
+
+    public void onAdjustVolume(int i) {
+    }
+
+    public void onSetVolumeTo(int i) {
+    }
+
+    public void setCallback(Callback callback) {
+        this.mCallback = callback;
+    }
+
+    public VolumeProviderCompat(int i, int i2, int i3) {
+        this(i, i2, i3, null);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public VolumeProviderCompat(int i, int i2, int i3, @Nullable String str) {
+        this.mControlType = i;
+        this.mMaxVolume = i2;
+        this.mCurrentVolume = i3;
+        this.mControlId = str;
+    }
+
+    public final void setCurrentVolume(int i) {
+        this.mCurrentVolume = i;
+        ((VolumeProvider) getVolumeProvider()).setCurrentVolume(i);
+        Callback callback = this.mCallback;
+        if (callback != null) {
+            callback.onVolumeChanged(this);
+        }
+    }
+
+    public Object getVolumeProvider() {
+        if (this.mVolumeProviderFwk == null) {
+            if (Build.VERSION.SDK_INT >= 30) {
+                this.mVolumeProviderFwk = new VolumeProvider(this.mControlType, this.mMaxVolume, this.mCurrentVolume, this.mControlId) { // from class: androidx.media.VolumeProviderCompat.1
+                    @Override // android.media.VolumeProvider
+                    public void onSetVolumeTo(int i) {
+                        VolumeProviderCompat.this.onSetVolumeTo(i);
+                    }
+
+                    @Override // android.media.VolumeProvider
+                    public void onAdjustVolume(int i) {
+                        VolumeProviderCompat.this.onAdjustVolume(i);
+                    }
+                };
+            } else {
+                this.mVolumeProviderFwk = new VolumeProvider(this.mControlType, this.mMaxVolume, this.mCurrentVolume) { // from class: androidx.media.VolumeProviderCompat.2
+                    @Override // android.media.VolumeProvider
+                    public void onSetVolumeTo(int i) {
+                        VolumeProviderCompat.this.onSetVolumeTo(i);
+                    }
+
+                    @Override // android.media.VolumeProvider
+                    public void onAdjustVolume(int i) {
+                        VolumeProviderCompat.this.onAdjustVolume(i);
+                    }
+                };
+            }
+        }
+        return this.mVolumeProviderFwk;
+    }
+}

decompiled/sources/androidx/media/app/NotificationCompat.java

@@ -0,0 +1,205 @@
+package androidx.media.app;
+
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.media.session.MediaSession;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.support.v4.media.session.MediaSessionCompat;
+import android.widget.RemoteViews;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.app.NotificationBuilderWithBuilderAccessor;
+import androidx.core.app.NotificationCompat;
+import androidx.media.R;
+
+/* loaded from: classes.dex */
+public class NotificationCompat {
+    private NotificationCompat() {
+    }
+
+    public static class MediaStyle extends NotificationCompat.Style {
+        private static final int MAX_MEDIA_BUTTONS = 5;
+        private static final int MAX_MEDIA_BUTTONS_IN_COMPACT = 3;
+        int[] mActionsToShowInCompact = null;
+        PendingIntent mCancelButtonIntent;
+        boolean mShowCancelButton;
+        MediaSessionCompat.Token mToken;
+
+        public int getBigContentViewLayoutResource(int i) {
+            return i <= 3 ? R.layout.notification_template_big_media_narrow : R.layout.notification_template_big_media;
+        }
+
+        public int getContentViewLayoutResource() {
+            return R.layout.notification_template_media;
+        }
+
+        @Override // androidx.core.app.NotificationCompat.Style
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public RemoteViews makeBigContentView(NotificationBuilderWithBuilderAccessor notificationBuilderWithBuilderAccessor) {
+            return null;
+        }
+
+        @Override // androidx.core.app.NotificationCompat.Style
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public RemoteViews makeContentView(NotificationBuilderWithBuilderAccessor notificationBuilderWithBuilderAccessor) {
+            return null;
+        }
+
+        public MediaStyle setCancelButtonIntent(PendingIntent pendingIntent) {
+            this.mCancelButtonIntent = pendingIntent;
+            return this;
+        }
+
+        public MediaStyle setMediaSession(MediaSessionCompat.Token token) {
+            this.mToken = token;
+            return this;
+        }
+
+        public MediaStyle setShowActionsInCompactView(int... iArr) {
+            this.mActionsToShowInCompact = iArr;
+            return this;
+        }
+
+        public MediaStyle setShowCancelButton(boolean z) {
+            return this;
+        }
+
+        public static MediaSessionCompat.Token getMediaSession(Notification notification) {
+            Parcelable parcelable;
+            Bundle extras = androidx.core.app.NotificationCompat.getExtras(notification);
+            if (extras == null || (parcelable = extras.getParcelable(androidx.core.app.NotificationCompat.EXTRA_MEDIA_SESSION)) == null) {
+                return null;
+            }
+            return MediaSessionCompat.Token.fromToken(parcelable);
+        }
+
+        public MediaStyle() {
+        }
+
+        public MediaStyle(NotificationCompat.Builder builder) {
+            setBuilder(builder);
+        }
+
+        @Override // androidx.core.app.NotificationCompat.Style
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public void apply(NotificationBuilderWithBuilderAccessor notificationBuilderWithBuilderAccessor) {
+            notificationBuilderWithBuilderAccessor.getBuilder().setStyle(fillInMediaStyle(new Notification.MediaStyle()));
+        }
+
+        @RequiresApi(21)
+        public Notification.MediaStyle fillInMediaStyle(Notification.MediaStyle mediaStyle) {
+            int[] iArr = this.mActionsToShowInCompact;
+            if (iArr != null) {
+                mediaStyle.setShowActionsInCompactView(iArr);
+            }
+            MediaSessionCompat.Token token = this.mToken;
+            if (token != null) {
+                mediaStyle.setMediaSession((MediaSession.Token) token.getToken());
+            }
+            return mediaStyle;
+        }
+
+        public RemoteViews generateContentView() {
+            RemoteViews applyStandardTemplate = applyStandardTemplate(false, getContentViewLayoutResource(), true);
+            int size = this.mBuilder.mActions.size();
+            int[] iArr = this.mActionsToShowInCompact;
+            int min = iArr == null ? 0 : Math.min(iArr.length, 3);
+            applyStandardTemplate.removeAllViews(R.id.media_actions);
+            if (min > 0) {
+                for (int i = 0; i < min; i++) {
+                    if (i >= size) {
+                        throw new IllegalArgumentException(String.format("setShowActionsInCompactView: action %d out of bounds (max %d)", Integer.valueOf(i), Integer.valueOf(size - 1)));
+                    }
+                    applyStandardTemplate.addView(R.id.media_actions, generateMediaActionButton(this.mBuilder.mActions.get(this.mActionsToShowInCompact[i])));
+                }
+            }
+            if (this.mShowCancelButton) {
+                applyStandardTemplate.setViewVisibility(R.id.end_padder, 8);
+                applyStandardTemplate.setViewVisibility(R.id.cancel_action, 0);
+                applyStandardTemplate.setOnClickPendingIntent(R.id.cancel_action, this.mCancelButtonIntent);
+                applyStandardTemplate.setInt(R.id.cancel_action, "setAlpha", this.mBuilder.mContext.getResources().getInteger(R.integer.cancel_button_image_alpha));
+            } else {
+                applyStandardTemplate.setViewVisibility(R.id.end_padder, 0);
+                applyStandardTemplate.setViewVisibility(R.id.cancel_action, 8);
+            }
+            return applyStandardTemplate;
+        }
+
+        private RemoteViews generateMediaActionButton(NotificationCompat.Action action) {
+            boolean z = action.getActionIntent() == null;
+            RemoteViews remoteViews = new RemoteViews(this.mBuilder.mContext.getPackageName(), R.layout.notification_media_action);
+            remoteViews.setImageViewResource(R.id.action0, action.getIcon());
+            if (!z) {
+                remoteViews.setOnClickPendingIntent(R.id.action0, action.getActionIntent());
+            }
+            remoteViews.setContentDescription(R.id.action0, action.getTitle());
+            return remoteViews;
+        }
+
+        public RemoteViews generateBigContentView() {
+            int min = Math.min(this.mBuilder.mActions.size(), 5);
+            RemoteViews applyStandardTemplate = applyStandardTemplate(false, getBigContentViewLayoutResource(min), false);
+            applyStandardTemplate.removeAllViews(R.id.media_actions);
+            if (min > 0) {
+                for (int i = 0; i < min; i++) {
+                    applyStandardTemplate.addView(R.id.media_actions, generateMediaActionButton(this.mBuilder.mActions.get(i)));
+                }
+            }
+            if (this.mShowCancelButton) {
+                applyStandardTemplate.setViewVisibility(R.id.cancel_action, 0);
+                applyStandardTemplate.setInt(R.id.cancel_action, "setAlpha", this.mBuilder.mContext.getResources().getInteger(R.integer.cancel_button_image_alpha));
+                applyStandardTemplate.setOnClickPendingIntent(R.id.cancel_action, this.mCancelButtonIntent);
+            } else {
+                applyStandardTemplate.setViewVisibility(R.id.cancel_action, 8);
+            }
+            return applyStandardTemplate;
+        }
+    }
+
+    public static class DecoratedMediaCustomViewStyle extends MediaStyle {
+        @Override // androidx.media.app.NotificationCompat.MediaStyle
+        public int getBigContentViewLayoutResource(int i) {
+            return i <= 3 ? R.layout.notification_template_big_media_narrow_custom : R.layout.notification_template_big_media_custom;
+        }
+
+        @Override // androidx.media.app.NotificationCompat.MediaStyle, androidx.core.app.NotificationCompat.Style
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public RemoteViews makeBigContentView(NotificationBuilderWithBuilderAccessor notificationBuilderWithBuilderAccessor) {
+            return null;
+        }
+
+        @Override // androidx.media.app.NotificationCompat.MediaStyle, androidx.core.app.NotificationCompat.Style
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public RemoteViews makeContentView(NotificationBuilderWithBuilderAccessor notificationBuilderWithBuilderAccessor) {
+            return null;
+        }
+
+        @Override // androidx.core.app.NotificationCompat.Style
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public RemoteViews makeHeadsUpContentView(NotificationBuilderWithBuilderAccessor notificationBuilderWithBuilderAccessor) {
+            return null;
+        }
+
+        @Override // androidx.media.app.NotificationCompat.MediaStyle, androidx.core.app.NotificationCompat.Style
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public void apply(NotificationBuilderWithBuilderAccessor notificationBuilderWithBuilderAccessor) {
+            notificationBuilderWithBuilderAccessor.getBuilder().setStyle(fillInMediaStyle(new Notification.DecoratedMediaCustomViewStyle()));
+        }
+
+        @Override // androidx.media.app.NotificationCompat.MediaStyle
+        public int getContentViewLayoutResource() {
+            return this.mBuilder.getContentView() != null ? R.layout.notification_template_media_custom : super.getContentViewLayoutResource();
+        }
+
+        private void setBackgroundColor(RemoteViews remoteViews) {
+            int color;
+            if (this.mBuilder.getColor() != 0) {
+                color = this.mBuilder.getColor();
+            } else {
+                color = this.mBuilder.mContext.getResources().getColor(R.color.notification_material_background_media_default_color);
+            }
+            remoteViews.setInt(R.id.status_bar_latest_event_content, "setBackgroundColor", color);
+        }
+    }
+}

decompiled/sources/androidx/media/session/MediaButtonReceiver.java

@@ -0,0 +1,163 @@
+package androidx.media.session;
+
+import android.annotation.SuppressLint;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
+import android.support.v4.media.MediaBrowserCompat;
+import android.support.v4.media.session.MediaControllerCompat;
+import android.support.v4.media.session.MediaSessionCompat;
+import android.support.v4.media.session.PlaybackStateCompat;
+import android.util.Log;
+import android.view.KeyEvent;
+import androidx.annotation.RestrictTo;
+import androidx.media.MediaBrowserServiceCompat;
+import com.google.android.gms.drive.DriveFile;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class MediaButtonReceiver extends BroadcastReceiver {
+    private static final String TAG = "MediaButtonReceiver";
+
+    @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")) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Ignore unsupported intent: ");
+            sb.append(intent);
+            return;
+        }
+        ComponentName serviceComponentByAction = getServiceComponentByAction(context, "android.intent.action.MEDIA_BUTTON");
+        if (serviceComponentByAction != null) {
+            intent.setComponent(serviceComponentByAction);
+            startForegroundService(context, intent);
+            return;
+        }
+        ComponentName serviceComponentByAction2 = getServiceComponentByAction(context, MediaBrowserServiceCompat.SERVICE_INTERFACE);
+        if (serviceComponentByAction2 != null) {
+            BroadcastReceiver.PendingResult goAsync = goAsync();
+            Context applicationContext = context.getApplicationContext();
+            MediaButtonConnectionCallback mediaButtonConnectionCallback = new MediaButtonConnectionCallback(applicationContext, intent, goAsync);
+            MediaBrowserCompat mediaBrowserCompat = new MediaBrowserCompat(applicationContext, serviceComponentByAction2, mediaButtonConnectionCallback, null);
+            mediaButtonConnectionCallback.setMediaBrowser(mediaBrowserCompat);
+            mediaBrowserCompat.connect();
+            return;
+        }
+        throw new IllegalStateException("Could not find any Service that handles android.intent.action.MEDIA_BUTTON or implements a media browser service.");
+    }
+
+    public static class MediaButtonConnectionCallback extends MediaBrowserCompat.ConnectionCallback {
+        private final Context mContext;
+        private final Intent mIntent;
+        private MediaBrowserCompat mMediaBrowser;
+        private final BroadcastReceiver.PendingResult mPendingResult;
+
+        public void setMediaBrowser(MediaBrowserCompat mediaBrowserCompat) {
+            this.mMediaBrowser = mediaBrowserCompat;
+        }
+
+        public MediaButtonConnectionCallback(Context context, Intent intent, BroadcastReceiver.PendingResult pendingResult) {
+            this.mContext = context;
+            this.mIntent = intent;
+            this.mPendingResult = pendingResult;
+        }
+
+        @Override // android.support.v4.media.MediaBrowserCompat.ConnectionCallback
+        public void onConnected() {
+            new MediaControllerCompat(this.mContext, this.mMediaBrowser.getSessionToken()).dispatchMediaButtonEvent((KeyEvent) this.mIntent.getParcelableExtra("android.intent.extra.KEY_EVENT"));
+            finish();
+        }
+
+        @Override // android.support.v4.media.MediaBrowserCompat.ConnectionCallback
+        public void onConnectionSuspended() {
+            finish();
+        }
+
+        @Override // android.support.v4.media.MediaBrowserCompat.ConnectionCallback
+        public void onConnectionFailed() {
+            finish();
+        }
+
+        private void finish() {
+            this.mMediaBrowser.disconnect();
+            this.mPendingResult.finish();
+        }
+    }
+
+    public static KeyEvent handleIntent(MediaSessionCompat mediaSessionCompat, Intent intent) {
+        if (mediaSessionCompat == null || intent == null || !"android.intent.action.MEDIA_BUTTON".equals(intent.getAction()) || !intent.hasExtra("android.intent.extra.KEY_EVENT")) {
+            return null;
+        }
+        KeyEvent keyEvent = (KeyEvent) intent.getParcelableExtra("android.intent.extra.KEY_EVENT");
+        mediaSessionCompat.getController().dispatchMediaButtonEvent(keyEvent);
+        return keyEvent;
+    }
+
+    public static PendingIntent buildMediaButtonPendingIntent(Context context, long j) {
+        ComponentName mediaButtonReceiverComponent = getMediaButtonReceiverComponent(context);
+        if (mediaButtonReceiverComponent == null) {
+            Log.w(TAG, "A unique media button receiver could not be found in the given context, so couldn't build a pending intent.");
+            return null;
+        }
+        return buildMediaButtonPendingIntent(context, mediaButtonReceiverComponent, j);
+    }
+
+    @SuppressLint({"WrongConstant"})
+    public static PendingIntent buildMediaButtonPendingIntent(Context context, ComponentName componentName, long j) {
+        if (componentName == null) {
+            Log.w(TAG, "The component name of media button receiver should be provided.");
+            return null;
+        }
+        int keyCode = PlaybackStateCompat.toKeyCode(j);
+        if (keyCode == 0) {
+            Log.w(TAG, "Cannot build a media button pending intent with the given action: " + j);
+            return null;
+        }
+        Intent intent = new Intent("android.intent.action.MEDIA_BUTTON");
+        intent.setComponent(componentName);
+        intent.putExtra("android.intent.extra.KEY_EVENT", new KeyEvent(0, keyCode));
+        intent.addFlags(DriveFile.MODE_READ_ONLY);
+        return PendingIntent.getBroadcast(context, keyCode, intent, MediaSessionCompat.PENDING_INTENT_FLAG_MUTABLE);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static ComponentName getMediaButtonReceiverComponent(Context context) {
+        Intent intent = new Intent("android.intent.action.MEDIA_BUTTON");
+        intent.setPackage(context.getPackageName());
+        List<ResolveInfo> queryBroadcastReceivers = context.getPackageManager().queryBroadcastReceivers(intent, 0);
+        if (queryBroadcastReceivers.size() == 1) {
+            ActivityInfo activityInfo = queryBroadcastReceivers.get(0).activityInfo;
+            return new ComponentName(activityInfo.packageName, activityInfo.name);
+        }
+        if (queryBroadcastReceivers.size() <= 1) {
+            return null;
+        }
+        Log.w(TAG, "More than one BroadcastReceiver that handles android.intent.action.MEDIA_BUTTON was found, returning null.");
+        return null;
+    }
+
+    private static void startForegroundService(Context context, Intent intent) {
+        context.startForegroundService(intent);
+    }
+
+    private static ComponentName getServiceComponentByAction(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) {
+            ServiceInfo serviceInfo = queryIntentServices.get(0).serviceInfo;
+            return new ComponentName(serviceInfo.packageName, serviceInfo.name);
+        }
+        if (queryIntentServices.isEmpty()) {
+            return null;
+        }
+        throw new IllegalStateException("Expected 1 service that handles " + str + ", found " + queryIntentServices.size());
+    }
+}

decompiled/sources/androidx/media/utils/MediaConstants.java

@@ -0,0 +1,77 @@
+package androidx.media.utils;
+
+import android.annotation.SuppressLint;
+import androidx.annotation.RestrictTo;
+
+/* loaded from: classes.dex */
+public final class MediaConstants {
+
+    @SuppressLint({"IntentName"})
+    public static final String BROWSER_ROOT_HINTS_KEY_MEDIA_ART_SIZE_PIXELS = "android.media.extras.MEDIA_ART_SIZE_HINT_PIXELS";
+
+    @SuppressLint({"IntentName"})
+    public static final String BROWSER_ROOT_HINTS_KEY_ROOT_CHILDREN_LIMIT = "androidx.media.MediaBrowserCompat.Extras.KEY_ROOT_CHILDREN_LIMIT";
+
+    @SuppressLint({"IntentName"})
+    public static final String BROWSER_ROOT_HINTS_KEY_ROOT_CHILDREN_SUPPORTED_FLAGS = "androidx.media.MediaBrowserCompat.Extras.KEY_ROOT_CHILDREN_SUPPORTED_FLAGS";
+
+    @SuppressLint({"IntentName"})
+    public static final String BROWSER_SERVICE_EXTRAS_KEY_SEARCH_SUPPORTED = "android.media.browse.SEARCH_SUPPORTED";
+
+    @SuppressLint({"IntentName"})
+    public static final String DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS = "android.media.extra.PLAYBACK_STATUS";
+
+    @SuppressLint({"IntentName"})
+    public static final String DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_BROWSABLE = "android.media.browse.CONTENT_STYLE_BROWSABLE_HINT";
+
+    @SuppressLint({"IntentName"})
+    public static final String DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE = "android.media.browse.CONTENT_STYLE_GROUP_TITLE_HINT";
+
+    @SuppressLint({"IntentName"})
+    public static final String DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_PLAYABLE = "android.media.browse.CONTENT_STYLE_PLAYABLE_HINT";
+    public static final int DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_FULLY_PLAYED = 2;
+    public static final int DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_NOT_PLAYED = 0;
+    public static final int DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_PARTIALLY_PLAYED = 1;
+    public static final int DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_CATEGORY_GRID_ITEM = 4;
+    public static final int DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_CATEGORY_LIST_ITEM = 3;
+    public static final int DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_GRID_ITEM = 2;
+    public static final int DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM = 1;
+
+    @SuppressLint({"IntentName"})
+    public static final String METADATA_KEY_CONTENT_ID = "androidx.media.MediaMetadatCompat.METADATA_KEY_CONTENT_ID";
+
+    @SuppressLint({"IntentName"})
+    public static final String METADATA_KEY_IS_ADVERTISEMENT = "android.media.metadata.ADVERTISEMENT";
+
+    @SuppressLint({"IntentName"})
+    public static final String METADATA_KEY_IS_EXPLICIT = "android.media.IS_EXPLICIT";
+    public static final long METADATA_VALUE_ATTRIBUTE_PRESENT = 1;
+
+    @SuppressLint({"IntentName"})
+    public static final String PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_INTENT = "android.media.extras.ERROR_RESOLUTION_ACTION_INTENT";
+
+    @SuppressLint({"IntentName"})
+    public static final String PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL = "android.media.extras.ERROR_RESOLUTION_ACTION_LABEL";
+
+    @SuppressLint({"IntentName"})
+    public static final String PLAYBACK_STATE_EXTRAS_KEY_MEDIA_ID = "androidx.media.PlaybackStateCompat.Extras.KEY_MEDIA_ID";
+
+    @SuppressLint({"IntentName"})
+    public static final String SESSION_EXTRAS_KEY_ACCOUNT_NAME = "androidx.media.MediaSessionCompat.Extras.KEY_ACCOUNT_NAME";
+
+    @SuppressLint({"IntentName"})
+    public static final String SESSION_EXTRAS_KEY_ACCOUNT_TYPE = "androidx.media.MediaSessionCompat.Extras.KEY_ACCOUNT_TYPE";
+
+    @SuppressLint({"IntentName"})
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final String SESSION_EXTRAS_KEY_AUTHTOKEN = "androidx.media.MediaSessionCompat.Extras.KEY_AUTHTOKEN";
+
+    @SuppressLint({"IntentName"})
+    public static final String SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_NEXT = "android.media.playback.ALWAYS_RESERVE_SPACE_FOR.ACTION_SKIP_TO_NEXT";
+
+    @SuppressLint({"IntentName"})
+    public static final String SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_PREV = "android.media.playback.ALWAYS_RESERVE_SPACE_FOR.ACTION_SKIP_TO_PREVIOUS";
+
+    private MediaConstants() {
+    }
+}