CrackMe.apk
Download file
package com.google.android.exoplayer2.offline;
import android.content.Context;
import android.net.Uri;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.util.SparseIntArray;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.MediaItem;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.RendererCapabilities;
import com.google.android.exoplayer2.RenderersFactory;
import com.google.android.exoplayer2.Timeline;
import com.google.android.exoplayer2.Tracks;
import com.google.android.exoplayer2.analytics.PlayerId;
import com.google.android.exoplayer2.audio.AudioRendererEventListener;
import com.google.android.exoplayer2.decoder.DecoderCounters;
import com.google.android.exoplayer2.decoder.DecoderReuseEvaluation;
import com.google.android.exoplayer2.drm.DrmSessionManager;
import com.google.android.exoplayer2.drm.DrmSessionManagerProvider;
import com.google.android.exoplayer2.extractor.ExtractorsFactory;
import com.google.android.exoplayer2.metadata.Metadata;
import com.google.android.exoplayer2.offline.DownloadRequest;
import com.google.android.exoplayer2.source.DefaultMediaSourceFactory;
import com.google.android.exoplayer2.source.MediaPeriod;
import com.google.android.exoplayer2.source.MediaSource;
import com.google.android.exoplayer2.source.TrackGroup;
import com.google.android.exoplayer2.source.TrackGroupArray;
import com.google.android.exoplayer2.source.chunk.MediaChunk;
import com.google.android.exoplayer2.source.chunk.MediaChunkIterator;
import com.google.android.exoplayer2.text.CueGroup;
import com.google.android.exoplayer2.trackselection.BaseTrackSelection;
import com.google.android.exoplayer2.trackselection.DefaultTrackSelector;
import com.google.android.exoplayer2.trackselection.ExoTrackSelection;
import com.google.android.exoplayer2.trackselection.MappingTrackSelector;
import com.google.android.exoplayer2.trackselection.TrackSelection;
import com.google.android.exoplayer2.trackselection.TrackSelectionOverride;
import com.google.android.exoplayer2.trackselection.TrackSelectionParameters;
import com.google.android.exoplayer2.trackselection.TrackSelectionUtil;
import com.google.android.exoplayer2.trackselection.TrackSelectorResult;
import com.google.android.exoplayer2.upstream.Allocator;
import com.google.android.exoplayer2.upstream.BandwidthMeter;
import com.google.android.exoplayer2.upstream.DataSource;
import com.google.android.exoplayer2.upstream.DefaultAllocator;
import com.google.android.exoplayer2.upstream.TransferListener;
import com.google.android.exoplayer2.util.Assertions;
import com.google.android.exoplayer2.util.MimeTypes;
import com.google.android.exoplayer2.util.Util;
import com.google.android.exoplayer2.video.VideoRendererEventListener;
import com.google.android.exoplayer2.video.VideoSize;
import com.google.common.collect.UnmodifiableIterator;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.checkerframework.checker.nullness.qual.EnsuresNonNull;
import org.checkerframework.checker.nullness.qual.RequiresNonNull;
public final class DownloadHelper {
public static final DefaultTrackSelector.Parameters DEFAULT_TRACK_SELECTOR_PARAMETERS_WITHOUT_CONTEXT = DefaultTrackSelector.Parameters.DEFAULT_WITHOUT_CONTEXT.buildUpon().setForceHighestSupportedBitrate(true).setConstrainAudioChannelCountToDeviceCapabilities(false).build();
private Callback callback;
private final Handler callbackHandler;
private List<ExoTrackSelection>[][] immutableTrackSelectionsByPeriodAndRenderer;
private boolean isPreparedWithMedia;
private final MediaItem.LocalConfiguration localConfiguration;
private MappingTrackSelector.MappedTrackInfo[] mappedTrackInfos;
private MediaPreparer mediaPreparer;
private final MediaSource mediaSource;
private final RendererCapabilities[] rendererCapabilities;
private final SparseIntArray scratchSet = new SparseIntArray();
private TrackGroupArray[] trackGroupArrays;
private List<ExoTrackSelection>[][] trackSelectionsByPeriodAndRenderer;
private final DefaultTrackSelector trackSelector;
private final Timeline.Window window;
public interface Callback {
void onPrepareError(DownloadHelper downloadHelper, IOException iOException);
void onPrepared(DownloadHelper downloadHelper);
}
public static class LiveContentUnsupportedException extends IOException {
}
static /* synthetic */ DrmSessionManager lambda$createMediaSourceInternal$6(DrmSessionManager drmSessionManager, MediaItem mediaItem) {
return drmSessionManager;
}
static /* synthetic */ void lambda$getRendererCapabilities$0(CueGroup cueGroup) {
}
static /* synthetic */ void lambda$getRendererCapabilities$1(Metadata metadata) {
}
static /* synthetic */ void lambda$new$2() {
}
public static DefaultTrackSelector.Parameters getDefaultTrackSelectorParameters(Context context) {
return DefaultTrackSelector.Parameters.getDefaults(context).buildUpon().setForceHighestSupportedBitrate(true).setConstrainAudioChannelCountToDeviceCapabilities(false).build();
}
public static RendererCapabilities[] getRendererCapabilities(RenderersFactory renderersFactory) {
Renderer[] createRenderers = renderersFactory.createRenderers(Util.createHandlerForCurrentOrMainLooper(), new VideoRendererEventListener() {
public /* synthetic */ void onDroppedFrames(int i, long j) {
VideoRendererEventListener.CC.$default$onDroppedFrames(this, i, j);
}
public /* synthetic */ void onRenderedFirstFrame(Object obj, long j) {
VideoRendererEventListener.CC.$default$onRenderedFirstFrame(this, obj, j);
}
public /* synthetic */ void onVideoCodecError(Exception exc) {
VideoRendererEventListener.CC.$default$onVideoCodecError(this, exc);
}
public /* synthetic */ void onVideoDecoderInitialized(String str, long j, long j2) {
VideoRendererEventListener.CC.$default$onVideoDecoderInitialized(this, str, j, j2);
}
public /* synthetic */ void onVideoDecoderReleased(String str) {
VideoRendererEventListener.CC.$default$onVideoDecoderReleased(this, str);
}
public /* synthetic */ void onVideoDisabled(DecoderCounters decoderCounters) {
VideoRendererEventListener.CC.$default$onVideoDisabled(this, decoderCounters);
}
public /* synthetic */ void onVideoEnabled(DecoderCounters decoderCounters) {
VideoRendererEventListener.CC.$default$onVideoEnabled(this, decoderCounters);
}
public /* synthetic */ void onVideoFrameProcessingOffset(long j, int i) {
VideoRendererEventListener.CC.$default$onVideoFrameProcessingOffset(this, j, i);
}
public /* synthetic */ void onVideoInputFormatChanged(Format format) {
VideoRendererEventListener.CC.$default$onVideoInputFormatChanged(this, format);
}
public /* synthetic */ void onVideoInputFormatChanged(Format format, DecoderReuseEvaluation decoderReuseEvaluation) {
VideoRendererEventListener.CC.$default$onVideoInputFormatChanged(this, format, decoderReuseEvaluation);
}
public /* synthetic */ void onVideoSizeChanged(VideoSize videoSize) {
VideoRendererEventListener.CC.$default$onVideoSizeChanged(this, videoSize);
}
}, new AudioRendererEventListener() {
public /* synthetic */ void onAudioCodecError(Exception exc) {
AudioRendererEventListener.CC.$default$onAudioCodecError(this, exc);
}
public /* synthetic */ void onAudioDecoderInitialized(String str, long j, long j2) {
AudioRendererEventListener.CC.$default$onAudioDecoderInitialized(this, str, j, j2);
}
public /* synthetic */ void onAudioDecoderReleased(String str) {
AudioRendererEventListener.CC.$default$onAudioDecoderReleased(this, str);
}
public /* synthetic */ void onAudioDisabled(DecoderCounters decoderCounters) {
AudioRendererEventListener.CC.$default$onAudioDisabled(this, decoderCounters);
}
public /* synthetic */ void onAudioEnabled(DecoderCounters decoderCounters) {
AudioRendererEventListener.CC.$default$onAudioEnabled(this, decoderCounters);
}
public /* synthetic */ void onAudioInputFormatChanged(Format format) {
AudioRendererEventListener.CC.$default$onAudioInputFormatChanged(this, format);
}
public /* synthetic */ void onAudioInputFormatChanged(Format format, DecoderReuseEvaluation decoderReuseEvaluation) {
AudioRendererEventListener.CC.$default$onAudioInputFormatChanged(this, format, decoderReuseEvaluation);
}
public /* synthetic */ void onAudioPositionAdvancing(long j) {
AudioRendererEventListener.CC.$default$onAudioPositionAdvancing(this, j);
}
public /* synthetic */ void onAudioSinkError(Exception exc) {
AudioRendererEventListener.CC.$default$onAudioSinkError(this, exc);
}
public /* synthetic */ void onAudioUnderrun(int i, long j, long j2) {
AudioRendererEventListener.CC.$default$onAudioUnderrun(this, i, j, j2);
}
public /* synthetic */ void onSkipSilenceEnabledChanged(boolean z) {
AudioRendererEventListener.CC.$default$onSkipSilenceEnabledChanged(this, z);
}
}, DownloadHelper$$ExternalSyntheticLambda2.INSTANCE, DownloadHelper$$ExternalSyntheticLambda1.INSTANCE);
RendererCapabilities[] rendererCapabilitiesArr = new RendererCapabilities[createRenderers.length];
for (int i = 0; i < createRenderers.length; i++) {
rendererCapabilitiesArr[i] = createRenderers[i].getCapabilities();
}
return rendererCapabilitiesArr;
}
@Deprecated
public static DownloadHelper forProgressive(Context context, Uri uri) {
return forMediaItem(context, new MediaItem.Builder().setUri(uri).build());
}
@Deprecated
public static DownloadHelper forProgressive(Context context, Uri uri, String str) {
return forMediaItem(context, new MediaItem.Builder().setUri(uri).setCustomCacheKey(str).build());
}
@Deprecated
public static DownloadHelper forDash(Context context, Uri uri, DataSource.Factory factory, RenderersFactory renderersFactory) {
return forDash(uri, factory, renderersFactory, (DrmSessionManager) null, getDefaultTrackSelectorParameters(context));
}
@Deprecated
public static DownloadHelper forDash(Uri uri, DataSource.Factory factory, RenderersFactory renderersFactory, DrmSessionManager drmSessionManager, TrackSelectionParameters trackSelectionParameters) {
return forMediaItem(new MediaItem.Builder().setUri(uri).setMimeType(MimeTypes.APPLICATION_MPD).build(), trackSelectionParameters, renderersFactory, factory, drmSessionManager);
}
@Deprecated
public static DownloadHelper forHls(Context context, Uri uri, DataSource.Factory factory, RenderersFactory renderersFactory) {
return forHls(uri, factory, renderersFactory, (DrmSessionManager) null, getDefaultTrackSelectorParameters(context));
}
@Deprecated
public static DownloadHelper forHls(Uri uri, DataSource.Factory factory, RenderersFactory renderersFactory, DrmSessionManager drmSessionManager, TrackSelectionParameters trackSelectionParameters) {
return forMediaItem(new MediaItem.Builder().setUri(uri).setMimeType(MimeTypes.APPLICATION_M3U8).build(), trackSelectionParameters, renderersFactory, factory, drmSessionManager);
}
@Deprecated
public static DownloadHelper forSmoothStreaming(Uri uri, DataSource.Factory factory, RenderersFactory renderersFactory) {
return forSmoothStreaming(uri, factory, renderersFactory, (DrmSessionManager) null, DEFAULT_TRACK_SELECTOR_PARAMETERS_WITHOUT_CONTEXT);
}
@Deprecated
public static DownloadHelper forSmoothStreaming(Context context, Uri uri, DataSource.Factory factory, RenderersFactory renderersFactory) {
return forSmoothStreaming(uri, factory, renderersFactory, (DrmSessionManager) null, getDefaultTrackSelectorParameters(context));
}
@Deprecated
public static DownloadHelper forSmoothStreaming(Uri uri, DataSource.Factory factory, RenderersFactory renderersFactory, DrmSessionManager drmSessionManager, TrackSelectionParameters trackSelectionParameters) {
return forMediaItem(new MediaItem.Builder().setUri(uri).setMimeType(MimeTypes.APPLICATION_SS).build(), trackSelectionParameters, renderersFactory, factory, drmSessionManager);
}
public static DownloadHelper forMediaItem(Context context, MediaItem mediaItem) {
Assertions.checkArgument(isProgressive((MediaItem.LocalConfiguration) Assertions.checkNotNull(mediaItem.localConfiguration)));
return forMediaItem(mediaItem, getDefaultTrackSelectorParameters(context), (RenderersFactory) null, (DataSource.Factory) null, (DrmSessionManager) null);
}
public static DownloadHelper forMediaItem(Context context, MediaItem mediaItem, RenderersFactory renderersFactory, DataSource.Factory factory) {
return forMediaItem(mediaItem, getDefaultTrackSelectorParameters(context), renderersFactory, factory, (DrmSessionManager) null);
}
public static DownloadHelper forMediaItem(MediaItem mediaItem, TrackSelectionParameters trackSelectionParameters, RenderersFactory renderersFactory, DataSource.Factory factory) {
return forMediaItem(mediaItem, trackSelectionParameters, renderersFactory, factory, (DrmSessionManager) null);
}
public static DownloadHelper forMediaItem(MediaItem mediaItem, TrackSelectionParameters trackSelectionParameters, RenderersFactory renderersFactory, DataSource.Factory factory, DrmSessionManager drmSessionManager) {
MediaSource mediaSource2;
boolean isProgressive = isProgressive((MediaItem.LocalConfiguration) Assertions.checkNotNull(mediaItem.localConfiguration));
Assertions.checkArgument(isProgressive || factory != null);
if (isProgressive) {
mediaSource2 = null;
} else {
mediaSource2 = createMediaSourceInternal(mediaItem, (DataSource.Factory) Util.castNonNull(factory), drmSessionManager);
}
return new DownloadHelper(mediaItem, mediaSource2, trackSelectionParameters, renderersFactory != null ? getRendererCapabilities(renderersFactory) : new RendererCapabilities[0]);
}
public static MediaSource createMediaSource(DownloadRequest downloadRequest, DataSource.Factory factory) {
return createMediaSource(downloadRequest, factory, (DrmSessionManager) null);
}
public static MediaSource createMediaSource(DownloadRequest downloadRequest, DataSource.Factory factory, DrmSessionManager drmSessionManager) {
return createMediaSourceInternal(downloadRequest.toMediaItem(), factory, drmSessionManager);
}
public DownloadHelper(MediaItem mediaItem, MediaSource mediaSource2, TrackSelectionParameters trackSelectionParameters, RendererCapabilities[] rendererCapabilitiesArr) {
this.localConfiguration = (MediaItem.LocalConfiguration) Assertions.checkNotNull(mediaItem.localConfiguration);
this.mediaSource = mediaSource2;
DefaultTrackSelector defaultTrackSelector = new DefaultTrackSelector(trackSelectionParameters, (ExoTrackSelection.Factory) new DownloadTrackSelection.Factory());
this.trackSelector = defaultTrackSelector;
this.rendererCapabilities = rendererCapabilitiesArr;
defaultTrackSelector.init(DownloadHelper$$ExternalSyntheticLambda3.INSTANCE, new FakeBandwidthMeter());
this.callbackHandler = Util.createHandlerForCurrentOrMainLooper();
this.window = new Timeline.Window();
}
public void prepare(Callback callback2) {
Assertions.checkState(this.callback == null);
this.callback = callback2;
MediaSource mediaSource2 = this.mediaSource;
if (mediaSource2 != null) {
this.mediaPreparer = new MediaPreparer(mediaSource2, this);
} else {
this.callbackHandler.post(new DownloadHelper$$ExternalSyntheticLambda5(this, callback2));
}
}
/* access modifiers changed from: package-private */
/* renamed from: lambda$prepare$3$com-google-android-exoplayer2-offline-DownloadHelper reason: not valid java name */
public /* synthetic */ void m76lambda$prepare$3$comgoogleandroidexoplayer2offlineDownloadHelper(Callback callback2) {
callback2.onPrepared(this);
}
public void release() {
MediaPreparer mediaPreparer2 = this.mediaPreparer;
if (mediaPreparer2 != null) {
mediaPreparer2.release();
}
this.trackSelector.release();
}
public Object getManifest() {
if (this.mediaSource == null) {
return null;
}
assertPreparedWithMedia();
if (this.mediaPreparer.timeline.getWindowCount() > 0) {
return this.mediaPreparer.timeline.getWindow(0, this.window).manifest;
}
return null;
}
public int getPeriodCount() {
if (this.mediaSource == null) {
return 0;
}
assertPreparedWithMedia();
return this.trackGroupArrays.length;
}
public Tracks getTracks(int i) {
assertPreparedWithMedia();
return TrackSelectionUtil.buildTracks(this.mappedTrackInfos[i], (List<? extends TrackSelection>[]) this.immutableTrackSelectionsByPeriodAndRenderer[i]);
}
public TrackGroupArray getTrackGroups(int i) {
assertPreparedWithMedia();
return this.trackGroupArrays[i];
}
public MappingTrackSelector.MappedTrackInfo getMappedTrackInfo(int i) {
assertPreparedWithMedia();
return this.mappedTrackInfos[i];
}
public List<ExoTrackSelection> getTrackSelections(int i, int i2) {
assertPreparedWithMedia();
return this.immutableTrackSelectionsByPeriodAndRenderer[i][i2];
}
public void clearTrackSelections(int i) {
assertPreparedWithMedia();
for (int i2 = 0; i2 < this.rendererCapabilities.length; i2++) {
this.trackSelectionsByPeriodAndRenderer[i][i2].clear();
}
}
public void replaceTrackSelections(int i, TrackSelectionParameters trackSelectionParameters) {
try {
assertPreparedWithMedia();
clearTrackSelections(i);
addTrackSelectionInternal(i, trackSelectionParameters);
} catch (ExoPlaybackException e) {
throw new IllegalStateException(e);
}
}
public void addTrackSelection(int i, TrackSelectionParameters trackSelectionParameters) {
try {
assertPreparedWithMedia();
addTrackSelectionInternal(i, trackSelectionParameters);
} catch (ExoPlaybackException e) {
throw new IllegalStateException(e);
}
}
public void addAudioLanguagesToSelection(String... strArr) {
try {
assertPreparedWithMedia();
DefaultTrackSelector.Parameters.Builder buildUpon = DEFAULT_TRACK_SELECTOR_PARAMETERS_WITHOUT_CONTEXT.buildUpon();
buildUpon.setForceHighestSupportedBitrate(true);
for (RendererCapabilities trackType : this.rendererCapabilities) {
int trackType2 = trackType.getTrackType();
buildUpon.setTrackTypeDisabled(trackType2, trackType2 != 1);
}
int periodCount = getPeriodCount();
for (String preferredAudioLanguage : strArr) {
TrackSelectionParameters build = buildUpon.setPreferredAudioLanguage(preferredAudioLanguage).build();
for (int i = 0; i < periodCount; i++) {
addTrackSelectionInternal(i, build);
}
}
} catch (ExoPlaybackException e) {
throw new IllegalStateException(e);
}
}
public void addTextLanguagesToSelection(boolean z, String... strArr) {
try {
assertPreparedWithMedia();
DefaultTrackSelector.Parameters.Builder buildUpon = DEFAULT_TRACK_SELECTOR_PARAMETERS_WITHOUT_CONTEXT.buildUpon();
buildUpon.setSelectUndeterminedTextLanguage(z);
buildUpon.setForceHighestSupportedBitrate(true);
for (RendererCapabilities trackType : this.rendererCapabilities) {
int trackType2 = trackType.getTrackType();
buildUpon.setTrackTypeDisabled(trackType2, trackType2 != 3);
}
int periodCount = getPeriodCount();
for (String preferredTextLanguage : strArr) {
TrackSelectionParameters build = buildUpon.setPreferredTextLanguage(preferredTextLanguage).build();
for (int i = 0; i < periodCount; i++) {
addTrackSelectionInternal(i, build);
}
}
} catch (ExoPlaybackException e) {
throw new IllegalStateException(e);
}
}
public void addTrackSelectionForSingleRenderer(int i, int i2, DefaultTrackSelector.Parameters parameters, List<DefaultTrackSelector.SelectionOverride> list) {
try {
assertPreparedWithMedia();
DefaultTrackSelector.Parameters.Builder buildUpon = parameters.buildUpon();
int i3 = 0;
while (i3 < this.mappedTrackInfos[i].getRendererCount()) {
buildUpon.setRendererDisabled(i3, i3 != i2);
i3++;
}
if (list.isEmpty()) {
addTrackSelectionInternal(i, buildUpon.build());
return;
}
TrackGroupArray trackGroups = this.mappedTrackInfos[i].getTrackGroups(i2);
for (int i4 = 0; i4 < list.size(); i4++) {
buildUpon.setSelectionOverride(i2, trackGroups, list.get(i4));
addTrackSelectionInternal(i, buildUpon.build());
}
} catch (ExoPlaybackException e) {
throw new IllegalStateException(e);
}
}
public DownloadRequest getDownloadRequest(byte[] bArr) {
return getDownloadRequest(this.localConfiguration.uri.toString(), bArr);
}
public DownloadRequest getDownloadRequest(String str, byte[] bArr) {
DownloadRequest.Builder data = new DownloadRequest.Builder(str, this.localConfiguration.uri).setMimeType(this.localConfiguration.mimeType).setKeySetId(this.localConfiguration.drmConfiguration != null ? this.localConfiguration.drmConfiguration.getKeySetId() : null).setCustomCacheKey(this.localConfiguration.customCacheKey).setData(bArr);
if (this.mediaSource == null) {
return data.build();
}
assertPreparedWithMedia();
ArrayList arrayList = new ArrayList();
ArrayList arrayList2 = new ArrayList();
int length = this.trackSelectionsByPeriodAndRenderer.length;
for (int i = 0; i < length; i++) {
arrayList2.clear();
for (List<ExoTrackSelection> addAll : this.trackSelectionsByPeriodAndRenderer[i]) {
arrayList2.addAll(addAll);
}
arrayList.addAll(this.mediaPreparer.mediaPeriods[i].getStreamKeys(arrayList2));
}
return data.setStreamKeys(arrayList).build();
}
@RequiresNonNull({"trackGroupArrays", "trackSelectionsByPeriodAndRenderer", "mediaPreparer", "mediaPreparer.timeline"})
private void addTrackSelectionInternal(int i, TrackSelectionParameters trackSelectionParameters) throws ExoPlaybackException {
this.trackSelector.setParameters(trackSelectionParameters);
runTrackSelection(i);
UnmodifiableIterator<TrackSelectionOverride> it = trackSelectionParameters.overrides.values().iterator();
while (it.hasNext()) {
this.trackSelector.setParameters(trackSelectionParameters.buildUpon().setOverrideForType(it.next()).build());
runTrackSelection(i);
}
}
/* access modifiers changed from: private */
public void onMediaPrepared() throws ExoPlaybackException {
Assertions.checkNotNull(this.mediaPreparer);
Assertions.checkNotNull(this.mediaPreparer.mediaPeriods);
Assertions.checkNotNull(this.mediaPreparer.timeline);
int length = this.mediaPreparer.mediaPeriods.length;
int length2 = this.rendererCapabilities.length;
int[] iArr = new int[2];
iArr[1] = length2;
iArr[0] = length;
this.trackSelectionsByPeriodAndRenderer = (List[][]) Array.newInstance(List.class, iArr);
int[] iArr2 = new int[2];
iArr2[1] = length2;
iArr2[0] = length;
this.immutableTrackSelectionsByPeriodAndRenderer = (List[][]) Array.newInstance(List.class, iArr2);
for (int i = 0; i < length; i++) {
for (int i2 = 0; i2 < length2; i2++) {
this.trackSelectionsByPeriodAndRenderer[i][i2] = new ArrayList();
this.immutableTrackSelectionsByPeriodAndRenderer[i][i2] = Collections.unmodifiableList(this.trackSelectionsByPeriodAndRenderer[i][i2]);
}
}
this.trackGroupArrays = new TrackGroupArray[length];
this.mappedTrackInfos = new MappingTrackSelector.MappedTrackInfo[length];
for (int i3 = 0; i3 < length; i3++) {
this.trackGroupArrays[i3] = this.mediaPreparer.mediaPeriods[i3].getTrackGroups();
this.trackSelector.onSelectionActivated(runTrackSelection(i3).info);
this.mappedTrackInfos[i3] = (MappingTrackSelector.MappedTrackInfo) Assertions.checkNotNull(this.trackSelector.getCurrentMappedTrackInfo());
}
setPreparedWithMedia();
((Handler) Assertions.checkNotNull(this.callbackHandler)).post(new DownloadHelper$$ExternalSyntheticLambda4(this));
}
/* access modifiers changed from: package-private */
/* renamed from: lambda$onMediaPrepared$4$com-google-android-exoplayer2-offline-DownloadHelper reason: not valid java name */
public /* synthetic */ void m75lambda$onMediaPrepared$4$comgoogleandroidexoplayer2offlineDownloadHelper() {
((Callback) Assertions.checkNotNull(this.callback)).onPrepared(this);
}
/* access modifiers changed from: private */
public void onMediaPreparationFailed(IOException iOException) {
((Handler) Assertions.checkNotNull(this.callbackHandler)).post(new DownloadHelper$$ExternalSyntheticLambda6(this, iOException));
}
/* access modifiers changed from: package-private */
/* renamed from: lambda$onMediaPreparationFailed$5$com-google-android-exoplayer2-offline-DownloadHelper reason: not valid java name */
public /* synthetic */ void m74lambda$onMediaPreparationFailed$5$comgoogleandroidexoplayer2offlineDownloadHelper(IOException iOException) {
((Callback) Assertions.checkNotNull(this.callback)).onPrepareError(this, iOException);
}
@RequiresNonNull({"trackGroupArrays", "mappedTrackInfos", "trackSelectionsByPeriodAndRenderer", "immutableTrackSelectionsByPeriodAndRenderer", "mediaPreparer", "mediaPreparer.timeline", "mediaPreparer.mediaPeriods"})
private void setPreparedWithMedia() {
this.isPreparedWithMedia = true;
}
@EnsuresNonNull({"trackGroupArrays", "mappedTrackInfos", "trackSelectionsByPeriodAndRenderer", "immutableTrackSelectionsByPeriodAndRenderer", "mediaPreparer", "mediaPreparer.timeline", "mediaPreparer.mediaPeriods"})
private void assertPreparedWithMedia() {
Assertions.checkState(this.isPreparedWithMedia);
}
@RequiresNonNull({"trackGroupArrays", "trackSelectionsByPeriodAndRenderer", "mediaPreparer", "mediaPreparer.timeline"})
private TrackSelectorResult runTrackSelection(int i) throws ExoPlaybackException {
boolean z;
TrackSelectorResult selectTracks = this.trackSelector.selectTracks(this.rendererCapabilities, this.trackGroupArrays[i], new MediaSource.MediaPeriodId(this.mediaPreparer.timeline.getUidOfPeriod(i)), this.mediaPreparer.timeline);
for (int i2 = 0; i2 < selectTracks.length; i2++) {
ExoTrackSelection exoTrackSelection = selectTracks.selections[i2];
if (exoTrackSelection != null) {
List<ExoTrackSelection> list = this.trackSelectionsByPeriodAndRenderer[i][i2];
int i3 = 0;
while (true) {
if (i3 >= list.size()) {
z = false;
break;
}
ExoTrackSelection exoTrackSelection2 = list.get(i3);
if (exoTrackSelection2.getTrackGroup().equals(exoTrackSelection.getTrackGroup())) {
this.scratchSet.clear();
for (int i4 = 0; i4 < exoTrackSelection2.length(); i4++) {
this.scratchSet.put(exoTrackSelection2.getIndexInTrackGroup(i4), 0);
}
for (int i5 = 0; i5 < exoTrackSelection.length(); i5++) {
this.scratchSet.put(exoTrackSelection.getIndexInTrackGroup(i5), 0);
}
int[] iArr = new int[this.scratchSet.size()];
for (int i6 = 0; i6 < this.scratchSet.size(); i6++) {
iArr[i6] = this.scratchSet.keyAt(i6);
}
list.set(i3, new DownloadTrackSelection(exoTrackSelection2.getTrackGroup(), iArr));
z = true;
} else {
i3++;
}
}
if (!z) {
list.add(exoTrackSelection);
}
}
}
return selectTracks;
}
private static MediaSource createMediaSourceInternal(MediaItem mediaItem, DataSource.Factory factory, DrmSessionManager drmSessionManager) {
DefaultMediaSourceFactory defaultMediaSourceFactory = new DefaultMediaSourceFactory(factory, ExtractorsFactory.EMPTY);
if (drmSessionManager != null) {
defaultMediaSourceFactory.setDrmSessionManagerProvider((DrmSessionManagerProvider) new DownloadHelper$$ExternalSyntheticLambda0(drmSessionManager));
}
return defaultMediaSourceFactory.createMediaSource(mediaItem);
}
private static boolean isProgressive(MediaItem.LocalConfiguration localConfiguration2) {
return Util.inferContentTypeForUriAndMimeType(localConfiguration2.uri, localConfiguration2.mimeType) == 4;
}
private static final class MediaPreparer implements MediaSource.MediaSourceCaller, MediaPeriod.Callback, Handler.Callback {
private static final int DOWNLOAD_HELPER_CALLBACK_MESSAGE_FAILED = 1;
private static final int DOWNLOAD_HELPER_CALLBACK_MESSAGE_PREPARED = 0;
private static final int MESSAGE_CHECK_FOR_FAILURE = 1;
private static final int MESSAGE_CONTINUE_LOADING = 2;
private static final int MESSAGE_PREPARE_SOURCE = 0;
private static final int MESSAGE_RELEASE = 3;
private final Allocator allocator = new DefaultAllocator(true, 65536);
private final DownloadHelper downloadHelper;
private final Handler downloadHelperHandler = Util.createHandlerForCurrentOrMainLooper(new DownloadHelper$MediaPreparer$$ExternalSyntheticLambda0(this));
public MediaPeriod[] mediaPeriods;
private final MediaSource mediaSource;
private final Handler mediaSourceHandler;
private final HandlerThread mediaSourceThread;
private final ArrayList<MediaPeriod> pendingMediaPeriods = new ArrayList<>();
private boolean released;
public Timeline timeline;
public MediaPreparer(MediaSource mediaSource2, DownloadHelper downloadHelper2) {
this.mediaSource = mediaSource2;
this.downloadHelper = downloadHelper2;
HandlerThread handlerThread = new HandlerThread("ExoPlayer:DownloadHelper");
this.mediaSourceThread = handlerThread;
handlerThread.start();
Handler createHandler = Util.createHandler(handlerThread.getLooper(), this);
this.mediaSourceHandler = createHandler;
createHandler.sendEmptyMessage(0);
}
public void release() {
if (!this.released) {
this.released = true;
this.mediaSourceHandler.sendEmptyMessage(3);
}
}
public boolean handleMessage(Message message) {
int i = message.what;
if (i != 0) {
int i2 = 0;
if (i == 1) {
try {
if (this.mediaPeriods == null) {
this.mediaSource.maybeThrowSourceInfoRefreshError();
} else {
while (i2 < this.pendingMediaPeriods.size()) {
this.pendingMediaPeriods.get(i2).maybeThrowPrepareError();
i2++;
}
}
this.mediaSourceHandler.sendEmptyMessageDelayed(1, 100);
} catch (IOException e) {
this.downloadHelperHandler.obtainMessage(1, e).sendToTarget();
}
return true;
} else if (i == 2) {
MediaPeriod mediaPeriod = (MediaPeriod) message.obj;
if (this.pendingMediaPeriods.contains(mediaPeriod)) {
mediaPeriod.continueLoading(0);
}
return true;
} else if (i != 3) {
return false;
} else {
MediaPeriod[] mediaPeriodArr = this.mediaPeriods;
if (mediaPeriodArr != null) {
int length = mediaPeriodArr.length;
while (i2 < length) {
this.mediaSource.releasePeriod(mediaPeriodArr[i2]);
i2++;
}
}
this.mediaSource.releaseSource(this);
this.mediaSourceHandler.removeCallbacksAndMessages((Object) null);
this.mediaSourceThread.quit();
return true;
}
} else {
this.mediaSource.prepareSource(this, (TransferListener) null, PlayerId.UNSET);
this.mediaSourceHandler.sendEmptyMessage(1);
return true;
}
}
public void onSourceInfoRefreshed(MediaSource mediaSource2, Timeline timeline2) {
MediaPeriod[] mediaPeriodArr;
if (this.timeline == null) {
if (timeline2.getWindow(0, new Timeline.Window()).isLive()) {
this.downloadHelperHandler.obtainMessage(1, new LiveContentUnsupportedException()).sendToTarget();
return;
}
this.timeline = timeline2;
this.mediaPeriods = new MediaPeriod[timeline2.getPeriodCount()];
int i = 0;
while (true) {
mediaPeriodArr = this.mediaPeriods;
if (i >= mediaPeriodArr.length) {
break;
}
MediaPeriod createPeriod = this.mediaSource.createPeriod(new MediaSource.MediaPeriodId(timeline2.getUidOfPeriod(i)), this.allocator, 0);
this.mediaPeriods[i] = createPeriod;
this.pendingMediaPeriods.add(createPeriod);
i++;
}
for (MediaPeriod prepare : mediaPeriodArr) {
prepare.prepare(this, 0);
}
}
}
public void onPrepared(MediaPeriod mediaPeriod) {
this.pendingMediaPeriods.remove(mediaPeriod);
if (this.pendingMediaPeriods.isEmpty()) {
this.mediaSourceHandler.removeMessages(1);
this.downloadHelperHandler.sendEmptyMessage(0);
}
}
public void onContinueLoadingRequested(MediaPeriod mediaPeriod) {
if (this.pendingMediaPeriods.contains(mediaPeriod)) {
this.mediaSourceHandler.obtainMessage(2, mediaPeriod).sendToTarget();
}
}
/* access modifiers changed from: private */
public boolean handleDownloadHelperCallbackMessage(Message message) {
if (this.released) {
return false;
}
int i = message.what;
if (i == 0) {
try {
this.downloadHelper.onMediaPrepared();
} catch (ExoPlaybackException e) {
this.downloadHelperHandler.obtainMessage(1, new IOException(e)).sendToTarget();
}
return true;
} else if (i != 1) {
return false;
} else {
release();
this.downloadHelper.onMediaPreparationFailed((IOException) Util.castNonNull(message.obj));
return true;
}
}
}
private static final class DownloadTrackSelection extends BaseTrackSelection {
public int getSelectedIndex() {
return 0;
}
public Object getSelectionData() {
return null;
}
public int getSelectionReason() {
return 0;
}
public void updateSelectedTrack(long j, long j2, long j3, List<? extends MediaChunk> list, MediaChunkIterator[] mediaChunkIteratorArr) {
}
private static final class Factory implements ExoTrackSelection.Factory {
private Factory() {
}
public ExoTrackSelection[] createTrackSelections(ExoTrackSelection.Definition[] definitionArr, BandwidthMeter bandwidthMeter, MediaSource.MediaPeriodId mediaPeriodId, Timeline timeline) {
DownloadTrackSelection downloadTrackSelection;
ExoTrackSelection[] exoTrackSelectionArr = new ExoTrackSelection[definitionArr.length];
for (int i = 0; i < definitionArr.length; i++) {
if (definitionArr[i] == null) {
downloadTrackSelection = null;
} else {
downloadTrackSelection = new DownloadTrackSelection(definitionArr[i].group, definitionArr[i].tracks);
}
exoTrackSelectionArr[i] = downloadTrackSelection;
}
return exoTrackSelectionArr;
}
}
public DownloadTrackSelection(TrackGroup trackGroup, int[] iArr) {
super(trackGroup, iArr);
}
}
private static final class FakeBandwidthMeter implements BandwidthMeter {
public void addEventListener(Handler handler, BandwidthMeter.EventListener eventListener) {
}
public long getBitrateEstimate() {
return 0;
}
public /* synthetic */ long getTimeToFirstByteEstimateUs() {
return BandwidthMeter.CC.$default$getTimeToFirstByteEstimateUs(this);
}
public TransferListener getTransferListener() {
return null;
}
public void removeEventListener(BandwidthMeter.EventListener eventListener) {
}
private FakeBandwidthMeter() {
}
}
}
Download file