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/com/mbridge/msdk/playercommon/exoplayer2/drm/ClearKeyUtil.java

@@ -0,0 +1,57 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.util.Log;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+final class ClearKeyUtil {
+    private static final String TAG = "ClearKeyUtil";
+
+    private ClearKeyUtil() {
+    }
+
+    public static byte[] adjustRequestData(byte[] bArr) {
+        return Util.SDK_INT >= 27 ? bArr : Util.getUtf8Bytes(base64ToBase64Url(Util.fromUtf8Bytes(bArr)));
+    }
+
+    public static byte[] adjustResponseData(byte[] bArr) {
+        if (Util.SDK_INT >= 27) {
+            return bArr;
+        }
+        try {
+            JSONObject jSONObject = new JSONObject(Util.fromUtf8Bytes(bArr));
+            StringBuilder sb = new StringBuilder("{\"keys\":[");
+            JSONArray jSONArray = jSONObject.getJSONArray("keys");
+            for (int i = 0; i < jSONArray.length(); i++) {
+                if (i != 0) {
+                    sb.append(",");
+                }
+                JSONObject jSONObject2 = jSONArray.getJSONObject(i);
+                sb.append("{\"k\":\"");
+                sb.append(base64UrlToBase64(jSONObject2.getString(CampaignEx.JSON_KEY_AD_K)));
+                sb.append("\",\"kid\":\"");
+                sb.append(base64UrlToBase64(jSONObject2.getString("kid")));
+                sb.append("\",\"kty\":\"");
+                sb.append(jSONObject2.getString("kty"));
+                sb.append("\"}");
+            }
+            sb.append("]}");
+            return Util.getUtf8Bytes(sb.toString());
+        } catch (JSONException e) {
+            Log.e(TAG, "Failed to adjust response data: " + Util.fromUtf8Bytes(bArr), e);
+            return bArr;
+        }
+    }
+
+    private static String base64ToBase64Url(String str) {
+        return str.replace('+', '-').replace('/', '_');
+    }
+
+    private static String base64UrlToBase64(String str) {
+        return str.replace('-', '+').replace('_', '/');
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DecryptionException.java

@@ -0,0 +1,11 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+/* loaded from: classes4.dex */
+public class DecryptionException extends Exception {
+    public final int errorCode;
+
+    public DecryptionException(int i, String str) {
+        super(str);
+        this.errorCode = i;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DefaultDrmSession.java

@@ -0,0 +1,444 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.media.NotProvisionedException;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+import android.util.Pair;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+@TargetApi(18)
+/* loaded from: classes4.dex */
+class DefaultDrmSession<T extends ExoMediaCrypto> implements DrmSession<T> {
+    private static final int MAX_LICENSE_DURATION_TO_RENEW = 60;
+    private static final int MSG_KEYS = 1;
+    private static final int MSG_PROVISION = 0;
+    private static final String TAG = "DefaultDrmSession";
+    final MediaDrmCallback callback;
+    private Object currentKeyRequest;
+    private Object currentProvisionRequest;
+    private final DefaultDrmSessionEventListener.EventDispatcher eventDispatcher;
+    private final int initialDrmRequestRetryCount;
+    private DrmSession.DrmSessionException lastException;
+    private T mediaCrypto;
+    private final ExoMediaDrm<T> mediaDrm;
+    private final int mode;
+    private byte[] offlineLicenseKeySetId;
+    private int openCount;
+    private final HashMap<String, String> optionalKeyRequestParameters;
+    private DefaultDrmSession<T>.PostRequestHandler postRequestHandler;
+    final DefaultDrmSession<T>.PostResponseHandler postResponseHandler;
+    private final ProvisioningManager<T> provisioningManager;
+    private HandlerThread requestHandlerThread;
+    private final DrmInitData.SchemeData schemeData;
+    private byte[] sessionId;
+    private int state;
+    final UUID uuid;
+
+    public interface ProvisioningManager<T extends ExoMediaCrypto> {
+        void onProvisionCompleted();
+
+        void onProvisionError(Exception exc);
+
+        void provisionRequired(DefaultDrmSession<T> defaultDrmSession);
+    }
+
+    private boolean isOpen() {
+        int i = this.state;
+        return i == 3 || i == 4;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final DrmSession.DrmSessionException getError() {
+        if (this.state == 1) {
+            return this.lastException;
+        }
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final T getMediaCrypto() {
+        return this.mediaCrypto;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public byte[] getOfflineLicenseKeySetId() {
+        return this.offlineLicenseKeySetId;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final int getState() {
+        return this.state;
+    }
+
+    public DefaultDrmSession(UUID uuid, ExoMediaDrm<T> exoMediaDrm, ProvisioningManager<T> provisioningManager, @Nullable DrmInitData.SchemeData schemeData, int i, @Nullable byte[] bArr, HashMap<String, String> hashMap, MediaDrmCallback mediaDrmCallback, Looper looper, DefaultDrmSessionEventListener.EventDispatcher eventDispatcher, int i2) {
+        this.uuid = uuid;
+        this.provisioningManager = provisioningManager;
+        this.mediaDrm = exoMediaDrm;
+        this.mode = i;
+        this.offlineLicenseKeySetId = bArr;
+        this.schemeData = bArr != null ? null : schemeData;
+        this.optionalKeyRequestParameters = hashMap;
+        this.callback = mediaDrmCallback;
+        this.initialDrmRequestRetryCount = i2;
+        this.eventDispatcher = eventDispatcher;
+        this.state = 2;
+        this.postResponseHandler = new PostResponseHandler(looper);
+        HandlerThread handlerThread = new HandlerThread("DrmRequestHandler");
+        this.requestHandlerThread = handlerThread;
+        handlerThread.start();
+        this.postRequestHandler = new PostRequestHandler(this.requestHandlerThread.getLooper());
+    }
+
+    public void acquire() {
+        int i = this.openCount + 1;
+        this.openCount = i;
+        if (i == 1 && this.state != 1 && openInternal(true)) {
+            doLicense(true);
+        }
+    }
+
+    public boolean release() {
+        int i = this.openCount - 1;
+        this.openCount = i;
+        if (i != 0) {
+            return false;
+        }
+        this.state = 0;
+        this.postResponseHandler.removeCallbacksAndMessages(null);
+        this.postRequestHandler.removeCallbacksAndMessages(null);
+        this.postRequestHandler = null;
+        this.requestHandlerThread.quit();
+        this.requestHandlerThread = null;
+        this.mediaCrypto = null;
+        this.lastException = null;
+        this.currentKeyRequest = null;
+        this.currentProvisionRequest = null;
+        byte[] bArr = this.sessionId;
+        if (bArr != null) {
+            this.mediaDrm.closeSession(bArr);
+            this.sessionId = null;
+        }
+        return true;
+    }
+
+    public boolean hasInitData(byte[] bArr) {
+        DrmInitData.SchemeData schemeData = this.schemeData;
+        return Arrays.equals(schemeData != null ? schemeData.data : null, bArr);
+    }
+
+    public boolean hasSessionId(byte[] bArr) {
+        return Arrays.equals(this.sessionId, bArr);
+    }
+
+    public void onMediaDrmEvent(int i) {
+        if (isOpen()) {
+            if (i == 1) {
+                this.state = 3;
+                this.provisioningManager.provisionRequired(this);
+            } else if (i == 2) {
+                doLicense(false);
+            } else {
+                if (i != 3) {
+                    return;
+                }
+                onKeysExpired();
+            }
+        }
+    }
+
+    public void provision() {
+        ExoMediaDrm.ProvisionRequest provisionRequest = this.mediaDrm.getProvisionRequest();
+        this.currentProvisionRequest = provisionRequest;
+        this.postRequestHandler.post(0, provisionRequest, true);
+    }
+
+    public void onProvisionCompleted() {
+        if (openInternal(false)) {
+            doLicense(true);
+        }
+    }
+
+    public void onProvisionError(Exception exc) {
+        onError(exc);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public Map<String, String> queryKeyStatus() {
+        byte[] bArr = this.sessionId;
+        if (bArr == null) {
+            return null;
+        }
+        return this.mediaDrm.queryKeyStatus(bArr);
+    }
+
+    private boolean openInternal(boolean z) {
+        if (isOpen()) {
+            return true;
+        }
+        try {
+            byte[] openSession = this.mediaDrm.openSession();
+            this.sessionId = openSession;
+            this.mediaCrypto = this.mediaDrm.createMediaCrypto(openSession);
+            this.state = 3;
+            return true;
+        } catch (NotProvisionedException e) {
+            if (z) {
+                this.provisioningManager.provisionRequired(this);
+                return false;
+            }
+            onError(e);
+            return false;
+        } catch (Exception e2) {
+            onError(e2);
+            return false;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onProvisionResponse(Object obj, Object obj2) {
+        if (obj == this.currentProvisionRequest) {
+            if (this.state == 2 || isOpen()) {
+                this.currentProvisionRequest = null;
+                if (obj2 instanceof Exception) {
+                    this.provisioningManager.onProvisionError((Exception) obj2);
+                    return;
+                }
+                try {
+                    this.mediaDrm.provideProvisionResponse((byte[]) obj2);
+                    this.provisioningManager.onProvisionCompleted();
+                } catch (Exception e) {
+                    this.provisioningManager.onProvisionError(e);
+                }
+            }
+        }
+    }
+
+    private void doLicense(boolean z) {
+        int i = this.mode;
+        if (i != 0 && i != 1) {
+            if (i != 2) {
+                if (i == 3 && restoreKeys()) {
+                    postKeyRequest(3, z);
+                    return;
+                }
+                return;
+            }
+            if (this.offlineLicenseKeySetId == null) {
+                postKeyRequest(2, z);
+                return;
+            } else {
+                if (restoreKeys()) {
+                    postKeyRequest(2, z);
+                    return;
+                }
+                return;
+            }
+        }
+        if (this.offlineLicenseKeySetId == null) {
+            postKeyRequest(1, z);
+            return;
+        }
+        if (this.state == 4 || restoreKeys()) {
+            long licenseDurationRemainingSec = getLicenseDurationRemainingSec();
+            if (this.mode == 0 && licenseDurationRemainingSec <= 60) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Offline license has expired or will expire soon. Remaining seconds: ");
+                sb.append(licenseDurationRemainingSec);
+                postKeyRequest(2, z);
+                return;
+            }
+            if (licenseDurationRemainingSec <= 0) {
+                onError(new KeysExpiredException());
+            } else {
+                this.state = 4;
+                this.eventDispatcher.drmKeysRestored();
+            }
+        }
+    }
+
+    private boolean restoreKeys() {
+        try {
+            this.mediaDrm.restoreKeys(this.sessionId, this.offlineLicenseKeySetId);
+            return true;
+        } catch (Exception e) {
+            Log.e(TAG, "Error trying to restore Widevine keys.", e);
+            onError(e);
+            return false;
+        }
+    }
+
+    private long getLicenseDurationRemainingSec() {
+        if (!C.WIDEVINE_UUID.equals(this.uuid)) {
+            return Long.MAX_VALUE;
+        }
+        Pair<Long, Long> licenseDurationRemainingSec = WidevineUtil.getLicenseDurationRemainingSec(this);
+        return Math.min(((Long) licenseDurationRemainingSec.first).longValue(), ((Long) licenseDurationRemainingSec.second).longValue());
+    }
+
+    private void postKeyRequest(int i, boolean z) {
+        String str;
+        byte[] bArr;
+        String str2;
+        byte[] bArr2 = i == 3 ? this.offlineLicenseKeySetId : this.sessionId;
+        DrmInitData.SchemeData schemeData = this.schemeData;
+        if (schemeData != null) {
+            byte[] bArr3 = schemeData.data;
+            String str3 = schemeData.mimeType;
+            str = schemeData.licenseServerUrl;
+            str2 = str3;
+            bArr = bArr3;
+        } else {
+            str = null;
+            bArr = null;
+            str2 = null;
+        }
+        try {
+            Pair create = Pair.create(this.mediaDrm.getKeyRequest(bArr2, bArr, str2, i, this.optionalKeyRequestParameters), str);
+            this.currentKeyRequest = create;
+            this.postRequestHandler.post(1, create, z);
+        } catch (Exception e) {
+            onKeysError(e);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onKeyResponse(Object obj, Object obj2) {
+        if (obj == this.currentKeyRequest && isOpen()) {
+            this.currentKeyRequest = null;
+            if (obj2 instanceof Exception) {
+                onKeysError((Exception) obj2);
+                return;
+            }
+            try {
+                byte[] bArr = (byte[]) obj2;
+                if (this.mode == 3) {
+                    this.mediaDrm.provideKeyResponse(this.offlineLicenseKeySetId, bArr);
+                    this.eventDispatcher.drmKeysRemoved();
+                    return;
+                }
+                byte[] provideKeyResponse = this.mediaDrm.provideKeyResponse(this.sessionId, bArr);
+                int i = this.mode;
+                if ((i == 2 || (i == 0 && this.offlineLicenseKeySetId != null)) && provideKeyResponse != null && provideKeyResponse.length != 0) {
+                    this.offlineLicenseKeySetId = provideKeyResponse;
+                }
+                this.state = 4;
+                this.eventDispatcher.drmKeysLoaded();
+            } catch (Exception e) {
+                onKeysError(e);
+            }
+        }
+    }
+
+    private void onKeysExpired() {
+        if (this.state == 4) {
+            this.state = 3;
+            onError(new KeysExpiredException());
+        }
+    }
+
+    private void onKeysError(Exception exc) {
+        if (exc instanceof NotProvisionedException) {
+            this.provisioningManager.provisionRequired(this);
+        } else {
+            onError(exc);
+        }
+    }
+
+    private void onError(Exception exc) {
+        this.lastException = new DrmSession.DrmSessionException(exc);
+        this.eventDispatcher.drmSessionManagerError(exc);
+        if (this.state != 4) {
+            this.state = 1;
+        }
+    }
+
+    @SuppressLint({"HandlerLeak"})
+    public class PostResponseHandler extends Handler {
+        public PostResponseHandler(Looper looper) {
+            super(looper);
+        }
+
+        @Override // android.os.Handler
+        public void handleMessage(Message message) {
+            Pair pair = (Pair) message.obj;
+            Object obj = pair.first;
+            Object obj2 = pair.second;
+            int i = message.what;
+            if (i == 0) {
+                DefaultDrmSession.this.onProvisionResponse(obj, obj2);
+            } else {
+                if (i != 1) {
+                    return;
+                }
+                DefaultDrmSession.this.onKeyResponse(obj, obj2);
+            }
+        }
+    }
+
+    @SuppressLint({"HandlerLeak"})
+    public class PostRequestHandler extends Handler {
+        public PostRequestHandler(Looper looper) {
+            super(looper);
+        }
+
+        public void post(int i, Object obj, boolean z) {
+            obtainMessage(i, z ? 1 : 0, 0, obj).sendToTarget();
+        }
+
+        @Override // android.os.Handler
+        public void handleMessage(Message message) {
+            Object obj = message.obj;
+            try {
+                int i = message.what;
+                if (i == 0) {
+                    DefaultDrmSession defaultDrmSession = DefaultDrmSession.this;
+                    e = defaultDrmSession.callback.executeProvisionRequest(defaultDrmSession.uuid, (ExoMediaDrm.ProvisionRequest) obj);
+                } else if (i == 1) {
+                    Pair pair = (Pair) obj;
+                    ExoMediaDrm.KeyRequest keyRequest = (ExoMediaDrm.KeyRequest) pair.first;
+                    String str = (String) pair.second;
+                    DefaultDrmSession defaultDrmSession2 = DefaultDrmSession.this;
+                    e = defaultDrmSession2.callback.executeKeyRequest(defaultDrmSession2.uuid, keyRequest, str);
+                } else {
+                    throw new RuntimeException();
+                }
+            } catch (Exception e) {
+                e = e;
+                if (maybeRetryRequest(message)) {
+                    return;
+                }
+            }
+            DefaultDrmSession.this.postResponseHandler.obtainMessage(message.what, Pair.create(obj, e)).sendToTarget();
+        }
+
+        private boolean maybeRetryRequest(Message message) {
+            int i;
+            if (message.arg1 != 1 || (i = message.arg2 + 1) > DefaultDrmSession.this.initialDrmRequestRetryCount) {
+                return false;
+            }
+            Message obtain = Message.obtain(message);
+            obtain.arg2 = i;
+            sendMessageDelayed(obtain, getRetryDelayMillis(i));
+            return true;
+        }
+
+        private long getRetryDelayMillis(int i) {
+            return Math.min((i - 1) * 1000, 5000);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DefaultDrmSessionEventListener.java

@@ -0,0 +1,102 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.os.Handler;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.Iterator;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/* loaded from: classes4.dex */
+public interface DefaultDrmSessionEventListener {
+    void onDrmKeysLoaded();
+
+    void onDrmKeysRemoved();
+
+    void onDrmKeysRestored();
+
+    void onDrmSessionManagerError(Exception exc);
+
+    public static final class EventDispatcher {
+        private final CopyOnWriteArrayList<HandlerAndListener> listeners = new CopyOnWriteArrayList<>();
+
+        public final void addListener(Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+            Assertions.checkArgument((handler == null || defaultDrmSessionEventListener == null) ? false : true);
+            this.listeners.add(new HandlerAndListener(handler, defaultDrmSessionEventListener));
+        }
+
+        public final void removeListener(DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+            Iterator<HandlerAndListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                HandlerAndListener next = it.next();
+                if (next.listener == defaultDrmSessionEventListener) {
+                    this.listeners.remove(next);
+                }
+            }
+        }
+
+        public final void drmKeysLoaded() {
+            Iterator<HandlerAndListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                HandlerAndListener next = it.next();
+                final DefaultDrmSessionEventListener defaultDrmSessionEventListener = next.listener;
+                next.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener.EventDispatcher.1
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        defaultDrmSessionEventListener.onDrmKeysLoaded();
+                    }
+                });
+            }
+        }
+
+        public final void drmSessionManagerError(final Exception exc) {
+            Iterator<HandlerAndListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                HandlerAndListener next = it.next();
+                final DefaultDrmSessionEventListener defaultDrmSessionEventListener = next.listener;
+                next.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener.EventDispatcher.2
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        defaultDrmSessionEventListener.onDrmSessionManagerError(exc);
+                    }
+                });
+            }
+        }
+
+        public final void drmKeysRestored() {
+            Iterator<HandlerAndListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                HandlerAndListener next = it.next();
+                final DefaultDrmSessionEventListener defaultDrmSessionEventListener = next.listener;
+                next.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener.EventDispatcher.3
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        defaultDrmSessionEventListener.onDrmKeysRestored();
+                    }
+                });
+            }
+        }
+
+        public final void drmKeysRemoved() {
+            Iterator<HandlerAndListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                HandlerAndListener next = it.next();
+                final DefaultDrmSessionEventListener defaultDrmSessionEventListener = next.listener;
+                next.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener.EventDispatcher.4
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        defaultDrmSessionEventListener.onDrmKeysRemoved();
+                    }
+                });
+            }
+        }
+
+        public static final class HandlerAndListener {
+            public final Handler handler;
+            public final DefaultDrmSessionEventListener listener;
+
+            public HandlerAndListener(Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+                this.handler = handler;
+                this.listener = defaultDrmSessionEventListener;
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DefaultDrmSessionManager.java

@@ -0,0 +1,376 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.text.TextUtils;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import com.ironsource.mediationsdk.metadata.a;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.PsshAtomUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
+
+@TargetApi(18)
+/* loaded from: classes4.dex */
+public class DefaultDrmSessionManager<T extends ExoMediaCrypto> implements DefaultDrmSession.ProvisioningManager<T>, DrmSessionManager<T> {
+    public static final int INITIAL_DRM_REQUEST_RETRY_COUNT = 3;
+    public static final int MODE_DOWNLOAD = 2;
+    public static final int MODE_PLAYBACK = 0;
+    public static final int MODE_QUERY = 1;
+    public static final int MODE_RELEASE = 3;
+    public static final String PLAYREADY_CUSTOM_DATA_KEY = "PRCustomData";
+    private static final String TAG = "DefaultDrmSessionMgr";
+    private final MediaDrmCallback callback;
+    private final DefaultDrmSessionEventListener.EventDispatcher eventDispatcher;
+    private final int initialDrmRequestRetryCount;
+    private final ExoMediaDrm<T> mediaDrm;
+    volatile DefaultDrmSessionManager<T>.MediaDrmHandler mediaDrmHandler;
+    private int mode;
+    private final boolean multiSession;
+    private byte[] offlineLicenseKeySetId;
+    private final HashMap<String, String> optionalKeyRequestParameters;
+    private Looper playbackLooper;
+    private final List<DefaultDrmSession<T>> provisioningSessions;
+    private final List<DefaultDrmSession<T>> sessions;
+    private final UUID uuid;
+
+    @Deprecated
+    public interface EventListener extends DefaultDrmSessionEventListener {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Mode {
+    }
+
+    public static final class MissingSchemeDataException extends Exception {
+        private MissingSchemeDataException(UUID uuid) {
+            super("Media does not support uuid: " + uuid);
+        }
+    }
+
+    @Deprecated
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newWidevineInstance(MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) throws UnsupportedDrmException {
+        DefaultDrmSessionManager<FrameworkMediaCrypto> newWidevineInstance = newWidevineInstance(mediaDrmCallback, hashMap);
+        if (handler != null && defaultDrmSessionEventListener != null) {
+            newWidevineInstance.addListener(handler, defaultDrmSessionEventListener);
+        }
+        return newWidevineInstance;
+    }
+
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newWidevineInstance(MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap) throws UnsupportedDrmException {
+        return newFrameworkInstance(C.WIDEVINE_UUID, mediaDrmCallback, hashMap);
+    }
+
+    @Deprecated
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newPlayReadyInstance(MediaDrmCallback mediaDrmCallback, String str, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) throws UnsupportedDrmException {
+        DefaultDrmSessionManager<FrameworkMediaCrypto> newPlayReadyInstance = newPlayReadyInstance(mediaDrmCallback, str);
+        if (handler != null && defaultDrmSessionEventListener != null) {
+            newPlayReadyInstance.addListener(handler, defaultDrmSessionEventListener);
+        }
+        return newPlayReadyInstance;
+    }
+
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newPlayReadyInstance(MediaDrmCallback mediaDrmCallback, String str) throws UnsupportedDrmException {
+        HashMap hashMap;
+        if (TextUtils.isEmpty(str)) {
+            hashMap = null;
+        } else {
+            hashMap = new HashMap();
+            hashMap.put(PLAYREADY_CUSTOM_DATA_KEY, str);
+        }
+        return newFrameworkInstance(C.PLAYREADY_UUID, mediaDrmCallback, hashMap);
+    }
+
+    @Deprecated
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newFrameworkInstance(UUID uuid, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) throws UnsupportedDrmException {
+        DefaultDrmSessionManager<FrameworkMediaCrypto> newFrameworkInstance = newFrameworkInstance(uuid, mediaDrmCallback, hashMap);
+        if (handler != null && defaultDrmSessionEventListener != null) {
+            newFrameworkInstance.addListener(handler, defaultDrmSessionEventListener);
+        }
+        return newFrameworkInstance;
+    }
+
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newFrameworkInstance(UUID uuid, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap) throws UnsupportedDrmException {
+        return new DefaultDrmSessionManager<>(uuid, (ExoMediaDrm) FrameworkMediaDrm.newInstance(uuid), mediaDrmCallback, hashMap, false, 3);
+    }
+
+    @Deprecated
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+        this(uuid, exoMediaDrm, mediaDrmCallback, hashMap);
+        if (handler == null || defaultDrmSessionEventListener == null) {
+            return;
+        }
+        addListener(handler, defaultDrmSessionEventListener);
+    }
+
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap) {
+        this(uuid, (ExoMediaDrm) exoMediaDrm, mediaDrmCallback, hashMap, false, 3);
+    }
+
+    @Deprecated
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener, boolean z) {
+        this(uuid, exoMediaDrm, mediaDrmCallback, hashMap, z);
+        if (handler == null || defaultDrmSessionEventListener == null) {
+            return;
+        }
+        addListener(handler, defaultDrmSessionEventListener);
+    }
+
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, boolean z) {
+        this(uuid, exoMediaDrm, mediaDrmCallback, hashMap, z, 3);
+    }
+
+    @Deprecated
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener, boolean z, int i) {
+        this(uuid, exoMediaDrm, mediaDrmCallback, hashMap, z, i);
+        if (handler == null || defaultDrmSessionEventListener == null) {
+            return;
+        }
+        addListener(handler, defaultDrmSessionEventListener);
+    }
+
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, boolean z, int i) {
+        Assertions.checkNotNull(uuid);
+        Assertions.checkNotNull(exoMediaDrm);
+        Assertions.checkArgument(!C.COMMON_PSSH_UUID.equals(uuid), "Use C.CLEARKEY_UUID instead");
+        this.uuid = uuid;
+        this.mediaDrm = exoMediaDrm;
+        this.callback = mediaDrmCallback;
+        this.optionalKeyRequestParameters = hashMap;
+        this.eventDispatcher = new DefaultDrmSessionEventListener.EventDispatcher();
+        this.multiSession = z;
+        this.initialDrmRequestRetryCount = i;
+        this.mode = 0;
+        this.sessions = new ArrayList();
+        this.provisioningSessions = new ArrayList();
+        if (z) {
+            exoMediaDrm.setPropertyString("sessionSharing", a.j);
+        }
+        exoMediaDrm.setOnEventListener(new MediaDrmEventListener());
+    }
+
+    public final void addListener(Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+        this.eventDispatcher.addListener(handler, defaultDrmSessionEventListener);
+    }
+
+    public final void removeListener(DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+        this.eventDispatcher.removeListener(defaultDrmSessionEventListener);
+    }
+
+    public final String getPropertyString(String str) {
+        return this.mediaDrm.getPropertyString(str);
+    }
+
+    public final void setPropertyString(String str, String str2) {
+        this.mediaDrm.setPropertyString(str, str2);
+    }
+
+    public final byte[] getPropertyByteArray(String str) {
+        return this.mediaDrm.getPropertyByteArray(str);
+    }
+
+    public final void setPropertyByteArray(String str, byte[] bArr) {
+        this.mediaDrm.setPropertyByteArray(str, bArr);
+    }
+
+    public void setMode(int i, byte[] bArr) {
+        Assertions.checkState(this.sessions.isEmpty());
+        if (i == 1 || i == 3) {
+            Assertions.checkNotNull(bArr);
+        }
+        this.mode = i;
+        this.offlineLicenseKeySetId = bArr;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager
+    public boolean canAcquireSession(@NonNull DrmInitData drmInitData) {
+        if (this.offlineLicenseKeySetId != null) {
+            return true;
+        }
+        if (getSchemeData(drmInitData, this.uuid, true) == null) {
+            if (drmInitData.schemeDataCount != 1 || !drmInitData.get(0).matches(C.COMMON_PSSH_UUID)) {
+                return false;
+            }
+            Log.w(TAG, "DrmInitData only contains common PSSH SchemeData. Assuming support for: " + this.uuid);
+        }
+        String str = drmInitData.schemeType;
+        if (str == null || C.CENC_TYPE_cenc.equals(str)) {
+            return true;
+        }
+        return !(C.CENC_TYPE_cbc1.equals(str) || C.CENC_TYPE_cbcs.equals(str) || C.CENC_TYPE_cens.equals(str)) || Util.SDK_INT >= 25;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r2v0, types: [com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionManager$1] */
+    /* JADX WARN: Type inference failed for: r2v1 */
+    /* JADX WARN: Type inference failed for: r2v12 */
+    /* JADX WARN: Type inference failed for: r2v2 */
+    /* JADX WARN: Type inference failed for: r2v3, types: [com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession, com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession<T extends com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto>] */
+    /* JADX WARN: Type inference failed for: r2v5 */
+    /* JADX WARN: Type inference failed for: r2v7, types: [com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession] */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager
+    public DrmSession<T> acquireSession(Looper looper, DrmInitData drmInitData) {
+        DrmInitData.SchemeData schemeData;
+        Looper looper2 = this.playbackLooper;
+        Assertions.checkState(looper2 == null || looper2 == looper);
+        if (this.sessions.isEmpty()) {
+            this.playbackLooper = looper;
+            if (this.mediaDrmHandler == null) {
+                this.mediaDrmHandler = new MediaDrmHandler(looper);
+            }
+        }
+        DefaultDrmSession<T> defaultDrmSession = 0;
+        defaultDrmSession = 0;
+        if (this.offlineLicenseKeySetId == null) {
+            DrmInitData.SchemeData schemeData2 = getSchemeData(drmInitData, this.uuid, false);
+            if (schemeData2 == null) {
+                MissingSchemeDataException missingSchemeDataException = new MissingSchemeDataException(this.uuid);
+                this.eventDispatcher.drmSessionManagerError(missingSchemeDataException);
+                return new ErrorStateDrmSession(new DrmSession.DrmSessionException(missingSchemeDataException));
+            }
+            schemeData = schemeData2;
+        } else {
+            schemeData = null;
+        }
+        if (!this.multiSession) {
+            if (!this.sessions.isEmpty()) {
+                defaultDrmSession = this.sessions.get(0);
+            }
+        } else {
+            byte[] bArr = schemeData != null ? schemeData.data : null;
+            Iterator<DefaultDrmSession<T>> it = this.sessions.iterator();
+            while (true) {
+                if (!it.hasNext()) {
+                    break;
+                }
+                DefaultDrmSession<T> next = it.next();
+                if (next.hasInitData(bArr)) {
+                    defaultDrmSession = next;
+                    break;
+                }
+            }
+        }
+        if (defaultDrmSession == 0) {
+            DefaultDrmSession<T> defaultDrmSession2 = new DefaultDrmSession<>(this.uuid, this.mediaDrm, this, schemeData, this.mode, this.offlineLicenseKeySetId, this.optionalKeyRequestParameters, this.callback, looper, this.eventDispatcher, this.initialDrmRequestRetryCount);
+            this.sessions.add(defaultDrmSession2);
+            defaultDrmSession = defaultDrmSession2;
+        }
+        ((DefaultDrmSession) defaultDrmSession).acquire();
+        return (DrmSession<T>) defaultDrmSession;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager
+    public void releaseSession(DrmSession<T> drmSession) {
+        if (drmSession instanceof ErrorStateDrmSession) {
+            return;
+        }
+        DefaultDrmSession<T> defaultDrmSession = (DefaultDrmSession) drmSession;
+        if (defaultDrmSession.release()) {
+            this.sessions.remove(defaultDrmSession);
+            if (this.provisioningSessions.size() > 1 && this.provisioningSessions.get(0) == defaultDrmSession) {
+                this.provisioningSessions.get(1).provision();
+            }
+            this.provisioningSessions.remove(defaultDrmSession);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession.ProvisioningManager
+    public void provisionRequired(DefaultDrmSession<T> defaultDrmSession) {
+        this.provisioningSessions.add(defaultDrmSession);
+        if (this.provisioningSessions.size() == 1) {
+            defaultDrmSession.provision();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession.ProvisioningManager
+    public void onProvisionCompleted() {
+        Iterator<DefaultDrmSession<T>> it = this.provisioningSessions.iterator();
+        while (it.hasNext()) {
+            it.next().onProvisionCompleted();
+        }
+        this.provisioningSessions.clear();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession.ProvisioningManager
+    public void onProvisionError(Exception exc) {
+        Iterator<DefaultDrmSession<T>> it = this.provisioningSessions.iterator();
+        while (it.hasNext()) {
+            it.next().onProvisionError(exc);
+        }
+        this.provisioningSessions.clear();
+    }
+
+    private static DrmInitData.SchemeData getSchemeData(DrmInitData drmInitData, UUID uuid, boolean z) {
+        ArrayList arrayList = new ArrayList(drmInitData.schemeDataCount);
+        for (int i = 0; i < drmInitData.schemeDataCount; i++) {
+            DrmInitData.SchemeData schemeData = drmInitData.get(i);
+            if ((schemeData.matches(uuid) || (C.CLEARKEY_UUID.equals(uuid) && schemeData.matches(C.COMMON_PSSH_UUID))) && (schemeData.data != null || z)) {
+                arrayList.add(schemeData);
+            }
+        }
+        if (arrayList.isEmpty()) {
+            return null;
+        }
+        if (C.WIDEVINE_UUID.equals(uuid)) {
+            for (int i2 = 0; i2 < arrayList.size(); i2++) {
+                DrmInitData.SchemeData schemeData2 = (DrmInitData.SchemeData) arrayList.get(i2);
+                int parseVersion = schemeData2.hasData() ? PsshAtomUtil.parseVersion(schemeData2.data) : -1;
+                int i3 = Util.SDK_INT;
+                if (i3 < 23 && parseVersion == 0) {
+                    return schemeData2;
+                }
+                if (i3 >= 23 && parseVersion == 1) {
+                    return schemeData2;
+                }
+            }
+        }
+        return (DrmInitData.SchemeData) arrayList.get(0);
+    }
+
+    @SuppressLint({"HandlerLeak"})
+    public class MediaDrmHandler extends Handler {
+        public MediaDrmHandler(Looper looper) {
+            super(looper);
+        }
+
+        @Override // android.os.Handler
+        public void handleMessage(Message message) {
+            byte[] bArr = (byte[]) message.obj;
+            for (DefaultDrmSession defaultDrmSession : DefaultDrmSessionManager.this.sessions) {
+                if (defaultDrmSession.hasSessionId(bArr)) {
+                    defaultDrmSession.onMediaDrmEvent(message.what);
+                    return;
+                }
+            }
+        }
+    }
+
+    public class MediaDrmEventListener implements ExoMediaDrm.OnEventListener<T> {
+        private MediaDrmEventListener() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.OnEventListener
+        public void onEvent(ExoMediaDrm<? extends T> exoMediaDrm, byte[] bArr, int i, int i2, byte[] bArr2) {
+            if (DefaultDrmSessionManager.this.mode == 0) {
+                DefaultDrmSessionManager.this.mediaDrmHandler.obtainMessage(i, bArr).sendToTarget();
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DrmInitData.java

@@ -0,0 +1,260 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public final class DrmInitData implements Parcelable, Comparator<SchemeData> {
+    public static final Parcelable.Creator<DrmInitData> CREATOR = new Parcelable.Creator<DrmInitData>() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public DrmInitData createFromParcel(Parcel parcel) {
+            return new DrmInitData(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public DrmInitData[] newArray(int i) {
+            return new DrmInitData[i];
+        }
+    };
+    private int hashCode;
+    public final int schemeDataCount;
+    private final SchemeData[] schemeDatas;
+
+    @Nullable
+    public final String schemeType;
+
+    @Override // android.os.Parcelable
+    public final int describeContents() {
+        return 0;
+    }
+
+    @Nullable
+    public static DrmInitData createSessionCreationData(@Nullable DrmInitData drmInitData, @Nullable DrmInitData drmInitData2) {
+        String str;
+        ArrayList arrayList = new ArrayList();
+        if (drmInitData != null) {
+            str = drmInitData.schemeType;
+            for (SchemeData schemeData : drmInitData.schemeDatas) {
+                if (schemeData.hasData()) {
+                    arrayList.add(schemeData);
+                }
+            }
+        } else {
+            str = null;
+        }
+        if (drmInitData2 != null) {
+            if (str == null) {
+                str = drmInitData2.schemeType;
+            }
+            int size = arrayList.size();
+            for (SchemeData schemeData2 : drmInitData2.schemeDatas) {
+                if (schemeData2.hasData() && !containsSchemeDataWithUuid(arrayList, size, schemeData2.uuid)) {
+                    arrayList.add(schemeData2);
+                }
+            }
+        }
+        if (arrayList.isEmpty()) {
+            return null;
+        }
+        return new DrmInitData(str, arrayList);
+    }
+
+    public DrmInitData(List<SchemeData> list) {
+        this(null, false, (SchemeData[]) list.toArray(new SchemeData[list.size()]));
+    }
+
+    public DrmInitData(String str, List<SchemeData> list) {
+        this(str, false, (SchemeData[]) list.toArray(new SchemeData[list.size()]));
+    }
+
+    public DrmInitData(SchemeData... schemeDataArr) {
+        this((String) null, schemeDataArr);
+    }
+
+    public DrmInitData(@Nullable String str, SchemeData... schemeDataArr) {
+        this(str, true, schemeDataArr);
+    }
+
+    private DrmInitData(@Nullable String str, boolean z, SchemeData... schemeDataArr) {
+        this.schemeType = str;
+        schemeDataArr = z ? (SchemeData[]) schemeDataArr.clone() : schemeDataArr;
+        Arrays.sort(schemeDataArr, this);
+        this.schemeDatas = schemeDataArr;
+        this.schemeDataCount = schemeDataArr.length;
+    }
+
+    public DrmInitData(Parcel parcel) {
+        this.schemeType = parcel.readString();
+        SchemeData[] schemeDataArr = (SchemeData[]) parcel.createTypedArray(SchemeData.CREATOR);
+        this.schemeDatas = schemeDataArr;
+        this.schemeDataCount = schemeDataArr.length;
+    }
+
+    @Deprecated
+    public final SchemeData get(UUID uuid) {
+        for (SchemeData schemeData : this.schemeDatas) {
+            if (schemeData.matches(uuid)) {
+                return schemeData;
+            }
+        }
+        return null;
+    }
+
+    public final SchemeData get(int i) {
+        return this.schemeDatas[i];
+    }
+
+    public final DrmInitData copyWithSchemeType(@Nullable String str) {
+        return Util.areEqual(this.schemeType, str) ? this : new DrmInitData(str, false, this.schemeDatas);
+    }
+
+    public final int hashCode() {
+        if (this.hashCode == 0) {
+            String str = this.schemeType;
+            this.hashCode = ((str == null ? 0 : str.hashCode()) * 31) + Arrays.hashCode(this.schemeDatas);
+        }
+        return this.hashCode;
+    }
+
+    @Override // java.util.Comparator
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || DrmInitData.class != obj.getClass()) {
+            return false;
+        }
+        DrmInitData drmInitData = (DrmInitData) obj;
+        return Util.areEqual(this.schemeType, drmInitData.schemeType) && Arrays.equals(this.schemeDatas, drmInitData.schemeDatas);
+    }
+
+    @Override // java.util.Comparator
+    public final int compare(SchemeData schemeData, SchemeData schemeData2) {
+        UUID uuid = C.UUID_NIL;
+        if (uuid.equals(schemeData.uuid)) {
+            return uuid.equals(schemeData2.uuid) ? 0 : 1;
+        }
+        return schemeData.uuid.compareTo(schemeData2.uuid);
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        parcel.writeString(this.schemeType);
+        parcel.writeTypedArray(this.schemeDatas, 0);
+    }
+
+    private static boolean containsSchemeDataWithUuid(ArrayList<SchemeData> arrayList, int i, UUID uuid) {
+        for (int i2 = 0; i2 < i; i2++) {
+            if (arrayList.get(i2).uuid.equals(uuid)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static final class SchemeData implements Parcelable {
+        public static final Parcelable.Creator<SchemeData> CREATOR = new Parcelable.Creator<SchemeData>() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData.SchemeData.1
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // android.os.Parcelable.Creator
+            public SchemeData createFromParcel(Parcel parcel) {
+                return new SchemeData(parcel);
+            }
+
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // android.os.Parcelable.Creator
+            public SchemeData[] newArray(int i) {
+                return new SchemeData[i];
+            }
+        };
+        public final byte[] data;
+        private int hashCode;
+
+        @Nullable
+        public final String licenseServerUrl;
+        public final String mimeType;
+        public final boolean requiresSecureDecryption;
+        private final UUID uuid;
+
+        @Override // android.os.Parcelable
+        public final int describeContents() {
+            return 0;
+        }
+
+        public final boolean hasData() {
+            return this.data != null;
+        }
+
+        public SchemeData(UUID uuid, String str, byte[] bArr) {
+            this(uuid, str, bArr, false);
+        }
+
+        public SchemeData(UUID uuid, String str, byte[] bArr, boolean z) {
+            this(uuid, null, str, bArr, z);
+        }
+
+        public SchemeData(UUID uuid, @Nullable String str, String str2, byte[] bArr, boolean z) {
+            this.uuid = (UUID) Assertions.checkNotNull(uuid);
+            this.licenseServerUrl = str;
+            this.mimeType = (String) Assertions.checkNotNull(str2);
+            this.data = bArr;
+            this.requiresSecureDecryption = z;
+        }
+
+        public SchemeData(Parcel parcel) {
+            this.uuid = new UUID(parcel.readLong(), parcel.readLong());
+            this.licenseServerUrl = parcel.readString();
+            this.mimeType = parcel.readString();
+            this.data = parcel.createByteArray();
+            this.requiresSecureDecryption = parcel.readByte() != 0;
+        }
+
+        public final boolean matches(UUID uuid) {
+            return C.UUID_NIL.equals(this.uuid) || uuid.equals(this.uuid);
+        }
+
+        public final boolean canReplace(SchemeData schemeData) {
+            return hasData() && !schemeData.hasData() && matches(schemeData.uuid);
+        }
+
+        public final boolean equals(@Nullable Object obj) {
+            if (!(obj instanceof SchemeData)) {
+                return false;
+            }
+            if (obj == this) {
+                return true;
+            }
+            SchemeData schemeData = (SchemeData) obj;
+            return Util.areEqual(this.licenseServerUrl, schemeData.licenseServerUrl) && Util.areEqual(this.mimeType, schemeData.mimeType) && Util.areEqual(this.uuid, schemeData.uuid) && Arrays.equals(this.data, schemeData.data);
+        }
+
+        public final int hashCode() {
+            if (this.hashCode == 0) {
+                int hashCode = this.uuid.hashCode() * 31;
+                String str = this.licenseServerUrl;
+                this.hashCode = ((((hashCode + (str == null ? 0 : str.hashCode())) * 31) + this.mimeType.hashCode()) * 31) + Arrays.hashCode(this.data);
+            }
+            return this.hashCode;
+        }
+
+        @Override // android.os.Parcelable
+        public final void writeToParcel(Parcel parcel, int i) {
+            parcel.writeLong(this.uuid.getMostSignificantBits());
+            parcel.writeLong(this.uuid.getLeastSignificantBits());
+            parcel.writeString(this.licenseServerUrl);
+            parcel.writeString(this.mimeType);
+            parcel.writeByteArray(this.data);
+            parcel.writeByte(this.requiresSecureDecryption ? (byte) 1 : (byte) 0);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DrmSession.java

@@ -0,0 +1,37 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.TargetApi;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Map;
+
+@TargetApi(16)
+/* loaded from: classes4.dex */
+public interface DrmSession<T extends ExoMediaCrypto> {
+    public static final int STATE_ERROR = 1;
+    public static final int STATE_OPENED = 3;
+    public static final int STATE_OPENED_WITH_KEYS = 4;
+    public static final int STATE_OPENING = 2;
+    public static final int STATE_RELEASED = 0;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface State {
+    }
+
+    DrmSessionException getError();
+
+    T getMediaCrypto();
+
+    byte[] getOfflineLicenseKeySetId();
+
+    int getState();
+
+    Map<String, String> queryKeyStatus();
+
+    public static class DrmSessionException extends Exception {
+        public DrmSessionException(Throwable th) {
+            super(th);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DrmSessionManager.java

@@ -0,0 +1,15 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.TargetApi;
+import android.os.Looper;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+
+@TargetApi(16)
+/* loaded from: classes4.dex */
+public interface DrmSessionManager<T extends ExoMediaCrypto> {
+    DrmSession<T> acquireSession(Looper looper, DrmInitData drmInitData);
+
+    boolean canAcquireSession(DrmInitData drmInitData);
+
+    void releaseSession(DrmSession<T> drmSession);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/ErrorStateDrmSession.java

@@ -0,0 +1,40 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public final class ErrorStateDrmSession<T extends ExoMediaCrypto> implements DrmSession<T> {
+    private final DrmSession.DrmSessionException error;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final DrmSession.DrmSessionException getError() {
+        return this.error;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final T getMediaCrypto() {
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final byte[] getOfflineLicenseKeySetId() {
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final int getState() {
+        return 1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final Map<String, String> queryKeyStatus() {
+        return null;
+    }
+
+    public ErrorStateDrmSession(DrmSession.DrmSessionException drmSessionException) {
+        this.error = (DrmSession.DrmSessionException) Assertions.checkNotNull(drmSessionException);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/ExoMediaCrypto.java

@@ -0,0 +1,6 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+/* loaded from: classes4.dex */
+public interface ExoMediaCrypto {
+    boolean requiresSecureDecoderComponent(String str);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/ExoMediaDrm.java

@@ -0,0 +1,139 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.media.DeniedByServerException;
+import android.media.MediaCryptoException;
+import android.media.MediaDrmException;
+import android.media.NotProvisionedException;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public interface ExoMediaDrm<T extends ExoMediaCrypto> {
+    public static final int EVENT_KEY_EXPIRED = 3;
+    public static final int EVENT_KEY_REQUIRED = 2;
+    public static final int EVENT_PROVISION_REQUIRED = 1;
+    public static final int KEY_TYPE_OFFLINE = 2;
+    public static final int KEY_TYPE_RELEASE = 3;
+    public static final int KEY_TYPE_STREAMING = 1;
+
+    public interface KeyRequest {
+        byte[] getData();
+
+        String getDefaultUrl();
+    }
+
+    public interface KeyStatus {
+        byte[] getKeyId();
+
+        int getStatusCode();
+    }
+
+    public interface OnEventListener<T extends ExoMediaCrypto> {
+        void onEvent(ExoMediaDrm<? extends T> exoMediaDrm, byte[] bArr, int i, int i2, @Nullable byte[] bArr2);
+    }
+
+    public interface OnKeyStatusChangeListener<T extends ExoMediaCrypto> {
+        void onKeyStatusChange(ExoMediaDrm<? extends T> exoMediaDrm, byte[] bArr, List<KeyStatus> list, boolean z);
+    }
+
+    public interface ProvisionRequest {
+        byte[] getData();
+
+        String getDefaultUrl();
+    }
+
+    void closeSession(byte[] bArr);
+
+    T createMediaCrypto(byte[] bArr) throws MediaCryptoException;
+
+    KeyRequest getKeyRequest(byte[] bArr, byte[] bArr2, String str, int i, HashMap<String, String> hashMap) throws NotProvisionedException;
+
+    byte[] getPropertyByteArray(String str);
+
+    String getPropertyString(String str);
+
+    ProvisionRequest getProvisionRequest();
+
+    byte[] openSession() throws MediaDrmException;
+
+    byte[] provideKeyResponse(byte[] bArr, byte[] bArr2) throws NotProvisionedException, DeniedByServerException;
+
+    void provideProvisionResponse(byte[] bArr) throws DeniedByServerException;
+
+    Map<String, String> queryKeyStatus(byte[] bArr);
+
+    void release();
+
+    void restoreKeys(byte[] bArr, byte[] bArr2);
+
+    void setOnEventListener(OnEventListener<? super T> onEventListener);
+
+    void setOnKeyStatusChangeListener(OnKeyStatusChangeListener<? super T> onKeyStatusChangeListener);
+
+    void setPropertyByteArray(String str, byte[] bArr);
+
+    void setPropertyString(String str, String str2);
+
+    public static final class DefaultKeyStatus implements KeyStatus {
+        private final byte[] keyId;
+        private final int statusCode;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.KeyStatus
+        public final byte[] getKeyId() {
+            return this.keyId;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.KeyStatus
+        public final int getStatusCode() {
+            return this.statusCode;
+        }
+
+        public DefaultKeyStatus(int i, byte[] bArr) {
+            this.statusCode = i;
+            this.keyId = bArr;
+        }
+    }
+
+    public static final class DefaultKeyRequest implements KeyRequest {
+        private final byte[] data;
+        private final String defaultUrl;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.KeyRequest
+        public final byte[] getData() {
+            return this.data;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.KeyRequest
+        public final String getDefaultUrl() {
+            return this.defaultUrl;
+        }
+
+        public DefaultKeyRequest(byte[] bArr, String str) {
+            this.data = bArr;
+            this.defaultUrl = str;
+        }
+    }
+
+    public static final class DefaultProvisionRequest implements ProvisionRequest {
+        private final byte[] data;
+        private final String defaultUrl;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.ProvisionRequest
+        public final byte[] getData() {
+            return this.data;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.ProvisionRequest
+        public final String getDefaultUrl() {
+            return this.defaultUrl;
+        }
+
+        public DefaultProvisionRequest(byte[] bArr, String str) {
+            this.data = bArr;
+            this.defaultUrl = str;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/FrameworkMediaCrypto.java

@@ -0,0 +1,30 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.TargetApi;
+import android.media.MediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+@TargetApi(16)
+/* loaded from: classes4.dex */
+public final class FrameworkMediaCrypto implements ExoMediaCrypto {
+    private final boolean forceAllowInsecureDecoderComponents;
+    private final MediaCrypto mediaCrypto;
+
+    public final MediaCrypto getWrappedMediaCrypto() {
+        return this.mediaCrypto;
+    }
+
+    public FrameworkMediaCrypto(MediaCrypto mediaCrypto) {
+        this(mediaCrypto, false);
+    }
+
+    public FrameworkMediaCrypto(MediaCrypto mediaCrypto, boolean z) {
+        this.mediaCrypto = (MediaCrypto) Assertions.checkNotNull(mediaCrypto);
+        this.forceAllowInsecureDecoderComponents = z;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto
+    public final boolean requiresSecureDecoderComponent(String str) {
+        return !this.forceAllowInsecureDecoderComponents && this.mediaCrypto.requiresSecureDecoderComponent(str);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/FrameworkMediaDrm.java

@@ -0,0 +1,243 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.media.DeniedByServerException;
+import android.media.MediaCrypto;
+import android.media.MediaCryptoException;
+import android.media.MediaDrm;
+import android.media.MediaDrmException;
+import android.media.NotProvisionedException;
+import android.media.UnsupportedSchemeException;
+import android.os.Handler;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+@TargetApi(23)
+/* loaded from: classes4.dex */
+public final class FrameworkMediaDrm implements ExoMediaDrm<FrameworkMediaCrypto> {
+    private static final String CENC_SCHEME_MIME_TYPE = "cenc";
+    private final MediaDrm mediaDrm;
+    private final UUID uuid;
+
+    public static FrameworkMediaDrm newInstance(UUID uuid) throws UnsupportedDrmException {
+        try {
+            return new FrameworkMediaDrm(uuid);
+        } catch (UnsupportedSchemeException e) {
+            throw new UnsupportedDrmException(1, e);
+        } catch (Exception e2) {
+            throw new UnsupportedDrmException(2, e2);
+        }
+    }
+
+    @SuppressLint({"WrongConstant"})
+    private FrameworkMediaDrm(UUID uuid) throws UnsupportedSchemeException {
+        Assertions.checkNotNull(uuid);
+        UUID uuid2 = C.COMMON_PSSH_UUID;
+        Assertions.checkArgument(!uuid2.equals(uuid), "Use C.CLEARKEY_UUID instead");
+        if (Util.SDK_INT < 27 && C.CLEARKEY_UUID.equals(uuid)) {
+            uuid = uuid2;
+        }
+        this.uuid = uuid;
+        MediaDrm mediaDrm = new MediaDrm(uuid);
+        this.mediaDrm = mediaDrm;
+        if (C.WIDEVINE_UUID.equals(uuid) && needsForceL3Workaround()) {
+            mediaDrm.setPropertyString("securityLevel", "L3");
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void setOnEventListener(final ExoMediaDrm.OnEventListener<? super FrameworkMediaCrypto> onEventListener) {
+        this.mediaDrm.setOnEventListener(onEventListener == null ? null : new MediaDrm.OnEventListener() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaDrm.1
+            @Override // android.media.MediaDrm.OnEventListener
+            public void onEvent(@NonNull MediaDrm mediaDrm, @Nullable byte[] bArr, int i, int i2, byte[] bArr2) {
+                onEventListener.onEvent(FrameworkMediaDrm.this, bArr, i, i2, bArr2);
+            }
+        });
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void setOnKeyStatusChangeListener(final ExoMediaDrm.OnKeyStatusChangeListener<? super FrameworkMediaCrypto> onKeyStatusChangeListener) {
+        if (Util.SDK_INT < 23) {
+            throw new UnsupportedOperationException();
+        }
+        this.mediaDrm.setOnKeyStatusChangeListener(onKeyStatusChangeListener == null ? null : new MediaDrm.OnKeyStatusChangeListener() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaDrm.2
+            @Override // android.media.MediaDrm.OnKeyStatusChangeListener
+            public void onKeyStatusChange(@NonNull MediaDrm mediaDrm, @NonNull byte[] bArr, @NonNull List<MediaDrm.KeyStatus> list, boolean z) {
+                ArrayList arrayList = new ArrayList();
+                for (MediaDrm.KeyStatus keyStatus : list) {
+                    arrayList.add(new ExoMediaDrm.DefaultKeyStatus(keyStatus.getStatusCode(), keyStatus.getKeyId()));
+                }
+                onKeyStatusChangeListener.onKeyStatusChange(FrameworkMediaDrm.this, bArr, arrayList, z);
+            }
+        }, (Handler) null);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final byte[] openSession() throws MediaDrmException {
+        return this.mediaDrm.openSession();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void closeSession(byte[] bArr) {
+        this.mediaDrm.closeSession(bArr);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:33:0x003c, code lost:
+    
+        if ("AFTM".equals(r1) == false) goto L20;
+     */
+    /* JADX WARN: Removed duplicated region for block: B:10:0x004e  */
+    /* JADX WARN: Removed duplicated region for block: B:19:0x0082  */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.KeyRequest getKeyRequest(byte[] r9, byte[] r10, java.lang.String r11, int r12, java.util.HashMap<java.lang.String, java.lang.String> r13) throws android.media.NotProvisionedException {
+        /*
+            r8 = this;
+            int r0 = com.mbridge.msdk.playercommon.exoplayer2.util.Util.SDK_INT
+            r1 = 21
+            if (r0 >= r1) goto L10
+            java.util.UUID r1 = com.mbridge.msdk.playercommon.exoplayer2.C.WIDEVINE_UUID
+            java.util.UUID r2 = r8.uuid
+            boolean r1 = r1.equals(r2)
+            if (r1 != 0) goto L3e
+        L10:
+            java.util.UUID r1 = com.mbridge.msdk.playercommon.exoplayer2.C.PLAYREADY_UUID
+            java.util.UUID r2 = r8.uuid
+            boolean r1 = r1.equals(r2)
+            if (r1 == 0) goto L49
+            java.lang.String r1 = "Amazon"
+            java.lang.String r2 = com.mbridge.msdk.playercommon.exoplayer2.util.Util.MANUFACTURER
+            boolean r1 = r1.equals(r2)
+            if (r1 == 0) goto L49
+            java.lang.String r1 = com.mbridge.msdk.playercommon.exoplayer2.util.Util.MODEL
+            java.lang.String r2 = "AFTB"
+            boolean r2 = r2.equals(r1)
+            if (r2 != 0) goto L3e
+            java.lang.String r2 = "AFTS"
+            boolean r2 = r2.equals(r1)
+            if (r2 != 0) goto L3e
+            java.lang.String r2 = "AFTM"
+            boolean r1 = r2.equals(r1)
+            if (r1 == 0) goto L49
+        L3e:
+            java.util.UUID r1 = r8.uuid
+            byte[] r1 = com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.PsshAtomUtil.parseSchemeSpecificData(r10, r1)
+            if (r1 != 0) goto L47
+            goto L49
+        L47:
+            r4 = r1
+            goto L4a
+        L49:
+            r4 = r10
+        L4a:
+            r10 = 26
+            if (r0 >= r10) goto L6a
+            java.util.UUID r10 = com.mbridge.msdk.playercommon.exoplayer2.C.CLEARKEY_UUID
+            java.util.UUID r0 = r8.uuid
+            boolean r10 = r10.equals(r0)
+            if (r10 == 0) goto L6a
+            java.lang.String r10 = "video/mp4"
+            boolean r10 = r10.equals(r11)
+            if (r10 != 0) goto L68
+            java.lang.String r10 = "audio/mp4"
+            boolean r10 = r10.equals(r11)
+            if (r10 == 0) goto L6a
+        L68:
+            java.lang.String r11 = "cenc"
+        L6a:
+            r5 = r11
+            android.media.MediaDrm r2 = r8.mediaDrm
+            r3 = r9
+            r6 = r12
+            r7 = r13
+            android.media.MediaDrm$KeyRequest r9 = r2.getKeyRequest(r3, r4, r5, r6, r7)
+            byte[] r10 = r9.getData()
+            java.util.UUID r11 = com.mbridge.msdk.playercommon.exoplayer2.C.CLEARKEY_UUID
+            java.util.UUID r12 = r8.uuid
+            boolean r11 = r11.equals(r12)
+            if (r11 == 0) goto L86
+            byte[] r10 = com.mbridge.msdk.playercommon.exoplayer2.drm.ClearKeyUtil.adjustRequestData(r10)
+        L86:
+            com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm$DefaultKeyRequest r11 = new com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm$DefaultKeyRequest
+            java.lang.String r9 = r9.getDefaultUrl()
+            r11.<init>(r10, r9)
+            return r11
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaDrm.getKeyRequest(byte[], byte[], java.lang.String, int, java.util.HashMap):com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm$KeyRequest");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final byte[] provideKeyResponse(byte[] bArr, byte[] bArr2) throws NotProvisionedException, DeniedByServerException {
+        if (C.CLEARKEY_UUID.equals(this.uuid)) {
+            bArr2 = ClearKeyUtil.adjustResponseData(bArr2);
+        }
+        return this.mediaDrm.provideKeyResponse(bArr, bArr2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final ExoMediaDrm.ProvisionRequest getProvisionRequest() {
+        MediaDrm.ProvisionRequest provisionRequest = this.mediaDrm.getProvisionRequest();
+        return new ExoMediaDrm.DefaultProvisionRequest(provisionRequest.getData(), provisionRequest.getDefaultUrl());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void provideProvisionResponse(byte[] bArr) throws DeniedByServerException {
+        this.mediaDrm.provideProvisionResponse(bArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final Map<String, String> queryKeyStatus(byte[] bArr) {
+        return this.mediaDrm.queryKeyStatus(bArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void release() {
+        this.mediaDrm.release();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void restoreKeys(byte[] bArr, byte[] bArr2) {
+        this.mediaDrm.restoreKeys(bArr, bArr2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final String getPropertyString(String str) {
+        return this.mediaDrm.getPropertyString(str);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final byte[] getPropertyByteArray(String str) {
+        return this.mediaDrm.getPropertyByteArray(str);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void setPropertyString(String str, String str2) {
+        this.mediaDrm.setPropertyString(str, str2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void setPropertyByteArray(String str, byte[] bArr) {
+        this.mediaDrm.setPropertyByteArray(str, bArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final FrameworkMediaCrypto createMediaCrypto(byte[] bArr) throws MediaCryptoException {
+        return new FrameworkMediaCrypto(new MediaCrypto(this.uuid, bArr), Util.SDK_INT < 21 && C.WIDEVINE_UUID.equals(this.uuid) && "L3".equals(getPropertyString("securityLevel")));
+    }
+
+    private static boolean needsForceL3Workaround() {
+        return "ASUS_Z00AD".equals(Util.MODEL);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/HttpMediaDrmCallback.java

@@ -0,0 +1,189 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.TargetApi;
+import android.text.TextUtils;
+import androidx.annotation.Nullable;
+import com.ironsource.nb;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+@TargetApi(18)
+/* loaded from: classes4.dex */
+public final class HttpMediaDrmCallback implements MediaDrmCallback {
+    private static final int MAX_MANUAL_REDIRECTS = 5;
+    private final HttpDataSource.Factory dataSourceFactory;
+    private final String defaultLicenseUrl;
+    private final boolean forceDefaultLicenseUrl;
+    private final Map<String, String> keyRequestProperties;
+
+    public HttpMediaDrmCallback(String str, HttpDataSource.Factory factory) {
+        this(str, false, factory);
+    }
+
+    public HttpMediaDrmCallback(String str, boolean z, HttpDataSource.Factory factory) {
+        this.dataSourceFactory = factory;
+        this.defaultLicenseUrl = str;
+        this.forceDefaultLicenseUrl = z;
+        this.keyRequestProperties = new HashMap();
+    }
+
+    public final void setKeyRequestProperty(String str, String str2) {
+        Assertions.checkNotNull(str);
+        Assertions.checkNotNull(str2);
+        synchronized (this.keyRequestProperties) {
+            this.keyRequestProperties.put(str, str2);
+        }
+    }
+
+    public final void clearKeyRequestProperty(String str) {
+        Assertions.checkNotNull(str);
+        synchronized (this.keyRequestProperties) {
+            this.keyRequestProperties.remove(str);
+        }
+    }
+
+    public final void clearAllKeyRequestProperties() {
+        synchronized (this.keyRequestProperties) {
+            this.keyRequestProperties.clear();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.MediaDrmCallback
+    public final byte[] executeProvisionRequest(UUID uuid, ExoMediaDrm.ProvisionRequest provisionRequest) throws IOException {
+        return executePost(this.dataSourceFactory, provisionRequest.getDefaultUrl() + "&signedRequest=" + Util.fromUtf8Bytes(provisionRequest.getData()), new byte[0], null);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.MediaDrmCallback
+    public final byte[] executeKeyRequest(UUID uuid, ExoMediaDrm.KeyRequest keyRequest, @Nullable String str) throws Exception {
+        String str2;
+        String defaultUrl = keyRequest.getDefaultUrl();
+        if (!TextUtils.isEmpty(defaultUrl)) {
+            str = defaultUrl;
+        }
+        if (this.forceDefaultLicenseUrl || TextUtils.isEmpty(str)) {
+            str = this.defaultLicenseUrl;
+        }
+        HashMap hashMap = new HashMap();
+        UUID uuid2 = C.PLAYREADY_UUID;
+        if (uuid2.equals(uuid)) {
+            str2 = "text/xml";
+        } else {
+            str2 = C.CLEARKEY_UUID.equals(uuid) ? nb.L : "application/octet-stream";
+        }
+        hashMap.put("Content-Type", str2);
+        if (uuid2.equals(uuid)) {
+            hashMap.put("SOAPAction", "http://schemas.microsoft.com/DRM/2007/03/protocols/AcquireLicense");
+        }
+        synchronized (this.keyRequestProperties) {
+            hashMap.putAll(this.keyRequestProperties);
+        }
+        return executePost(this.dataSourceFactory, str, keyRequest.getData(), hashMap);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:25:0x006b A[Catch: all -> 0x004f, TRY_LEAVE, TryCatch #1 {all -> 0x004f, blocks: (B:11:0x0047, B:19:0x0053, B:21:0x0059, B:25:0x006b, B:29:0x007c, B:32:0x005f), top: B:10:0x0047, inners: #0 }] */
+    /* JADX WARN: Removed duplicated region for block: B:27:0x0073 A[LOOP:1: B:9:0x002e->B:27:0x0073, LOOP_END] */
+    /* JADX WARN: Removed duplicated region for block: B:28:0x007c A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:31:0x0070  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static byte[] executePost(com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource.Factory r17, java.lang.String r18, byte[] r19, java.util.Map<java.lang.String, java.lang.String> r20) throws java.io.IOException {
+        /*
+            com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource r1 = r17.createDataSource()
+            if (r20 == 0) goto L2a
+            java.util.Set r0 = r20.entrySet()
+            java.util.Iterator r0 = r0.iterator()
+        Le:
+            boolean r2 = r0.hasNext()
+            if (r2 == 0) goto L2a
+            java.lang.Object r2 = r0.next()
+            java.util.Map$Entry r2 = (java.util.Map.Entry) r2
+            java.lang.Object r3 = r2.getKey()
+            java.lang.String r3 = (java.lang.String) r3
+            java.lang.Object r2 = r2.getValue()
+            java.lang.String r2 = (java.lang.String) r2
+            r1.setRequestProperty(r3, r2)
+            goto Le
+        L2a:
+            r2 = 0
+            r0 = r18
+            r3 = r2
+        L2e:
+            com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec r15 = new com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec
+            android.net.Uri r5 = android.net.Uri.parse(r0)
+            r7 = 0
+            r9 = 0
+            r11 = -1
+            r13 = 0
+            r14 = 1
+            r4 = r15
+            r6 = r19
+            r4.<init>(r5, r6, r7, r9, r11, r13, r14)
+            com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSourceInputStream r4 = new com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSourceInputStream
+            r4.<init>(r1, r15)
+            byte[] r0 = com.mbridge.msdk.playercommon.exoplayer2.util.Util.toByteArray(r4)     // Catch: java.lang.Throwable -> L4f com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource.InvalidResponseCodeException -> L51
+            com.mbridge.msdk.playercommon.exoplayer2.util.Util.closeQuietly(r4)
+            return r0
+        L4f:
+            r0 = move-exception
+            goto L7d
+        L51:
+            r0 = move-exception
+            r5 = r0
+            int r0 = r5.responseCode     // Catch: java.lang.Throwable -> L4f
+            r6 = 307(0x133, float:4.3E-43)
+            if (r0 == r6) goto L5f
+            int r0 = r5.responseCode     // Catch: java.lang.Throwable -> L4f
+            r6 = 308(0x134, float:4.32E-43)
+            if (r0 != r6) goto L67
+        L5f:
+            int r0 = r3 + 1
+            r6 = 5
+            if (r3 >= r6) goto L66
+            r3 = 1
+            goto L69
+        L66:
+            r3 = r0
+        L67:
+            r0 = r3
+            r3 = r2
+        L69:
+            if (r3 == 0) goto L70
+            java.lang.String r3 = getRedirectUrl(r5)     // Catch: java.lang.Throwable -> L4f
+            goto L71
+        L70:
+            r3 = 0
+        L71:
+            if (r3 == 0) goto L7c
+            com.mbridge.msdk.playercommon.exoplayer2.util.Util.closeQuietly(r4)
+            r16 = r3
+            r3 = r0
+            r0 = r16
+            goto L2e
+        L7c:
+            throw r5     // Catch: java.lang.Throwable -> L4f
+        L7d:
+            com.mbridge.msdk.playercommon.exoplayer2.util.Util.closeQuietly(r4)
+            throw r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.drm.HttpMediaDrmCallback.executePost(com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource$Factory, java.lang.String, byte[], java.util.Map):byte[]");
+    }
+
+    private static String getRedirectUrl(HttpDataSource.InvalidResponseCodeException invalidResponseCodeException) {
+        List<String> list;
+        Map<String, List<String>> map = invalidResponseCodeException.headerFields;
+        if (map == null || (list = map.get("Location")) == null || list.isEmpty()) {
+            return null;
+        }
+        return list.get(0);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/KeysExpiredException.java

@@ -0,0 +1,5 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+/* loaded from: classes4.dex */
+public final class KeysExpiredException extends Exception {
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/LocalMediaDrmCallback.java

@@ -0,0 +1,26 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.io.IOException;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public final class LocalMediaDrmCallback implements MediaDrmCallback {
+    private final byte[] keyResponse;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.MediaDrmCallback
+    public final byte[] executeKeyRequest(UUID uuid, ExoMediaDrm.KeyRequest keyRequest, @Nullable String str) throws Exception {
+        return this.keyResponse;
+    }
+
+    public LocalMediaDrmCallback(byte[] bArr) {
+        this.keyResponse = (byte[]) Assertions.checkNotNull(bArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.MediaDrmCallback
+    public final byte[] executeProvisionRequest(UUID uuid, ExoMediaDrm.ProvisionRequest provisionRequest) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/MediaDrmCallback.java

@@ -0,0 +1,12 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public interface MediaDrmCallback {
+    byte[] executeKeyRequest(UUID uuid, ExoMediaDrm.KeyRequest keyRequest, @Nullable String str) throws Exception;
+
+    byte[] executeProvisionRequest(UUID uuid, ExoMediaDrm.ProvisionRequest provisionRequest) throws Exception;
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/OfflineLicenseHelper.java

@@ -0,0 +1,133 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.os.ConditionVariable;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Pair;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.HashMap;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public final class OfflineLicenseHelper<T extends ExoMediaCrypto> {
+    private final ConditionVariable conditionVariable;
+    private final DefaultDrmSessionManager<T> drmSessionManager;
+    private final HandlerThread handlerThread;
+
+    public static OfflineLicenseHelper<FrameworkMediaCrypto> newWidevineInstance(String str, HttpDataSource.Factory factory) throws UnsupportedDrmException {
+        return newWidevineInstance(str, false, factory, null);
+    }
+
+    public static OfflineLicenseHelper<FrameworkMediaCrypto> newWidevineInstance(String str, boolean z, HttpDataSource.Factory factory) throws UnsupportedDrmException {
+        return newWidevineInstance(str, z, factory, null);
+    }
+
+    public static OfflineLicenseHelper<FrameworkMediaCrypto> newWidevineInstance(String str, boolean z, HttpDataSource.Factory factory, HashMap<String, String> hashMap) throws UnsupportedDrmException {
+        UUID uuid = C.WIDEVINE_UUID;
+        return new OfflineLicenseHelper<>(uuid, FrameworkMediaDrm.newInstance(uuid), new HttpMediaDrmCallback(str, z, factory), hashMap);
+    }
+
+    public OfflineLicenseHelper(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap) {
+        HandlerThread handlerThread = new HandlerThread("OfflineLicenseHelper");
+        this.handlerThread = handlerThread;
+        handlerThread.start();
+        this.conditionVariable = new ConditionVariable();
+        DefaultDrmSessionEventListener defaultDrmSessionEventListener = new DefaultDrmSessionEventListener() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.OfflineLicenseHelper.1
+            @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+            public void onDrmKeysLoaded() {
+                OfflineLicenseHelper.this.conditionVariable.open();
+            }
+
+            @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+            public void onDrmSessionManagerError(Exception exc) {
+                OfflineLicenseHelper.this.conditionVariable.open();
+            }
+
+            @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+            public void onDrmKeysRestored() {
+                OfflineLicenseHelper.this.conditionVariable.open();
+            }
+
+            @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+            public void onDrmKeysRemoved() {
+                OfflineLicenseHelper.this.conditionVariable.open();
+            }
+        };
+        DefaultDrmSessionManager<T> defaultDrmSessionManager = new DefaultDrmSessionManager<>(uuid, exoMediaDrm, mediaDrmCallback, hashMap);
+        this.drmSessionManager = defaultDrmSessionManager;
+        defaultDrmSessionManager.addListener(new Handler(handlerThread.getLooper()), defaultDrmSessionEventListener);
+    }
+
+    public final synchronized byte[] getPropertyByteArray(String str) {
+        return this.drmSessionManager.getPropertyByteArray(str);
+    }
+
+    public final synchronized void setPropertyByteArray(String str, byte[] bArr) {
+        this.drmSessionManager.setPropertyByteArray(str, bArr);
+    }
+
+    public final synchronized String getPropertyString(String str) {
+        return this.drmSessionManager.getPropertyString(str);
+    }
+
+    public final synchronized void setPropertyString(String str, String str2) {
+        this.drmSessionManager.setPropertyString(str, str2);
+    }
+
+    public final synchronized byte[] downloadLicense(DrmInitData drmInitData) throws DrmSession.DrmSessionException {
+        Assertions.checkArgument(drmInitData != null);
+        return blockingKeyRequest(2, null, drmInitData);
+    }
+
+    public final synchronized byte[] renewLicense(byte[] bArr) throws DrmSession.DrmSessionException {
+        Assertions.checkNotNull(bArr);
+        return blockingKeyRequest(2, bArr, null);
+    }
+
+    public final synchronized void releaseLicense(byte[] bArr) throws DrmSession.DrmSessionException {
+        Assertions.checkNotNull(bArr);
+        blockingKeyRequest(3, bArr, null);
+    }
+
+    public final synchronized Pair<Long, Long> getLicenseDurationRemainingSec(byte[] bArr) throws DrmSession.DrmSessionException {
+        Assertions.checkNotNull(bArr);
+        DrmSession<T> openBlockingKeyRequest = openBlockingKeyRequest(1, bArr, null);
+        DrmSession.DrmSessionException error = openBlockingKeyRequest.getError();
+        Pair<Long, Long> licenseDurationRemainingSec = WidevineUtil.getLicenseDurationRemainingSec(openBlockingKeyRequest);
+        this.drmSessionManager.releaseSession(openBlockingKeyRequest);
+        if (error == null) {
+            return licenseDurationRemainingSec;
+        }
+        if (error.getCause() instanceof KeysExpiredException) {
+            return Pair.create(0L, 0L);
+        }
+        throw error;
+    }
+
+    public final void release() {
+        this.handlerThread.quit();
+    }
+
+    private byte[] blockingKeyRequest(int i, byte[] bArr, DrmInitData drmInitData) throws DrmSession.DrmSessionException {
+        DrmSession<T> openBlockingKeyRequest = openBlockingKeyRequest(i, bArr, drmInitData);
+        DrmSession.DrmSessionException error = openBlockingKeyRequest.getError();
+        byte[] offlineLicenseKeySetId = openBlockingKeyRequest.getOfflineLicenseKeySetId();
+        this.drmSessionManager.releaseSession(openBlockingKeyRequest);
+        if (error == null) {
+            return offlineLicenseKeySetId;
+        }
+        throw error;
+    }
+
+    private DrmSession<T> openBlockingKeyRequest(int i, byte[] bArr, DrmInitData drmInitData) {
+        this.drmSessionManager.setMode(i, bArr);
+        this.conditionVariable.close();
+        DrmSession<T> acquireSession = this.drmSessionManager.acquireSession(this.handlerThread.getLooper(), drmInitData);
+        this.conditionVariable.block();
+        return acquireSession;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/UnsupportedDrmException.java

@@ -0,0 +1,24 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public final class UnsupportedDrmException extends Exception {
+    public static final int REASON_INSTANTIATION_ERROR = 2;
+    public static final int REASON_UNSUPPORTED_SCHEME = 1;
+    public final int reason;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Reason {
+    }
+
+    public UnsupportedDrmException(int i) {
+        this.reason = i;
+    }
+
+    public UnsupportedDrmException(int i, Exception exc) {
+        super(exc);
+        this.reason = i;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/WidevineUtil.java

@@ -0,0 +1,34 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.util.Pair;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public final class WidevineUtil {
+    public static final String PROPERTY_LICENSE_DURATION_REMAINING = "LicenseDurationRemaining";
+    public static final String PROPERTY_PLAYBACK_DURATION_REMAINING = "PlaybackDurationRemaining";
+
+    private WidevineUtil() {
+    }
+
+    public static Pair<Long, Long> getLicenseDurationRemainingSec(DrmSession<?> drmSession) {
+        Map<String, String> queryKeyStatus = drmSession.queryKeyStatus();
+        if (queryKeyStatus == null) {
+            return null;
+        }
+        return new Pair<>(Long.valueOf(getDurationRemainingSec(queryKeyStatus, PROPERTY_LICENSE_DURATION_REMAINING)), Long.valueOf(getDurationRemainingSec(queryKeyStatus, PROPERTY_PLAYBACK_DURATION_REMAINING)));
+    }
+
+    private static long getDurationRemainingSec(Map<String, String> map, String str) {
+        if (map == null) {
+            return C.TIME_UNSET;
+        }
+        try {
+            String str2 = map.get(str);
+            return str2 != null ? Long.parseLong(str2) : C.TIME_UNSET;
+        } catch (NumberFormatException unused) {
+            return C.TIME_UNSET;
+        }
+    }
+}