CrackMe.apk
Download file
package com.google.android.exoplayer2.source.smoothstreaming;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.os.SystemClock;
import com.google.android.exoplayer2.C;
import com.google.android.exoplayer2.ExoPlayerLibraryInfo;
import com.google.android.exoplayer2.MediaItem;
import com.google.android.exoplayer2.drm.DefaultDrmSessionManagerProvider;
import com.google.android.exoplayer2.drm.DrmSessionManager;
import com.google.android.exoplayer2.drm.DrmSessionManagerProvider;
import com.google.android.exoplayer2.offline.FilteringManifestParser;
import com.google.android.exoplayer2.offline.StreamKey;
import com.google.android.exoplayer2.source.BaseMediaSource;
import com.google.android.exoplayer2.source.CompositeSequenceableLoaderFactory;
import com.google.android.exoplayer2.source.DefaultCompositeSequenceableLoaderFactory;
import com.google.android.exoplayer2.source.LoadEventInfo;
import com.google.android.exoplayer2.source.MediaLoadData;
import com.google.android.exoplayer2.source.MediaPeriod;
import com.google.android.exoplayer2.source.MediaSource;
import com.google.android.exoplayer2.source.MediaSourceEventListener;
import com.google.android.exoplayer2.source.MediaSourceFactory;
import com.google.android.exoplayer2.source.SinglePeriodTimeline;
import com.google.android.exoplayer2.source.smoothstreaming.DefaultSsChunkSource;
import com.google.android.exoplayer2.source.smoothstreaming.SsChunkSource;
import com.google.android.exoplayer2.source.smoothstreaming.manifest.SsManifest;
import com.google.android.exoplayer2.source.smoothstreaming.manifest.SsManifestParser;
import com.google.android.exoplayer2.upstream.Allocator;
import com.google.android.exoplayer2.upstream.DataSource;
import com.google.android.exoplayer2.upstream.DefaultLoadErrorHandlingPolicy;
import com.google.android.exoplayer2.upstream.LoadErrorHandlingPolicy;
import com.google.android.exoplayer2.upstream.Loader;
import com.google.android.exoplayer2.upstream.LoaderErrorThrower;
import com.google.android.exoplayer2.upstream.ParsingLoadable;
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.common.collect.ImmutableList;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public final class SsMediaSource extends BaseMediaSource implements Loader.Callback<ParsingLoadable<SsManifest>> {
public static final long DEFAULT_LIVE_PRESENTATION_DELAY_MS = 30000;
private static final int MINIMUM_MANIFEST_REFRESH_PERIOD_MS = 5000;
private static final long MIN_LIVE_DEFAULT_START_POSITION_US = 5000000;
private final SsChunkSource.Factory chunkSourceFactory;
private final CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory;
private final DrmSessionManager drmSessionManager;
private final long livePresentationDelayMs;
private final LoadErrorHandlingPolicy loadErrorHandlingPolicy;
private final MediaItem.LocalConfiguration localConfiguration;
private SsManifest manifest;
private DataSource manifestDataSource;
private final DataSource.Factory manifestDataSourceFactory;
private final MediaSourceEventListener.EventDispatcher manifestEventDispatcher;
private long manifestLoadStartTimestamp;
private Loader manifestLoader;
private LoaderErrorThrower manifestLoaderErrorThrower;
private final ParsingLoadable.Parser<? extends SsManifest> manifestParser;
private Handler manifestRefreshHandler;
private final Uri manifestUri;
private final MediaItem mediaItem;
private final ArrayList<SsMediaPeriod> mediaPeriods;
private TransferListener mediaTransferListener;
private final boolean sideloadedManifest;
static {
ExoPlayerLibraryInfo.registerModule("goog.exo.smoothstreaming");
}
public static final class Factory implements MediaSourceFactory {
private final SsChunkSource.Factory chunkSourceFactory;
private CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory;
private DrmSessionManagerProvider drmSessionManagerProvider;
private long livePresentationDelayMs;
private LoadErrorHandlingPolicy loadErrorHandlingPolicy;
private final DataSource.Factory manifestDataSourceFactory;
private ParsingLoadable.Parser<? extends SsManifest> manifestParser;
public int[] getSupportedTypes() {
return new int[]{1};
}
public Factory(DataSource.Factory factory) {
this(new DefaultSsChunkSource.Factory(factory), factory);
}
public Factory(SsChunkSource.Factory factory, DataSource.Factory factory2) {
this.chunkSourceFactory = (SsChunkSource.Factory) Assertions.checkNotNull(factory);
this.manifestDataSourceFactory = factory2;
this.drmSessionManagerProvider = new DefaultDrmSessionManagerProvider();
this.loadErrorHandlingPolicy = new DefaultLoadErrorHandlingPolicy();
this.livePresentationDelayMs = 30000;
this.compositeSequenceableLoaderFactory = new DefaultCompositeSequenceableLoaderFactory();
}
public Factory setLoadErrorHandlingPolicy(LoadErrorHandlingPolicy loadErrorHandlingPolicy2) {
this.loadErrorHandlingPolicy = (LoadErrorHandlingPolicy) Assertions.checkNotNull(loadErrorHandlingPolicy2, "MediaSource.Factory#setLoadErrorHandlingPolicy no longer handles null by instantiating a new DefaultLoadErrorHandlingPolicy. Explicitly construct and pass an instance in order to retain the old behavior.");
return this;
}
public Factory setLivePresentationDelayMs(long j) {
this.livePresentationDelayMs = j;
return this;
}
public Factory setManifestParser(ParsingLoadable.Parser<? extends SsManifest> parser) {
this.manifestParser = parser;
return this;
}
public Factory setCompositeSequenceableLoaderFactory(CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory2) {
this.compositeSequenceableLoaderFactory = (CompositeSequenceableLoaderFactory) Assertions.checkNotNull(compositeSequenceableLoaderFactory2, "SsMediaSource.Factory#setCompositeSequenceableLoaderFactory no longer handles null by instantiating a new DefaultCompositeSequenceableLoaderFactory. Explicitly construct and pass an instance in order to retain the old behavior.");
return this;
}
public Factory setDrmSessionManagerProvider(DrmSessionManagerProvider drmSessionManagerProvider2) {
this.drmSessionManagerProvider = (DrmSessionManagerProvider) Assertions.checkNotNull(drmSessionManagerProvider2, "MediaSource.Factory#setDrmSessionManagerProvider no longer handles null by instantiating a new DefaultDrmSessionManagerProvider. Explicitly construct and pass an instance in order to retain the old behavior.");
return this;
}
public SsMediaSource createMediaSource(SsManifest ssManifest) {
return createMediaSource(ssManifest, MediaItem.fromUri(Uri.EMPTY));
}
public SsMediaSource createMediaSource(SsManifest ssManifest, MediaItem mediaItem) {
List list;
SsManifest ssManifest2 = ssManifest;
MediaItem mediaItem2 = mediaItem;
boolean z = true;
Assertions.checkArgument(!ssManifest2.isLive);
if (mediaItem2.localConfiguration != null) {
list = mediaItem2.localConfiguration.streamKeys;
} else {
list = ImmutableList.of();
}
if (!list.isEmpty()) {
ssManifest2 = ssManifest2.copy((List<StreamKey>) list);
}
SsManifest ssManifest3 = ssManifest2;
if (mediaItem2.localConfiguration == null) {
z = false;
}
MediaItem build = mediaItem.buildUpon().setMimeType(MimeTypes.APPLICATION_SS).setUri(z ? mediaItem2.localConfiguration.uri : Uri.EMPTY).build();
return new SsMediaSource(build, ssManifest3, (DataSource.Factory) null, (ParsingLoadable.Parser) null, this.chunkSourceFactory, this.compositeSequenceableLoaderFactory, this.drmSessionManagerProvider.get(build), this.loadErrorHandlingPolicy, this.livePresentationDelayMs);
}
public SsMediaSource createMediaSource(MediaItem mediaItem) {
Assertions.checkNotNull(mediaItem.localConfiguration);
ParsingLoadable.Parser parser = this.manifestParser;
if (parser == null) {
parser = new SsManifestParser();
}
List<StreamKey> list = mediaItem.localConfiguration.streamKeys;
return new SsMediaSource(mediaItem, (SsManifest) null, this.manifestDataSourceFactory, !list.isEmpty() ? new FilteringManifestParser(parser, list) : parser, this.chunkSourceFactory, this.compositeSequenceableLoaderFactory, this.drmSessionManagerProvider.get(mediaItem), this.loadErrorHandlingPolicy, this.livePresentationDelayMs);
}
}
private SsMediaSource(MediaItem mediaItem2, SsManifest ssManifest, DataSource.Factory factory, ParsingLoadable.Parser<? extends SsManifest> parser, SsChunkSource.Factory factory2, CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory2, DrmSessionManager drmSessionManager2, LoadErrorHandlingPolicy loadErrorHandlingPolicy2, long j) {
Uri uri;
boolean z = false;
Assertions.checkState(ssManifest == null || !ssManifest.isLive);
this.mediaItem = mediaItem2;
MediaItem.LocalConfiguration localConfiguration2 = (MediaItem.LocalConfiguration) Assertions.checkNotNull(mediaItem2.localConfiguration);
this.localConfiguration = localConfiguration2;
this.manifest = ssManifest;
if (localConfiguration2.uri.equals(Uri.EMPTY)) {
uri = null;
} else {
uri = Util.fixSmoothStreamingIsmManifestUri(localConfiguration2.uri);
}
this.manifestUri = uri;
this.manifestDataSourceFactory = factory;
this.manifestParser = parser;
this.chunkSourceFactory = factory2;
this.compositeSequenceableLoaderFactory = compositeSequenceableLoaderFactory2;
this.drmSessionManager = drmSessionManager2;
this.loadErrorHandlingPolicy = loadErrorHandlingPolicy2;
this.livePresentationDelayMs = j;
this.manifestEventDispatcher = createEventDispatcher((MediaSource.MediaPeriodId) null);
this.sideloadedManifest = ssManifest != null ? true : z;
this.mediaPeriods = new ArrayList<>();
}
public MediaItem getMediaItem() {
return this.mediaItem;
}
/* access modifiers changed from: protected */
public void prepareSourceInternal(TransferListener transferListener) {
this.mediaTransferListener = transferListener;
this.drmSessionManager.prepare();
this.drmSessionManager.setPlayer(Looper.myLooper(), getPlayerId());
if (this.sideloadedManifest) {
this.manifestLoaderErrorThrower = new LoaderErrorThrower.Dummy();
processManifest();
return;
}
this.manifestDataSource = this.manifestDataSourceFactory.createDataSource();
Loader loader = new Loader("SsMediaSource");
this.manifestLoader = loader;
this.manifestLoaderErrorThrower = loader;
this.manifestRefreshHandler = Util.createHandlerForCurrentLooper();
startLoadingManifest();
}
public void maybeThrowSourceInfoRefreshError() throws IOException {
this.manifestLoaderErrorThrower.maybeThrowError();
}
public MediaPeriod createPeriod(MediaSource.MediaPeriodId mediaPeriodId, Allocator allocator, long j) {
MediaSourceEventListener.EventDispatcher createEventDispatcher = createEventDispatcher(mediaPeriodId);
SsMediaPeriod ssMediaPeriod = new SsMediaPeriod(this.manifest, this.chunkSourceFactory, this.mediaTransferListener, this.compositeSequenceableLoaderFactory, this.drmSessionManager, createDrmEventDispatcher(mediaPeriodId), this.loadErrorHandlingPolicy, createEventDispatcher, this.manifestLoaderErrorThrower, allocator);
this.mediaPeriods.add(ssMediaPeriod);
return ssMediaPeriod;
}
public void releasePeriod(MediaPeriod mediaPeriod) {
((SsMediaPeriod) mediaPeriod).release();
this.mediaPeriods.remove(mediaPeriod);
}
/* access modifiers changed from: protected */
public void releaseSourceInternal() {
this.manifest = this.sideloadedManifest ? this.manifest : null;
this.manifestDataSource = null;
this.manifestLoadStartTimestamp = 0;
Loader loader = this.manifestLoader;
if (loader != null) {
loader.release();
this.manifestLoader = null;
}
Handler handler = this.manifestRefreshHandler;
if (handler != null) {
handler.removeCallbacksAndMessages((Object) null);
this.manifestRefreshHandler = null;
}
this.drmSessionManager.release();
}
public void onLoadCompleted(ParsingLoadable<SsManifest> parsingLoadable, long j, long j2) {
ParsingLoadable<SsManifest> parsingLoadable2 = parsingLoadable;
LoadEventInfo loadEventInfo = new LoadEventInfo(parsingLoadable2.loadTaskId, parsingLoadable2.dataSpec, parsingLoadable.getUri(), parsingLoadable.getResponseHeaders(), j, j2, parsingLoadable.bytesLoaded());
this.loadErrorHandlingPolicy.onLoadTaskConcluded(parsingLoadable2.loadTaskId);
this.manifestEventDispatcher.loadCompleted(loadEventInfo, parsingLoadable2.type);
this.manifest = parsingLoadable.getResult();
this.manifestLoadStartTimestamp = j - j2;
processManifest();
scheduleManifestRefresh();
}
public void onLoadCanceled(ParsingLoadable<SsManifest> parsingLoadable, long j, long j2, boolean z) {
ParsingLoadable<SsManifest> parsingLoadable2 = parsingLoadable;
LoadEventInfo loadEventInfo = new LoadEventInfo(parsingLoadable2.loadTaskId, parsingLoadable2.dataSpec, parsingLoadable.getUri(), parsingLoadable.getResponseHeaders(), j, j2, parsingLoadable.bytesLoaded());
this.loadErrorHandlingPolicy.onLoadTaskConcluded(parsingLoadable2.loadTaskId);
this.manifestEventDispatcher.loadCanceled(loadEventInfo, parsingLoadable2.type);
}
public Loader.LoadErrorAction onLoadError(ParsingLoadable<SsManifest> parsingLoadable, long j, long j2, IOException iOException, int i) {
Loader.LoadErrorAction loadErrorAction;
ParsingLoadable<SsManifest> parsingLoadable2 = parsingLoadable;
IOException iOException2 = iOException;
LoadEventInfo loadEventInfo = new LoadEventInfo(parsingLoadable2.loadTaskId, parsingLoadable2.dataSpec, parsingLoadable.getUri(), parsingLoadable.getResponseHeaders(), j, j2, parsingLoadable.bytesLoaded());
long retryDelayMsFor = this.loadErrorHandlingPolicy.getRetryDelayMsFor(new LoadErrorHandlingPolicy.LoadErrorInfo(loadEventInfo, new MediaLoadData(parsingLoadable2.type), iOException2, i));
if (retryDelayMsFor == C.TIME_UNSET) {
loadErrorAction = Loader.DONT_RETRY_FATAL;
} else {
loadErrorAction = Loader.createRetryAction(false, retryDelayMsFor);
}
boolean z = !loadErrorAction.isRetry();
this.manifestEventDispatcher.loadError(loadEventInfo, parsingLoadable2.type, iOException2, z);
if (z) {
this.loadErrorHandlingPolicy.onLoadTaskConcluded(parsingLoadable2.loadTaskId);
}
return loadErrorAction;
}
private void processManifest() {
SinglePeriodTimeline singlePeriodTimeline;
for (int i = 0; i < this.mediaPeriods.size(); i++) {
this.mediaPeriods.get(i).updateManifest(this.manifest);
}
long j = Long.MIN_VALUE;
long j2 = Long.MAX_VALUE;
for (SsManifest.StreamElement streamElement : this.manifest.streamElements) {
if (streamElement.chunkCount > 0) {
j2 = Math.min(j2, streamElement.getStartTimeUs(0));
j = Math.max(j, streamElement.getStartTimeUs(streamElement.chunkCount - 1) + streamElement.getChunkDurationUs(streamElement.chunkCount - 1));
}
}
if (j2 == Long.MAX_VALUE) {
singlePeriodTimeline = new SinglePeriodTimeline(this.manifest.isLive ? -9223372036854775807L : 0, 0, 0, 0, true, this.manifest.isLive, this.manifest.isLive, (Object) this.manifest, this.mediaItem);
} else if (this.manifest.isLive) {
if (this.manifest.dvrWindowLengthUs != C.TIME_UNSET && this.manifest.dvrWindowLengthUs > 0) {
j2 = Math.max(j2, j - this.manifest.dvrWindowLengthUs);
}
long j3 = j2;
long j4 = j - j3;
long msToUs = j4 - Util.msToUs(this.livePresentationDelayMs);
if (msToUs < MIN_LIVE_DEFAULT_START_POSITION_US) {
msToUs = Math.min(MIN_LIVE_DEFAULT_START_POSITION_US, j4 / 2);
}
singlePeriodTimeline = new SinglePeriodTimeline((long) C.TIME_UNSET, j4, j3, msToUs, true, true, true, (Object) this.manifest, this.mediaItem);
} else {
long j5 = this.manifest.durationUs != C.TIME_UNSET ? this.manifest.durationUs : j - j2;
singlePeriodTimeline = new SinglePeriodTimeline(j2 + j5, j5, j2, 0, true, false, false, (Object) this.manifest, this.mediaItem);
}
refreshSourceInfo(singlePeriodTimeline);
}
private void scheduleManifestRefresh() {
if (this.manifest.isLive) {
this.manifestRefreshHandler.postDelayed(new SsMediaSource$$ExternalSyntheticLambda0(this), Math.max(0, (this.manifestLoadStartTimestamp + 5000) - SystemClock.elapsedRealtime()));
}
}
/* access modifiers changed from: private */
public void startLoadingManifest() {
if (!this.manifestLoader.hasFatalError()) {
ParsingLoadable parsingLoadable = new ParsingLoadable(this.manifestDataSource, this.manifestUri, 4, this.manifestParser);
this.manifestEventDispatcher.loadStarted(new LoadEventInfo(parsingLoadable.loadTaskId, parsingLoadable.dataSpec, this.manifestLoader.startLoading(parsingLoadable, this, this.loadErrorHandlingPolicy.getMinimumLoadableRetryCount(parsingLoadable.type))), parsingLoadable.type);
}
}
}
Download file