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/source/ads/AdPlaybackState.java

@@ -0,0 +1,281 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.ads;
+
+import android.net.Uri;
+import androidx.annotation.CheckResult;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class AdPlaybackState {
+    public static final int AD_STATE_AVAILABLE = 1;
+    public static final int AD_STATE_ERROR = 4;
+    public static final int AD_STATE_PLAYED = 3;
+    public static final int AD_STATE_SKIPPED = 2;
+    public static final int AD_STATE_UNAVAILABLE = 0;
+    public static final AdPlaybackState NONE = new AdPlaybackState(new long[0]);
+    public final int adGroupCount;
+    public final long[] adGroupTimesUs;
+    public final AdGroup[] adGroups;
+    public final long adResumePositionUs;
+    public final long contentDurationUs;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface AdState {
+    }
+
+    public static final class AdGroup {
+        public final int count;
+        public final long[] durationsUs;
+        public final int[] states;
+        public final Uri[] uris;
+
+        public AdGroup() {
+            this(-1, new int[0], new Uri[0], new long[0]);
+        }
+
+        private AdGroup(int i, int[] iArr, Uri[] uriArr, long[] jArr) {
+            Assertions.checkArgument(iArr.length == uriArr.length);
+            this.count = i;
+            this.states = iArr;
+            this.uris = uriArr;
+            this.durationsUs = jArr;
+        }
+
+        public final int getFirstAdIndexToPlay() {
+            return getNextAdIndexToPlay(-1);
+        }
+
+        public final int getNextAdIndexToPlay(int i) {
+            int i2;
+            int i3 = i + 1;
+            while (true) {
+                int[] iArr = this.states;
+                if (i3 >= iArr.length || (i2 = iArr[i3]) == 0 || i2 == 1) {
+                    break;
+                }
+                i3++;
+            }
+            return i3;
+        }
+
+        public final boolean hasUnplayedAds() {
+            return this.count == -1 || getFirstAdIndexToPlay() < this.count;
+        }
+
+        @CheckResult
+        public final AdGroup withAdCount(int i) {
+            Assertions.checkArgument(this.count == -1 && this.states.length <= i);
+            return new AdGroup(i, copyStatesWithSpaceForAdCount(this.states, i), (Uri[]) Arrays.copyOf(this.uris, i), copyDurationsUsWithSpaceForAdCount(this.durationsUs, i));
+        }
+
+        @CheckResult
+        public final AdGroup withAdUri(Uri uri, int i) {
+            int i2 = this.count;
+            Assertions.checkArgument(i2 == -1 || i < i2);
+            int[] copyStatesWithSpaceForAdCount = copyStatesWithSpaceForAdCount(this.states, i + 1);
+            Assertions.checkArgument(copyStatesWithSpaceForAdCount[i] == 0);
+            long[] jArr = this.durationsUs;
+            if (jArr.length != copyStatesWithSpaceForAdCount.length) {
+                jArr = copyDurationsUsWithSpaceForAdCount(jArr, copyStatesWithSpaceForAdCount.length);
+            }
+            Uri[] uriArr = (Uri[]) Arrays.copyOf(this.uris, copyStatesWithSpaceForAdCount.length);
+            uriArr[i] = uri;
+            copyStatesWithSpaceForAdCount[i] = 1;
+            return new AdGroup(this.count, copyStatesWithSpaceForAdCount, uriArr, jArr);
+        }
+
+        @CheckResult
+        public final AdGroup withAdState(int i, int i2) {
+            int i3 = this.count;
+            Assertions.checkArgument(i3 == -1 || i2 < i3);
+            int[] copyStatesWithSpaceForAdCount = copyStatesWithSpaceForAdCount(this.states, i2 + 1);
+            int i4 = copyStatesWithSpaceForAdCount[i2];
+            Assertions.checkArgument(i4 == 0 || i4 == 1 || i4 == i);
+            long[] jArr = this.durationsUs;
+            if (jArr.length != copyStatesWithSpaceForAdCount.length) {
+                jArr = copyDurationsUsWithSpaceForAdCount(jArr, copyStatesWithSpaceForAdCount.length);
+            }
+            Uri[] uriArr = this.uris;
+            if (uriArr.length != copyStatesWithSpaceForAdCount.length) {
+                uriArr = (Uri[]) Arrays.copyOf(uriArr, copyStatesWithSpaceForAdCount.length);
+            }
+            copyStatesWithSpaceForAdCount[i2] = i;
+            return new AdGroup(this.count, copyStatesWithSpaceForAdCount, uriArr, jArr);
+        }
+
+        @CheckResult
+        public final AdGroup withAdDurationsUs(long[] jArr) {
+            Assertions.checkArgument(this.count == -1 || jArr.length <= this.uris.length);
+            int length = jArr.length;
+            Uri[] uriArr = this.uris;
+            if (length < uriArr.length) {
+                jArr = copyDurationsUsWithSpaceForAdCount(jArr, uriArr.length);
+            }
+            return new AdGroup(this.count, this.states, this.uris, jArr);
+        }
+
+        @CheckResult
+        public final AdGroup withAllAdsSkipped() {
+            if (this.count == -1) {
+                return new AdGroup(0, new int[0], new Uri[0], new long[0]);
+            }
+            int[] iArr = this.states;
+            int length = iArr.length;
+            int[] copyOf = Arrays.copyOf(iArr, length);
+            for (int i = 0; i < length; i++) {
+                int i2 = copyOf[i];
+                if (i2 == 1 || i2 == 0) {
+                    copyOf[i] = 2;
+                }
+            }
+            return new AdGroup(length, copyOf, this.uris, this.durationsUs);
+        }
+
+        @CheckResult
+        private static int[] copyStatesWithSpaceForAdCount(int[] iArr, int i) {
+            int length = iArr.length;
+            int max = Math.max(i, length);
+            int[] copyOf = Arrays.copyOf(iArr, max);
+            Arrays.fill(copyOf, length, max, 0);
+            return copyOf;
+        }
+
+        @CheckResult
+        private static long[] copyDurationsUsWithSpaceForAdCount(long[] jArr, int i) {
+            int length = jArr.length;
+            int max = Math.max(i, length);
+            long[] copyOf = Arrays.copyOf(jArr, max);
+            Arrays.fill(copyOf, length, max, C.TIME_UNSET);
+            return copyOf;
+        }
+    }
+
+    public AdPlaybackState(long... jArr) {
+        int length = jArr.length;
+        this.adGroupCount = length;
+        this.adGroupTimesUs = Arrays.copyOf(jArr, length);
+        this.adGroups = new AdGroup[length];
+        for (int i = 0; i < length; i++) {
+            this.adGroups[i] = new AdGroup();
+        }
+        this.adResumePositionUs = 0L;
+        this.contentDurationUs = C.TIME_UNSET;
+    }
+
+    private AdPlaybackState(long[] jArr, AdGroup[] adGroupArr, long j, long j2) {
+        this.adGroupCount = adGroupArr.length;
+        this.adGroupTimesUs = jArr;
+        this.adGroups = adGroupArr;
+        this.adResumePositionUs = j;
+        this.contentDurationUs = j2;
+    }
+
+    public final int getAdGroupIndexForPositionUs(long j) {
+        int length = this.adGroupTimesUs.length - 1;
+        while (length >= 0) {
+            long j2 = this.adGroupTimesUs[length];
+            if (j2 != Long.MIN_VALUE && j2 <= j) {
+                break;
+            }
+            length--;
+        }
+        if (length < 0 || !this.adGroups[length].hasUnplayedAds()) {
+            return -1;
+        }
+        return length;
+    }
+
+    public final int getAdGroupIndexAfterPositionUs(long j) {
+        int i = 0;
+        while (true) {
+            long[] jArr = this.adGroupTimesUs;
+            if (i >= jArr.length) {
+                break;
+            }
+            long j2 = jArr[i];
+            if (j2 == Long.MIN_VALUE || (j < j2 && this.adGroups[i].hasUnplayedAds())) {
+                break;
+            }
+            i++;
+        }
+        if (i < this.adGroupTimesUs.length) {
+            return i;
+        }
+        return -1;
+    }
+
+    @CheckResult
+    public final AdPlaybackState withAdCount(int i, int i2) {
+        Assertions.checkArgument(i2 > 0);
+        AdGroup[] adGroupArr = this.adGroups;
+        if (adGroupArr[i].count == i2) {
+            return this;
+        }
+        AdGroup[] adGroupArr2 = (AdGroup[]) Arrays.copyOf(adGroupArr, adGroupArr.length);
+        adGroupArr2[i] = this.adGroups[i].withAdCount(i2);
+        return new AdPlaybackState(this.adGroupTimesUs, adGroupArr2, this.adResumePositionUs, this.contentDurationUs);
+    }
+
+    @CheckResult
+    public final AdPlaybackState withAdUri(int i, int i2, Uri uri) {
+        AdGroup[] adGroupArr = this.adGroups;
+        AdGroup[] adGroupArr2 = (AdGroup[]) Arrays.copyOf(adGroupArr, adGroupArr.length);
+        adGroupArr2[i] = adGroupArr2[i].withAdUri(uri, i2);
+        return new AdPlaybackState(this.adGroupTimesUs, adGroupArr2, this.adResumePositionUs, this.contentDurationUs);
+    }
+
+    @CheckResult
+    public final AdPlaybackState withPlayedAd(int i, int i2) {
+        AdGroup[] adGroupArr = this.adGroups;
+        AdGroup[] adGroupArr2 = (AdGroup[]) Arrays.copyOf(adGroupArr, adGroupArr.length);
+        adGroupArr2[i] = adGroupArr2[i].withAdState(3, i2);
+        return new AdPlaybackState(this.adGroupTimesUs, adGroupArr2, this.adResumePositionUs, this.contentDurationUs);
+    }
+
+    @CheckResult
+    public final AdPlaybackState withSkippedAd(int i, int i2) {
+        AdGroup[] adGroupArr = this.adGroups;
+        AdGroup[] adGroupArr2 = (AdGroup[]) Arrays.copyOf(adGroupArr, adGroupArr.length);
+        adGroupArr2[i] = adGroupArr2[i].withAdState(2, i2);
+        return new AdPlaybackState(this.adGroupTimesUs, adGroupArr2, this.adResumePositionUs, this.contentDurationUs);
+    }
+
+    @CheckResult
+    public final AdPlaybackState withAdLoadError(int i, int i2) {
+        AdGroup[] adGroupArr = this.adGroups;
+        AdGroup[] adGroupArr2 = (AdGroup[]) Arrays.copyOf(adGroupArr, adGroupArr.length);
+        adGroupArr2[i] = adGroupArr2[i].withAdState(4, i2);
+        return new AdPlaybackState(this.adGroupTimesUs, adGroupArr2, this.adResumePositionUs, this.contentDurationUs);
+    }
+
+    @CheckResult
+    public final AdPlaybackState withSkippedAdGroup(int i) {
+        AdGroup[] adGroupArr = this.adGroups;
+        AdGroup[] adGroupArr2 = (AdGroup[]) Arrays.copyOf(adGroupArr, adGroupArr.length);
+        adGroupArr2[i] = adGroupArr2[i].withAllAdsSkipped();
+        return new AdPlaybackState(this.adGroupTimesUs, adGroupArr2, this.adResumePositionUs, this.contentDurationUs);
+    }
+
+    @CheckResult
+    public final AdPlaybackState withAdDurationsUs(long[][] jArr) {
+        AdGroup[] adGroupArr = this.adGroups;
+        AdGroup[] adGroupArr2 = (AdGroup[]) Arrays.copyOf(adGroupArr, adGroupArr.length);
+        for (int i = 0; i < this.adGroupCount; i++) {
+            adGroupArr2[i] = adGroupArr2[i].withAdDurationsUs(jArr[i]);
+        }
+        return new AdPlaybackState(this.adGroupTimesUs, adGroupArr2, this.adResumePositionUs, this.contentDurationUs);
+    }
+
+    @CheckResult
+    public final AdPlaybackState withAdResumePositionUs(long j) {
+        return this.adResumePositionUs == j ? this : new AdPlaybackState(this.adGroupTimesUs, this.adGroups, j, this.contentDurationUs);
+    }
+
+    @CheckResult
+    public final AdPlaybackState withContentDurationUs(long j) {
+        return this.contentDurationUs == j ? this : new AdPlaybackState(this.adGroupTimesUs, this.adGroups, this.adResumePositionUs, j);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/ads/AdsLoader.java

@@ -0,0 +1,31 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.ads;
+
+import android.view.ViewGroup;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer;
+import com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsMediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface AdsLoader {
+
+    public interface EventListener {
+        void onAdClicked();
+
+        void onAdLoadError(AdsMediaSource.AdLoadException adLoadException, DataSpec dataSpec);
+
+        void onAdPlaybackState(AdPlaybackState adPlaybackState);
+
+        void onAdTapped();
+    }
+
+    void attachPlayer(ExoPlayer exoPlayer, EventListener eventListener, ViewGroup viewGroup);
+
+    void detachPlayer();
+
+    void handlePrepareError(int i, int i2, IOException iOException);
+
+    void release();
+
+    void setSupportedContentTypes(int... iArr);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/ads/AdsMediaSource.java

@@ -0,0 +1,384 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.ads;
+
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.ViewGroup;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer;
+import com.mbridge.msdk.playercommon.exoplayer2.Timeline;
+import com.mbridge.msdk.playercommon.exoplayer2.source.CompositeMediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.DeferredMediaPeriod;
+import com.mbridge.msdk.playercommon.exoplayer2.source.ExtractorMediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaPeriod;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsLoader;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.Allocator;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public final class AdsMediaSource extends CompositeMediaSource<MediaSource.MediaPeriodId> {
+    private static final String TAG = "AdsMediaSource";
+    private long[][] adDurationsUs;
+    private MediaSource[][] adGroupMediaSources;
+    private final MediaSourceFactory adMediaSourceFactory;
+    private AdPlaybackState adPlaybackState;
+    private final ViewGroup adUiViewGroup;
+    private final AdsLoader adsLoader;
+    private ComponentListener componentListener;
+    private Object contentManifest;
+    private final MediaSource contentMediaSource;
+    private Timeline contentTimeline;
+    private final Map<MediaSource, List<DeferredMediaPeriod>> deferredMediaPeriodByAdMediaSource;
+
+    @Nullable
+    private final Handler eventHandler;
+
+    @Nullable
+    private final EventListener eventListener;
+    private final Handler mainHandler;
+    private final Timeline.Period period;
+
+    @Deprecated
+    public interface EventListener {
+        void onAdClicked();
+
+        void onAdLoadError(IOException iOException);
+
+        void onAdTapped();
+
+        void onInternalAdLoadError(RuntimeException runtimeException);
+    }
+
+    public interface MediaSourceFactory {
+        MediaSource createMediaSource(Uri uri);
+
+        int[] getSupportedTypes();
+    }
+
+    public static final class AdLoadException extends IOException {
+        public static final int TYPE_AD = 0;
+        public static final int TYPE_AD_GROUP = 1;
+        public static final int TYPE_ALL_ADS = 2;
+        public static final int TYPE_UNEXPECTED = 3;
+        public final int type;
+
+        @Retention(RetentionPolicy.SOURCE)
+        public @interface Type {
+        }
+
+        public static AdLoadException createForAd(Exception exc) {
+            return new AdLoadException(0, exc);
+        }
+
+        public static AdLoadException createForAdGroup(Exception exc, int i) {
+            return new AdLoadException(1, new IOException("Failed to load ad group " + i, exc));
+        }
+
+        public static AdLoadException createForAllAds(Exception exc) {
+            return new AdLoadException(2, exc);
+        }
+
+        public static AdLoadException createForUnexpected(RuntimeException runtimeException) {
+            return new AdLoadException(3, runtimeException);
+        }
+
+        private AdLoadException(int i, Exception exc) {
+            super(exc);
+            this.type = i;
+        }
+
+        public final RuntimeException getRuntimeExceptionForUnexpected() {
+            Assertions.checkState(this.type == 3);
+            return (RuntimeException) getCause();
+        }
+    }
+
+    public AdsMediaSource(MediaSource mediaSource, DataSource.Factory factory, AdsLoader adsLoader, ViewGroup viewGroup) {
+        this(mediaSource, new ExtractorMediaSource.Factory(factory), adsLoader, viewGroup, (Handler) null, (EventListener) null);
+    }
+
+    public AdsMediaSource(MediaSource mediaSource, MediaSourceFactory mediaSourceFactory, AdsLoader adsLoader, ViewGroup viewGroup) {
+        this(mediaSource, mediaSourceFactory, adsLoader, viewGroup, (Handler) null, (EventListener) null);
+    }
+
+    @Deprecated
+    public AdsMediaSource(MediaSource mediaSource, DataSource.Factory factory, AdsLoader adsLoader, ViewGroup viewGroup, @Nullable Handler handler, @Nullable EventListener eventListener) {
+        this(mediaSource, new ExtractorMediaSource.Factory(factory), adsLoader, viewGroup, handler, eventListener);
+    }
+
+    @Deprecated
+    public AdsMediaSource(MediaSource mediaSource, MediaSourceFactory mediaSourceFactory, AdsLoader adsLoader, ViewGroup viewGroup, @Nullable Handler handler, @Nullable EventListener eventListener) {
+        this.contentMediaSource = mediaSource;
+        this.adMediaSourceFactory = mediaSourceFactory;
+        this.adsLoader = adsLoader;
+        this.adUiViewGroup = viewGroup;
+        this.eventHandler = handler;
+        this.eventListener = eventListener;
+        this.mainHandler = new Handler(Looper.getMainLooper());
+        this.deferredMediaPeriodByAdMediaSource = new HashMap();
+        this.period = new Timeline.Period();
+        this.adGroupMediaSources = new MediaSource[0][];
+        this.adDurationsUs = new long[0][];
+        adsLoader.setSupportedContentTypes(mediaSourceFactory.getSupportedTypes());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.CompositeMediaSource, com.mbridge.msdk.playercommon.exoplayer2.source.BaseMediaSource
+    public final void prepareSourceInternal(final ExoPlayer exoPlayer, boolean z) {
+        super.prepareSourceInternal(exoPlayer, z);
+        Assertions.checkArgument(z);
+        final ComponentListener componentListener = new ComponentListener();
+        this.componentListener = componentListener;
+        prepareChildSource(new MediaSource.MediaPeriodId(0), this.contentMediaSource);
+        this.mainHandler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsMediaSource.1
+            @Override // java.lang.Runnable
+            public void run() {
+                AdsMediaSource.this.adsLoader.attachPlayer(exoPlayer, componentListener, AdsMediaSource.this.adUiViewGroup);
+            }
+        });
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource
+    public final MediaPeriod createPeriod(MediaSource.MediaPeriodId mediaPeriodId, Allocator allocator) {
+        if (this.adPlaybackState.adGroupCount > 0 && mediaPeriodId.isAd()) {
+            int i = mediaPeriodId.adGroupIndex;
+            int i2 = mediaPeriodId.adIndexInAdGroup;
+            Uri uri = this.adPlaybackState.adGroups[i].uris[i2];
+            if (this.adGroupMediaSources[i].length <= i2) {
+                MediaSource createMediaSource = this.adMediaSourceFactory.createMediaSource(uri);
+                MediaSource[][] mediaSourceArr = this.adGroupMediaSources;
+                MediaSource[] mediaSourceArr2 = mediaSourceArr[i];
+                int length = mediaSourceArr2.length;
+                if (i2 >= length) {
+                    int i3 = i2 + 1;
+                    mediaSourceArr[i] = (MediaSource[]) Arrays.copyOf(mediaSourceArr2, i3);
+                    long[][] jArr = this.adDurationsUs;
+                    jArr[i] = Arrays.copyOf(jArr[i], i3);
+                    Arrays.fill(this.adDurationsUs[i], length, i3, C.TIME_UNSET);
+                }
+                this.adGroupMediaSources[i][i2] = createMediaSource;
+                this.deferredMediaPeriodByAdMediaSource.put(createMediaSource, new ArrayList());
+                prepareChildSource(mediaPeriodId, createMediaSource);
+            }
+            MediaSource mediaSource = this.adGroupMediaSources[i][i2];
+            DeferredMediaPeriod deferredMediaPeriod = new DeferredMediaPeriod(mediaSource, new MediaSource.MediaPeriodId(0, mediaPeriodId.windowSequenceNumber), allocator);
+            deferredMediaPeriod.setPrepareErrorListener(new AdPrepareErrorListener(uri, i, i2));
+            List<DeferredMediaPeriod> list = this.deferredMediaPeriodByAdMediaSource.get(mediaSource);
+            if (list == null) {
+                deferredMediaPeriod.createPeriod();
+            } else {
+                list.add(deferredMediaPeriod);
+            }
+            return deferredMediaPeriod;
+        }
+        DeferredMediaPeriod deferredMediaPeriod2 = new DeferredMediaPeriod(this.contentMediaSource, mediaPeriodId, allocator);
+        deferredMediaPeriod2.createPeriod();
+        return deferredMediaPeriod2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource
+    public final void releasePeriod(MediaPeriod mediaPeriod) {
+        DeferredMediaPeriod deferredMediaPeriod = (DeferredMediaPeriod) mediaPeriod;
+        List<DeferredMediaPeriod> list = this.deferredMediaPeriodByAdMediaSource.get(deferredMediaPeriod.mediaSource);
+        if (list != null) {
+            list.remove(deferredMediaPeriod);
+        }
+        deferredMediaPeriod.releasePeriod();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.CompositeMediaSource, com.mbridge.msdk.playercommon.exoplayer2.source.BaseMediaSource
+    public final void releaseSourceInternal() {
+        super.releaseSourceInternal();
+        this.componentListener.release();
+        this.componentListener = null;
+        this.deferredMediaPeriodByAdMediaSource.clear();
+        this.contentTimeline = null;
+        this.contentManifest = null;
+        this.adPlaybackState = null;
+        this.adGroupMediaSources = new MediaSource[0][];
+        this.adDurationsUs = new long[0][];
+        this.mainHandler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsMediaSource.2
+            @Override // java.lang.Runnable
+            public void run() {
+                AdsMediaSource.this.adsLoader.detachPlayer();
+            }
+        });
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.CompositeMediaSource
+    public final void onChildSourceInfoRefreshed(MediaSource.MediaPeriodId mediaPeriodId, MediaSource mediaSource, Timeline timeline, @Nullable Object obj) {
+        if (mediaPeriodId.isAd()) {
+            onAdSourceInfoRefreshed(mediaSource, mediaPeriodId.adGroupIndex, mediaPeriodId.adIndexInAdGroup, timeline);
+        } else {
+            onContentSourceInfoRefreshed(timeline, obj);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.CompositeMediaSource
+    @Nullable
+    public final MediaSource.MediaPeriodId getMediaPeriodIdForChildMediaPeriodId(MediaSource.MediaPeriodId mediaPeriodId, MediaSource.MediaPeriodId mediaPeriodId2) {
+        return mediaPeriodId.isAd() ? mediaPeriodId : mediaPeriodId2;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onAdPlaybackState(AdPlaybackState adPlaybackState) {
+        if (this.adPlaybackState == null) {
+            MediaSource[][] mediaSourceArr = new MediaSource[adPlaybackState.adGroupCount][];
+            this.adGroupMediaSources = mediaSourceArr;
+            Arrays.fill(mediaSourceArr, new MediaSource[0]);
+            long[][] jArr = new long[adPlaybackState.adGroupCount][];
+            this.adDurationsUs = jArr;
+            Arrays.fill(jArr, new long[0]);
+        }
+        this.adPlaybackState = adPlaybackState;
+        maybeUpdateSourceInfo();
+    }
+
+    private void onContentSourceInfoRefreshed(Timeline timeline, Object obj) {
+        this.contentTimeline = timeline;
+        this.contentManifest = obj;
+        maybeUpdateSourceInfo();
+    }
+
+    private void onAdSourceInfoRefreshed(MediaSource mediaSource, int i, int i2, Timeline timeline) {
+        Assertions.checkArgument(timeline.getPeriodCount() == 1);
+        this.adDurationsUs[i][i2] = timeline.getPeriod(0, this.period).getDurationUs();
+        if (this.deferredMediaPeriodByAdMediaSource.containsKey(mediaSource)) {
+            List<DeferredMediaPeriod> list = this.deferredMediaPeriodByAdMediaSource.get(mediaSource);
+            for (int i3 = 0; i3 < list.size(); i3++) {
+                list.get(i3).createPeriod();
+            }
+            this.deferredMediaPeriodByAdMediaSource.remove(mediaSource);
+        }
+        maybeUpdateSourceInfo();
+    }
+
+    private void maybeUpdateSourceInfo() {
+        AdPlaybackState adPlaybackState = this.adPlaybackState;
+        if (adPlaybackState == null || this.contentTimeline == null) {
+            return;
+        }
+        AdPlaybackState withAdDurationsUs = adPlaybackState.withAdDurationsUs(this.adDurationsUs);
+        this.adPlaybackState = withAdDurationsUs;
+        refreshSourceInfo(withAdDurationsUs.adGroupCount == 0 ? this.contentTimeline : new SinglePeriodAdTimeline(this.contentTimeline, this.adPlaybackState), this.contentManifest);
+    }
+
+    public final class ComponentListener implements AdsLoader.EventListener {
+        private final Handler playerHandler = new Handler();
+        private volatile boolean released;
+
+        public ComponentListener() {
+        }
+
+        public final void release() {
+            this.released = true;
+            this.playerHandler.removeCallbacksAndMessages(null);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsLoader.EventListener
+        public final void onAdPlaybackState(final AdPlaybackState adPlaybackState) {
+            if (this.released) {
+                return;
+            }
+            this.playerHandler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsMediaSource.ComponentListener.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (ComponentListener.this.released) {
+                        return;
+                    }
+                    AdsMediaSource.this.onAdPlaybackState(adPlaybackState);
+                }
+            });
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsLoader.EventListener
+        public final void onAdClicked() {
+            if (this.released || AdsMediaSource.this.eventHandler == null || AdsMediaSource.this.eventListener == null) {
+                return;
+            }
+            AdsMediaSource.this.eventHandler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsMediaSource.ComponentListener.2
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (ComponentListener.this.released) {
+                        return;
+                    }
+                    AdsMediaSource.this.eventListener.onAdClicked();
+                }
+            });
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsLoader.EventListener
+        public final void onAdTapped() {
+            if (this.released || AdsMediaSource.this.eventHandler == null || AdsMediaSource.this.eventListener == null) {
+                return;
+            }
+            AdsMediaSource.this.eventHandler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsMediaSource.ComponentListener.3
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (ComponentListener.this.released) {
+                        return;
+                    }
+                    AdsMediaSource.this.eventListener.onAdTapped();
+                }
+            });
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsLoader.EventListener
+        public final void onAdLoadError(final AdLoadException adLoadException, DataSpec dataSpec) {
+            if (this.released) {
+                return;
+            }
+            AdsMediaSource.this.createEventDispatcher(null).loadError(dataSpec, 6, -1L, 0L, 0L, adLoadException, true);
+            if (AdsMediaSource.this.eventHandler == null || AdsMediaSource.this.eventListener == null) {
+                return;
+            }
+            AdsMediaSource.this.eventHandler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsMediaSource.ComponentListener.4
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (ComponentListener.this.released) {
+                        return;
+                    }
+                    if (adLoadException.type == 3) {
+                        AdsMediaSource.this.eventListener.onInternalAdLoadError(adLoadException.getRuntimeExceptionForUnexpected());
+                    } else {
+                        AdsMediaSource.this.eventListener.onAdLoadError(adLoadException);
+                    }
+                }
+            });
+        }
+    }
+
+    public final class AdPrepareErrorListener implements DeferredMediaPeriod.PrepareErrorListener {
+        private final int adGroupIndex;
+        private final int adIndexInAdGroup;
+        private final Uri adUri;
+
+        public AdPrepareErrorListener(Uri uri, int i, int i2) {
+            this.adUri = uri;
+            this.adGroupIndex = i;
+            this.adIndexInAdGroup = i2;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.source.DeferredMediaPeriod.PrepareErrorListener
+        public final void onPrepareError(MediaSource.MediaPeriodId mediaPeriodId, final IOException iOException) {
+            AdsMediaSource.this.createEventDispatcher(mediaPeriodId).loadError(new DataSpec(this.adUri), 6, -1L, 0L, 0L, AdLoadException.createForAd(iOException), true);
+            AdsMediaSource.this.mainHandler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdsMediaSource.AdPrepareErrorListener.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    AdsMediaSource.this.adsLoader.handlePrepareError(AdPrepareErrorListener.this.adGroupIndex, AdPrepareErrorListener.this.adIndexInAdGroup, iOException);
+                }
+            });
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/ads/SinglePeriodAdTimeline.java

