CrackMe.apk
Download file
package com.google.android.exoplayer2.offline;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import com.google.android.exoplayer2.offline.DownloadManager;
import com.google.android.exoplayer2.scheduler.Requirements;
import com.google.android.exoplayer2.scheduler.Scheduler;
import com.google.android.exoplayer2.util.Assertions;
import com.google.android.exoplayer2.util.Log;
import com.google.android.exoplayer2.util.NotificationUtil;
import com.google.android.exoplayer2.util.Util;
import java.util.HashMap;
import java.util.List;
import org.checkerframework.checker.nullness.qual.RequiresNonNull;
public abstract class DownloadService extends Service {
public static final String ACTION_ADD_DOWNLOAD = "com.google.android.exoplayer.downloadService.action.ADD_DOWNLOAD";
public static final String ACTION_INIT = "com.google.android.exoplayer.downloadService.action.INIT";
public static final String ACTION_PAUSE_DOWNLOADS = "com.google.android.exoplayer.downloadService.action.PAUSE_DOWNLOADS";
public static final String ACTION_REMOVE_ALL_DOWNLOADS = "com.google.android.exoplayer.downloadService.action.REMOVE_ALL_DOWNLOADS";
public static final String ACTION_REMOVE_DOWNLOAD = "com.google.android.exoplayer.downloadService.action.REMOVE_DOWNLOAD";
private static final String ACTION_RESTART = "com.google.android.exoplayer.downloadService.action.RESTART";
public static final String ACTION_RESUME_DOWNLOADS = "com.google.android.exoplayer.downloadService.action.RESUME_DOWNLOADS";
public static final String ACTION_SET_REQUIREMENTS = "com.google.android.exoplayer.downloadService.action.SET_REQUIREMENTS";
public static final String ACTION_SET_STOP_REASON = "com.google.android.exoplayer.downloadService.action.SET_STOP_REASON";
public static final long DEFAULT_FOREGROUND_NOTIFICATION_UPDATE_INTERVAL = 1000;
public static final int FOREGROUND_NOTIFICATION_ID_NONE = 0;
public static final String KEY_CONTENT_ID = "content_id";
public static final String KEY_DOWNLOAD_REQUEST = "download_request";
public static final String KEY_FOREGROUND = "foreground";
public static final String KEY_REQUIREMENTS = "requirements";
public static final String KEY_STOP_REASON = "stop_reason";
private static final String TAG = "DownloadService";
private static final HashMap<Class<? extends DownloadService>, DownloadManagerHelper> downloadManagerHelpers = new HashMap<>();
private final int channelDescriptionResourceId;
private final String channelId;
private final int channelNameResourceId;
/* access modifiers changed from: private */
public DownloadManagerHelper downloadManagerHelper;
private final ForegroundNotificationUpdater foregroundNotificationUpdater;
private boolean isDestroyed;
private boolean isStopped;
private int lastStartId;
private boolean startedInForeground;
private boolean taskRemoved;
/* access modifiers changed from: private */
public static boolean needsStartedService(int i) {
return i == 2 || i == 5 || i == 7;
}
/* access modifiers changed from: protected */
public abstract DownloadManager getDownloadManager();
/* access modifiers changed from: protected */
public abstract Notification getForegroundNotification(List<Download> list, int i);
/* access modifiers changed from: protected */
public abstract Scheduler getScheduler();
protected DownloadService(int i) {
this(i, 1000);
}
protected DownloadService(int i, long j) {
this(i, j, (String) null, 0, 0);
}
@Deprecated
protected DownloadService(int i, long j, String str, int i2) {
this(i, j, str, i2, 0);
}
protected DownloadService(int i, long j, String str, int i2, int i3) {
if (i == 0) {
this.foregroundNotificationUpdater = null;
this.channelId = null;
this.channelNameResourceId = 0;
this.channelDescriptionResourceId = 0;
return;
}
this.foregroundNotificationUpdater = new ForegroundNotificationUpdater(i, j);
this.channelId = str;
this.channelNameResourceId = i2;
this.channelDescriptionResourceId = i3;
}
public static Intent buildAddDownloadIntent(Context context, Class<? extends DownloadService> cls, DownloadRequest downloadRequest, boolean z) {
return buildAddDownloadIntent(context, cls, downloadRequest, 0, z);
}
public static Intent buildAddDownloadIntent(Context context, Class<? extends DownloadService> cls, DownloadRequest downloadRequest, int i, boolean z) {
return getIntent(context, cls, ACTION_ADD_DOWNLOAD, z).putExtra(KEY_DOWNLOAD_REQUEST, downloadRequest).putExtra(KEY_STOP_REASON, i);
}
public static Intent buildRemoveDownloadIntent(Context context, Class<? extends DownloadService> cls, String str, boolean z) {
return getIntent(context, cls, ACTION_REMOVE_DOWNLOAD, z).putExtra(KEY_CONTENT_ID, str);
}
public static Intent buildRemoveAllDownloadsIntent(Context context, Class<? extends DownloadService> cls, boolean z) {
return getIntent(context, cls, ACTION_REMOVE_ALL_DOWNLOADS, z);
}
public static Intent buildResumeDownloadsIntent(Context context, Class<? extends DownloadService> cls, boolean z) {
return getIntent(context, cls, ACTION_RESUME_DOWNLOADS, z);
}
public static Intent buildPauseDownloadsIntent(Context context, Class<? extends DownloadService> cls, boolean z) {
return getIntent(context, cls, ACTION_PAUSE_DOWNLOADS, z);
}
public static Intent buildSetStopReasonIntent(Context context, Class<? extends DownloadService> cls, String str, int i, boolean z) {
return getIntent(context, cls, ACTION_SET_STOP_REASON, z).putExtra(KEY_CONTENT_ID, str).putExtra(KEY_STOP_REASON, i);
}
public static Intent buildSetRequirementsIntent(Context context, Class<? extends DownloadService> cls, Requirements requirements, boolean z) {
return getIntent(context, cls, ACTION_SET_REQUIREMENTS, z).putExtra(KEY_REQUIREMENTS, requirements);
}
public static void sendAddDownload(Context context, Class<? extends DownloadService> cls, DownloadRequest downloadRequest, boolean z) {
startService(context, buildAddDownloadIntent(context, cls, downloadRequest, z), z);
}
public static void sendAddDownload(Context context, Class<? extends DownloadService> cls, DownloadRequest downloadRequest, int i, boolean z) {
startService(context, buildAddDownloadIntent(context, cls, downloadRequest, i, z), z);
}
public static void sendRemoveDownload(Context context, Class<? extends DownloadService> cls, String str, boolean z) {
startService(context, buildRemoveDownloadIntent(context, cls, str, z), z);
}
public static void sendRemoveAllDownloads(Context context, Class<? extends DownloadService> cls, boolean z) {
startService(context, buildRemoveAllDownloadsIntent(context, cls, z), z);
}
public static void sendResumeDownloads(Context context, Class<? extends DownloadService> cls, boolean z) {
startService(context, buildResumeDownloadsIntent(context, cls, z), z);
}
public static void sendPauseDownloads(Context context, Class<? extends DownloadService> cls, boolean z) {
startService(context, buildPauseDownloadsIntent(context, cls, z), z);
}
public static void sendSetStopReason(Context context, Class<? extends DownloadService> cls, String str, int i, boolean z) {
startService(context, buildSetStopReasonIntent(context, cls, str, i, z), z);
}
public static void sendSetRequirements(Context context, Class<? extends DownloadService> cls, Requirements requirements, boolean z) {
startService(context, buildSetRequirementsIntent(context, cls, requirements, z), z);
}
public static void start(Context context, Class<? extends DownloadService> cls) {
context.startService(getIntent(context, cls, ACTION_INIT));
}
public static void startForeground(Context context, Class<? extends DownloadService> cls) {
Util.startForegroundService(context, getIntent(context, cls, ACTION_INIT, true));
}
public void onCreate() {
String str = this.channelId;
if (str != null) {
NotificationUtil.createNotificationChannel(this, str, this.channelNameResourceId, this.channelDescriptionResourceId, 2);
}
Class<?> cls = getClass();
HashMap<Class<? extends DownloadService>, DownloadManagerHelper> hashMap = downloadManagerHelpers;
DownloadManagerHelper downloadManagerHelper2 = hashMap.get(cls);
if (downloadManagerHelper2 == null) {
boolean z = true;
boolean z2 = this.foregroundNotificationUpdater != null;
if (Util.SDK_INT >= 31) {
z = false;
}
Scheduler scheduler = (!z2 || !z) ? null : getScheduler();
DownloadManager downloadManager = getDownloadManager();
downloadManager.resumeDownloads();
downloadManagerHelper2 = new DownloadManagerHelper(getApplicationContext(), downloadManager, z2, scheduler, cls);
hashMap.put(cls, downloadManagerHelper2);
}
this.downloadManagerHelper = downloadManagerHelper2;
downloadManagerHelper2.attachService(this);
}
public int onStartCommand(Intent intent, int i, int i2) {
String str;
ForegroundNotificationUpdater foregroundNotificationUpdater2;
this.lastStartId = i2;
this.taskRemoved = false;
String str2 = null;
if (intent != null) {
str2 = intent.getAction();
str = intent.getStringExtra(KEY_CONTENT_ID);
this.startedInForeground |= intent.getBooleanExtra(KEY_FOREGROUND, false) || ACTION_RESTART.equals(str2);
} else {
str = null;
}
if (str2 == null) {
str2 = ACTION_INIT;
}
DownloadManager access$100 = ((DownloadManagerHelper) Assertions.checkNotNull(this.downloadManagerHelper)).downloadManager;
str2.hashCode();
char c = 65535;
switch (str2.hashCode()) {
case -1931239035:
if (str2.equals(ACTION_ADD_DOWNLOAD)) {
c = 0;
break;
}
break;
case -932047176:
if (str2.equals(ACTION_RESUME_DOWNLOADS)) {
c = 1;
break;
}
break;
case -871181424:
if (str2.equals(ACTION_RESTART)) {
c = 2;
break;
}
break;
case -650547439:
if (str2.equals(ACTION_REMOVE_ALL_DOWNLOADS)) {
c = 3;
break;
}
break;
case -119057172:
if (str2.equals(ACTION_SET_REQUIREMENTS)) {
c = 4;
break;
}
break;
case 191112771:
if (str2.equals(ACTION_PAUSE_DOWNLOADS)) {
c = 5;
break;
}
break;
case 671523141:
if (str2.equals(ACTION_SET_STOP_REASON)) {
c = 6;
break;
}
break;
case 1015676687:
if (str2.equals(ACTION_INIT)) {
c = 7;
break;
}
break;
case 1547520644:
if (str2.equals(ACTION_REMOVE_DOWNLOAD)) {
c = 8;
break;
}
break;
}
switch (c) {
case 0:
DownloadRequest downloadRequest = (DownloadRequest) ((Intent) Assertions.checkNotNull(intent)).getParcelableExtra(KEY_DOWNLOAD_REQUEST);
if (downloadRequest != null) {
access$100.addDownload(downloadRequest, intent.getIntExtra(KEY_STOP_REASON, 0));
break;
} else {
Log.e(TAG, "Ignored ADD_DOWNLOAD: Missing download_request extra");
break;
}
case 1:
access$100.resumeDownloads();
break;
case 2:
case 7:
break;
case 3:
access$100.removeAllDownloads();
break;
case 4:
Requirements requirements = (Requirements) ((Intent) Assertions.checkNotNull(intent)).getParcelableExtra(KEY_REQUIREMENTS);
if (requirements != null) {
access$100.setRequirements(requirements);
break;
} else {
Log.e(TAG, "Ignored SET_REQUIREMENTS: Missing requirements extra");
break;
}
case 5:
access$100.pauseDownloads();
break;
case 6:
if (((Intent) Assertions.checkNotNull(intent)).hasExtra(KEY_STOP_REASON)) {
access$100.setStopReason(str, intent.getIntExtra(KEY_STOP_REASON, 0));
break;
} else {
Log.e(TAG, "Ignored SET_STOP_REASON: Missing stop_reason extra");
break;
}
case 8:
if (str != null) {
access$100.removeDownload(str);
break;
} else {
Log.e(TAG, "Ignored REMOVE_DOWNLOAD: Missing content_id extra");
break;
}
default:
Log.e(TAG, "Ignored unrecognized action: " + str2);
break;
}
if (Util.SDK_INT >= 26 && this.startedInForeground && (foregroundNotificationUpdater2 = this.foregroundNotificationUpdater) != null) {
foregroundNotificationUpdater2.showNotificationIfNotAlready();
}
this.isStopped = false;
if (access$100.isIdle()) {
onIdle();
}
return 1;
}
public void onTaskRemoved(Intent intent) {
this.taskRemoved = true;
}
public void onDestroy() {
this.isDestroyed = true;
((DownloadManagerHelper) Assertions.checkNotNull(this.downloadManagerHelper)).detachService(this);
ForegroundNotificationUpdater foregroundNotificationUpdater2 = this.foregroundNotificationUpdater;
if (foregroundNotificationUpdater2 != null) {
foregroundNotificationUpdater2.stopPeriodicUpdates();
}
}
public final IBinder onBind(Intent intent) {
throw new UnsupportedOperationException();
}
/* access modifiers changed from: protected */
public final void invalidateForegroundNotification() {
ForegroundNotificationUpdater foregroundNotificationUpdater2 = this.foregroundNotificationUpdater;
if (foregroundNotificationUpdater2 != null && !this.isDestroyed) {
foregroundNotificationUpdater2.invalidate();
}
}
/* access modifiers changed from: private */
public void notifyDownloads(List<Download> list) {
if (this.foregroundNotificationUpdater != null) {
for (int i = 0; i < list.size(); i++) {
if (needsStartedService(list.get(i).state)) {
this.foregroundNotificationUpdater.startPeriodicUpdates();
return;
}
}
}
}
/* access modifiers changed from: private */
public void notifyDownloadChanged(Download download) {
if (this.foregroundNotificationUpdater == null) {
return;
}
if (needsStartedService(download.state)) {
this.foregroundNotificationUpdater.startPeriodicUpdates();
} else {
this.foregroundNotificationUpdater.invalidate();
}
}
/* access modifiers changed from: private */
public void notifyDownloadRemoved() {
ForegroundNotificationUpdater foregroundNotificationUpdater2 = this.foregroundNotificationUpdater;
if (foregroundNotificationUpdater2 != null) {
foregroundNotificationUpdater2.invalidate();
}
}
/* access modifiers changed from: private */
public boolean isStopped() {
return this.isStopped;
}
/* access modifiers changed from: private */
public void onIdle() {
ForegroundNotificationUpdater foregroundNotificationUpdater2 = this.foregroundNotificationUpdater;
if (foregroundNotificationUpdater2 != null) {
foregroundNotificationUpdater2.stopPeriodicUpdates();
}
if (((DownloadManagerHelper) Assertions.checkNotNull(this.downloadManagerHelper)).updateScheduler()) {
if (Util.SDK_INT >= 28 || !this.taskRemoved) {
this.isStopped |= stopSelfResult(this.lastStartId);
return;
}
stopSelf();
this.isStopped = true;
}
}
private static Intent getIntent(Context context, Class<? extends DownloadService> cls, String str, boolean z) {
return getIntent(context, cls, str).putExtra(KEY_FOREGROUND, z);
}
/* access modifiers changed from: private */
public static Intent getIntent(Context context, Class<? extends DownloadService> cls, String str) {
return new Intent(context, cls).setAction(str);
}
private static void startService(Context context, Intent intent, boolean z) {
if (z) {
Util.startForegroundService(context, intent);
} else {
context.startService(intent);
}
}
private final class ForegroundNotificationUpdater {
private final Handler handler = new Handler(Looper.getMainLooper());
private boolean notificationDisplayed;
private final int notificationId;
private boolean periodicUpdatesStarted;
private final long updateInterval;
public ForegroundNotificationUpdater(int i, long j) {
this.notificationId = i;
this.updateInterval = j;
}
public void startPeriodicUpdates() {
this.periodicUpdatesStarted = true;
update();
}
public void stopPeriodicUpdates() {
this.periodicUpdatesStarted = false;
this.handler.removeCallbacksAndMessages((Object) null);
}
public void showNotificationIfNotAlready() {
if (!this.notificationDisplayed) {
update();
}
}
public void invalidate() {
if (this.notificationDisplayed) {
update();
}
}
/* access modifiers changed from: private */
public void update() {
DownloadManager access$100 = ((DownloadManagerHelper) Assertions.checkNotNull(DownloadService.this.downloadManagerHelper)).downloadManager;
Notification foregroundNotification = DownloadService.this.getForegroundNotification(access$100.getCurrentDownloads(), access$100.getNotMetRequirements());
if (!this.notificationDisplayed) {
DownloadService.this.startForeground(this.notificationId, foregroundNotification);
this.notificationDisplayed = true;
} else {
((NotificationManager) DownloadService.this.getSystemService("notification")).notify(this.notificationId, foregroundNotification);
}
if (this.periodicUpdatesStarted) {
this.handler.removeCallbacksAndMessages((Object) null);
this.handler.postDelayed(new DownloadService$ForegroundNotificationUpdater$$ExternalSyntheticLambda0(this), this.updateInterval);
}
}
}
private static final class DownloadManagerHelper implements DownloadManager.Listener {
private final Context context;
/* access modifiers changed from: private */
public final DownloadManager downloadManager;
private DownloadService downloadService;
private final boolean foregroundAllowed;
private Requirements scheduledRequirements;
private final Scheduler scheduler;
private final Class<? extends DownloadService> serviceClass;
public /* synthetic */ void onDownloadsPausedChanged(DownloadManager downloadManager2, boolean z) {
DownloadManager.Listener.CC.$default$onDownloadsPausedChanged(this, downloadManager2, z);
}
private DownloadManagerHelper(Context context2, DownloadManager downloadManager2, boolean z, Scheduler scheduler2, Class<? extends DownloadService> cls) {
this.context = context2;
this.downloadManager = downloadManager2;
this.foregroundAllowed = z;
this.scheduler = scheduler2;
this.serviceClass = cls;
downloadManager2.addListener(this);
updateScheduler();
}
public void attachService(DownloadService downloadService2) {
Assertions.checkState(this.downloadService == null);
this.downloadService = downloadService2;
if (this.downloadManager.isInitialized()) {
Util.createHandlerForCurrentOrMainLooper().postAtFrontOfQueue(new DownloadService$DownloadManagerHelper$$ExternalSyntheticLambda0(this, downloadService2));
}
}
/* access modifiers changed from: package-private */
/* renamed from: lambda$attachService$0$com-google-android-exoplayer2-offline-DownloadService$DownloadManagerHelper reason: not valid java name */
public /* synthetic */ void m78lambda$attachService$0$comgoogleandroidexoplayer2offlineDownloadService$DownloadManagerHelper(DownloadService downloadService2) {
downloadService2.notifyDownloads(this.downloadManager.getCurrentDownloads());
}
public void detachService(DownloadService downloadService2) {
Assertions.checkState(this.downloadService == downloadService2);
this.downloadService = null;
}
public boolean updateScheduler() {
boolean isWaitingForRequirements = this.downloadManager.isWaitingForRequirements();
if (this.scheduler == null) {
return !isWaitingForRequirements;
}
if (!isWaitingForRequirements) {
cancelScheduler();
return true;
}
Requirements requirements = this.downloadManager.getRequirements();
if (!this.scheduler.getSupportedRequirements(requirements).equals(requirements)) {
cancelScheduler();
return false;
} else if (!schedulerNeedsUpdate(requirements)) {
return true;
} else {
if (this.scheduler.schedule(requirements, this.context.getPackageName(), DownloadService.ACTION_RESTART)) {
this.scheduledRequirements = requirements;
return true;
}
Log.w(DownloadService.TAG, "Failed to schedule restart");
cancelScheduler();
return false;
}
}
public void onInitialized(DownloadManager downloadManager2) {
DownloadService downloadService2 = this.downloadService;
if (downloadService2 != null) {
downloadService2.notifyDownloads(downloadManager2.getCurrentDownloads());
}
}
public void onDownloadChanged(DownloadManager downloadManager2, Download download, Exception exc) {
DownloadService downloadService2 = this.downloadService;
if (downloadService2 != null) {
downloadService2.notifyDownloadChanged(download);
}
if (serviceMayNeedRestart() && DownloadService.needsStartedService(download.state)) {
Log.w(DownloadService.TAG, "DownloadService wasn't running. Restarting.");
restartService();
}
}
public void onDownloadRemoved(DownloadManager downloadManager2, Download download) {
DownloadService downloadService2 = this.downloadService;
if (downloadService2 != null) {
downloadService2.notifyDownloadRemoved();
}
}
public final void onIdle(DownloadManager downloadManager2) {
DownloadService downloadService2 = this.downloadService;
if (downloadService2 != null) {
downloadService2.onIdle();
}
}
public void onRequirementsStateChanged(DownloadManager downloadManager2, Requirements requirements, int i) {
updateScheduler();
}
public void onWaitingForRequirementsChanged(DownloadManager downloadManager2, boolean z) {
if (!z && !downloadManager2.getDownloadsPaused() && serviceMayNeedRestart()) {
List<Download> currentDownloads = downloadManager2.getCurrentDownloads();
for (int i = 0; i < currentDownloads.size(); i++) {
if (currentDownloads.get(i).state == 0) {
restartService();
return;
}
}
}
}
private boolean schedulerNeedsUpdate(Requirements requirements) {
return !Util.areEqual(this.scheduledRequirements, requirements);
}
@RequiresNonNull({"scheduler"})
private void cancelScheduler() {
Requirements requirements = new Requirements(0);
if (schedulerNeedsUpdate(requirements)) {
this.scheduler.cancel();
this.scheduledRequirements = requirements;
}
}
private boolean serviceMayNeedRestart() {
DownloadService downloadService2 = this.downloadService;
return downloadService2 == null || downloadService2.isStopped();
}
private void restartService() {
if (this.foregroundAllowed) {
try {
Util.startForegroundService(this.context, DownloadService.getIntent(this.context, this.serviceClass, DownloadService.ACTION_RESTART));
} catch (IllegalStateException unused) {
Log.w(DownloadService.TAG, "Failed to restart (foreground launch restriction)");
}
} else {
try {
this.context.startService(DownloadService.getIntent(this.context, this.serviceClass, DownloadService.ACTION_INIT));
} catch (IllegalStateException unused2) {
Log.w(DownloadService.TAG, "Failed to restart (process is idle)");
}
}
}
}
}
Download file