@@ -0,0 +1,34 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.ads;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Timeline;
+import com.mbridge.msdk.playercommon.exoplayer2.source.ForwardingTimeline;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+final class SinglePeriodAdTimeline extends ForwardingTimeline {
+    private final AdPlaybackState adPlaybackState;
+
+    public SinglePeriodAdTimeline(Timeline timeline, AdPlaybackState adPlaybackState) {
+        super(timeline);
+        Assertions.checkState(timeline.getPeriodCount() == 1);
+        Assertions.checkState(timeline.getWindowCount() == 1);
+        this.adPlaybackState = adPlaybackState;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.ForwardingTimeline, com.mbridge.msdk.playercommon.exoplayer2.Timeline
+    public final Timeline.Period getPeriod(int i, Timeline.Period period, boolean z) {
+        this.timeline.getPeriod(i, period, z);
+        period.set(period.id, period.uid, period.windowIndex, period.durationUs, period.getPositionInWindowUs(), this.adPlaybackState);
+        return period;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.ForwardingTimeline, com.mbridge.msdk.playercommon.exoplayer2.Timeline
+    public final Timeline.Window getWindow(int i, Timeline.Window window, boolean z, long j) {
+        Timeline.Window window2 = super.getWindow(i, window, z, j);
+        if (window2.durationUs == C.TIME_UNSET) {
+            window2.durationUs = this.adPlaybackState.contentDurationUs;
+        }
+        return window2;
+    }
+}