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/androidx/work/impl/background/systemalarm/Alarms.java

@@ -0,0 +1,65 @@
+package androidx.work.impl.background.systemalarm;
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.core.app.NotificationCompat;
+import androidx.work.Logger;
+import androidx.work.impl.WorkDatabase;
+import androidx.work.impl.model.SystemIdInfo;
+import androidx.work.impl.model.SystemIdInfoDao;
+import androidx.work.impl.model.SystemIdInfoKt;
+import androidx.work.impl.model.WorkGenerationalId;
+import androidx.work.impl.utils.IdGenerator;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+class Alarms {
+    private static final String TAG = Logger.tagWithPrefix("Alarms");
+
+    public static void setAlarm(@NonNull Context context, @NonNull WorkDatabase workDatabase, @NonNull WorkGenerationalId workGenerationalId, long j) {
+        SystemIdInfoDao systemIdInfoDao = workDatabase.systemIdInfoDao();
+        SystemIdInfo systemIdInfo = systemIdInfoDao.getSystemIdInfo(workGenerationalId);
+        if (systemIdInfo != null) {
+            cancelExactAlarm(context, workGenerationalId, systemIdInfo.systemId);
+            setExactAlarm(context, workGenerationalId, systemIdInfo.systemId, j);
+        } else {
+            int nextAlarmManagerId = new IdGenerator(workDatabase).nextAlarmManagerId();
+            systemIdInfoDao.insertSystemIdInfo(SystemIdInfoKt.systemIdInfo(workGenerationalId, nextAlarmManagerId));
+            setExactAlarm(context, workGenerationalId, nextAlarmManagerId, j);
+        }
+    }
+
+    public static void cancelAlarm(@NonNull Context context, @NonNull WorkDatabase workDatabase, @NonNull WorkGenerationalId workGenerationalId) {
+        SystemIdInfoDao systemIdInfoDao = workDatabase.systemIdInfoDao();
+        SystemIdInfo systemIdInfo = systemIdInfoDao.getSystemIdInfo(workGenerationalId);
+        if (systemIdInfo != null) {
+            cancelExactAlarm(context, workGenerationalId, systemIdInfo.systemId);
+            Logger.get().debug(TAG, "Removing SystemIdInfo for workSpecId (" + workGenerationalId + ")");
+            systemIdInfoDao.removeSystemIdInfo(workGenerationalId);
+        }
+    }
+
+    private static void cancelExactAlarm(@NonNull Context context, @NonNull WorkGenerationalId workGenerationalId, int i) {
+        AlarmManager alarmManager = (AlarmManager) context.getSystemService(NotificationCompat.CATEGORY_ALARM);
+        PendingIntent service = PendingIntent.getService(context, i, CommandHandler.createDelayMetIntent(context, workGenerationalId), 603979776);
+        if (service == null || alarmManager == null) {
+            return;
+        }
+        Logger.get().debug(TAG, "Cancelling existing alarm with (workSpecId, systemId) (" + workGenerationalId + ", " + i + ")");
+        alarmManager.cancel(service);
+    }
+
+    private static void setExactAlarm(@NonNull Context context, @NonNull WorkGenerationalId workGenerationalId, int i, long j) {
+        AlarmManager alarmManager = (AlarmManager) context.getSystemService(NotificationCompat.CATEGORY_ALARM);
+        PendingIntent service = PendingIntent.getService(context, i, CommandHandler.createDelayMetIntent(context, workGenerationalId), 201326592);
+        if (alarmManager != null) {
+            alarmManager.setExact(0, j, service);
+        }
+    }
+
+    private Alarms() {
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/CommandHandler.java

@@ -0,0 +1,263 @@
+package androidx.work.impl.background.systemalarm;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.WorkerThread;
+import androidx.work.Clock;
+import androidx.work.Logger;
+import androidx.work.impl.ExecutionListener;
+import androidx.work.impl.StartStopToken;
+import androidx.work.impl.StartStopTokens;
+import androidx.work.impl.WorkDatabase;
+import androidx.work.impl.background.systemalarm.SystemAlarmDispatcher;
+import androidx.work.impl.model.WorkGenerationalId;
+import androidx.work.impl.model.WorkSpec;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public class CommandHandler implements ExecutionListener {
+    static final String ACTION_CONSTRAINTS_CHANGED = "ACTION_CONSTRAINTS_CHANGED";
+    static final String ACTION_DELAY_MET = "ACTION_DELAY_MET";
+    static final String ACTION_EXECUTION_COMPLETED = "ACTION_EXECUTION_COMPLETED";
+    static final String ACTION_RESCHEDULE = "ACTION_RESCHEDULE";
+    static final String ACTION_SCHEDULE_WORK = "ACTION_SCHEDULE_WORK";
+    static final String ACTION_STOP_WORK = "ACTION_STOP_WORK";
+    private static final String KEY_NEEDS_RESCHEDULE = "KEY_NEEDS_RESCHEDULE";
+    private static final String KEY_WORKSPEC_GENERATION = "KEY_WORKSPEC_GENERATION";
+    private static final String KEY_WORKSPEC_ID = "KEY_WORKSPEC_ID";
+    private static final String TAG = Logger.tagWithPrefix("CommandHandler");
+    static final long WORK_PROCESSING_TIME_IN_MS = 600000;
+    private final Clock mClock;
+    private final Context mContext;
+    private final StartStopTokens mStartStopTokens;
+    private final Map<WorkGenerationalId, DelayMetCommandHandler> mPendingDelayMet = new HashMap();
+    private final Object mLock = new Object();
+
+    public static Intent createScheduleWorkIntent(@NonNull Context context, @NonNull WorkGenerationalId workGenerationalId) {
+        Intent intent = new Intent(context, (Class<?>) SystemAlarmService.class);
+        intent.setAction(ACTION_SCHEDULE_WORK);
+        return writeWorkGenerationalId(intent, workGenerationalId);
+    }
+
+    private static Intent writeWorkGenerationalId(@NonNull Intent intent, @NonNull WorkGenerationalId workGenerationalId) {
+        intent.putExtra(KEY_WORKSPEC_ID, workGenerationalId.getWorkSpecId());
+        intent.putExtra(KEY_WORKSPEC_GENERATION, workGenerationalId.getGeneration());
+        return intent;
+    }
+
+    public static WorkGenerationalId readWorkGenerationalId(@NonNull Intent intent) {
+        return new WorkGenerationalId(intent.getStringExtra(KEY_WORKSPEC_ID), intent.getIntExtra(KEY_WORKSPEC_GENERATION, 0));
+    }
+
+    public static Intent createDelayMetIntent(@NonNull Context context, @NonNull WorkGenerationalId workGenerationalId) {
+        Intent intent = new Intent(context, (Class<?>) SystemAlarmService.class);
+        intent.setAction(ACTION_DELAY_MET);
+        return writeWorkGenerationalId(intent, workGenerationalId);
+    }
+
+    public static Intent createStopWorkIntent(@NonNull Context context, @NonNull String str) {
+        Intent intent = new Intent(context, (Class<?>) SystemAlarmService.class);
+        intent.setAction(ACTION_STOP_WORK);
+        intent.putExtra(KEY_WORKSPEC_ID, str);
+        return intent;
+    }
+
+    public static Intent createStopWorkIntent(@NonNull Context context, @NonNull WorkGenerationalId workGenerationalId) {
+        Intent intent = new Intent(context, (Class<?>) SystemAlarmService.class);
+        intent.setAction(ACTION_STOP_WORK);
+        return writeWorkGenerationalId(intent, workGenerationalId);
+    }
+
+    public static Intent createConstraintsChangedIntent(@NonNull Context context) {
+        Intent intent = new Intent(context, (Class<?>) SystemAlarmService.class);
+        intent.setAction(ACTION_CONSTRAINTS_CHANGED);
+        return intent;
+    }
+
+    public static Intent createRescheduleIntent(@NonNull Context context) {
+        Intent intent = new Intent(context, (Class<?>) SystemAlarmService.class);
+        intent.setAction(ACTION_RESCHEDULE);
+        return intent;
+    }
+
+    public static Intent createExecutionCompletedIntent(@NonNull Context context, @NonNull WorkGenerationalId workGenerationalId, boolean z) {
+        Intent intent = new Intent(context, (Class<?>) SystemAlarmService.class);
+        intent.setAction(ACTION_EXECUTION_COMPLETED);
+        intent.putExtra(KEY_NEEDS_RESCHEDULE, z);
+        return writeWorkGenerationalId(intent, workGenerationalId);
+    }
+
+    public CommandHandler(@NonNull Context context, Clock clock, @NonNull StartStopTokens startStopTokens) {
+        this.mContext = context;
+        this.mClock = clock;
+        this.mStartStopTokens = startStopTokens;
+    }
+
+    @Override // androidx.work.impl.ExecutionListener
+    public void onExecuted(@NonNull WorkGenerationalId workGenerationalId, boolean z) {
+        synchronized (this.mLock) {
+            try {
+                DelayMetCommandHandler remove = this.mPendingDelayMet.remove(workGenerationalId);
+                this.mStartStopTokens.remove(workGenerationalId);
+                if (remove != null) {
+                    remove.onExecuted(z);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public boolean hasPendingCommands() {
+        boolean z;
+        synchronized (this.mLock) {
+            z = !this.mPendingDelayMet.isEmpty();
+        }
+        return z;
+    }
+
+    @WorkerThread
+    public void onHandleIntent(@NonNull Intent intent, int i, @NonNull SystemAlarmDispatcher systemAlarmDispatcher) {
+        String action = intent.getAction();
+        if (ACTION_CONSTRAINTS_CHANGED.equals(action)) {
+            handleConstraintsChanged(intent, i, systemAlarmDispatcher);
+            return;
+        }
+        if (ACTION_RESCHEDULE.equals(action)) {
+            handleReschedule(intent, i, systemAlarmDispatcher);
+            return;
+        }
+        if (!hasKeys(intent.getExtras(), KEY_WORKSPEC_ID)) {
+            Logger.get().error(TAG, "Invalid request for " + action + " , requires " + KEY_WORKSPEC_ID + " .");
+            return;
+        }
+        if (ACTION_SCHEDULE_WORK.equals(action)) {
+            handleScheduleWorkIntent(intent, i, systemAlarmDispatcher);
+            return;
+        }
+        if (ACTION_DELAY_MET.equals(action)) {
+            handleDelayMet(intent, i, systemAlarmDispatcher);
+            return;
+        }
+        if (ACTION_STOP_WORK.equals(action)) {
+            handleStopWork(intent, systemAlarmDispatcher);
+            return;
+        }
+        if (ACTION_EXECUTION_COMPLETED.equals(action)) {
+            handleExecutionCompleted(intent, i);
+            return;
+        }
+        Logger.get().warning(TAG, "Ignoring intent " + intent);
+    }
+
+    private void handleScheduleWorkIntent(@NonNull Intent intent, int i, @NonNull SystemAlarmDispatcher systemAlarmDispatcher) {
+        WorkGenerationalId readWorkGenerationalId = readWorkGenerationalId(intent);
+        Logger logger = Logger.get();
+        String str = TAG;
+        logger.debug(str, "Handling schedule work for " + readWorkGenerationalId);
+        WorkDatabase workDatabase = systemAlarmDispatcher.getWorkManager().getWorkDatabase();
+        workDatabase.beginTransaction();
+        try {
+            WorkSpec workSpec = workDatabase.workSpecDao().getWorkSpec(readWorkGenerationalId.getWorkSpecId());
+            if (workSpec == null) {
+                Logger.get().warning(str, "Skipping scheduling " + readWorkGenerationalId + " because it's no longer in the DB");
+                return;
+            }
+            if (workSpec.state.isFinished()) {
+                Logger.get().warning(str, "Skipping scheduling " + readWorkGenerationalId + "because it is finished.");
+                return;
+            }
+            long calculateNextRunTime = workSpec.calculateNextRunTime();
+            if (!workSpec.hasConstraints()) {
+                Logger.get().debug(str, "Setting up Alarms for " + readWorkGenerationalId + "at " + calculateNextRunTime);
+                Alarms.setAlarm(this.mContext, workDatabase, readWorkGenerationalId, calculateNextRunTime);
+            } else {
+                Logger.get().debug(str, "Opportunistically setting an alarm for " + readWorkGenerationalId + "at " + calculateNextRunTime);
+                Alarms.setAlarm(this.mContext, workDatabase, readWorkGenerationalId, calculateNextRunTime);
+                systemAlarmDispatcher.getTaskExecutor().getMainThreadExecutor().execute(new SystemAlarmDispatcher.AddRunnable(systemAlarmDispatcher, createConstraintsChangedIntent(this.mContext), i));
+            }
+            workDatabase.setTransactionSuccessful();
+        } finally {
+            workDatabase.endTransaction();
+        }
+    }
+
+    private void handleDelayMet(@NonNull Intent intent, int i, @NonNull SystemAlarmDispatcher systemAlarmDispatcher) {
+        synchronized (this.mLock) {
+            try {
+                WorkGenerationalId readWorkGenerationalId = readWorkGenerationalId(intent);
+                Logger logger = Logger.get();
+                String str = TAG;
+                logger.debug(str, "Handing delay met for " + readWorkGenerationalId);
+                if (!this.mPendingDelayMet.containsKey(readWorkGenerationalId)) {
+                    DelayMetCommandHandler delayMetCommandHandler = new DelayMetCommandHandler(this.mContext, i, systemAlarmDispatcher, this.mStartStopTokens.tokenFor(readWorkGenerationalId));
+                    this.mPendingDelayMet.put(readWorkGenerationalId, delayMetCommandHandler);
+                    delayMetCommandHandler.handleProcessWork();
+                } else {
+                    Logger.get().debug(str, "WorkSpec " + readWorkGenerationalId + " is is already being handled for ACTION_DELAY_MET");
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private void handleStopWork(@NonNull Intent intent, @NonNull SystemAlarmDispatcher systemAlarmDispatcher) {
+        List<StartStopToken> remove;
+        Bundle extras = intent.getExtras();
+        String string = extras.getString(KEY_WORKSPEC_ID);
+        if (extras.containsKey(KEY_WORKSPEC_GENERATION)) {
+            int i = extras.getInt(KEY_WORKSPEC_GENERATION);
+            remove = new ArrayList<>(1);
+            StartStopToken remove2 = this.mStartStopTokens.remove(new WorkGenerationalId(string, i));
+            if (remove2 != null) {
+                remove.add(remove2);
+            }
+        } else {
+            remove = this.mStartStopTokens.remove(string);
+        }
+        for (StartStopToken startStopToken : remove) {
+            Logger.get().debug(TAG, "Handing stopWork work for " + string);
+            systemAlarmDispatcher.getWorkerLauncher().stopWork(startStopToken);
+            Alarms.cancelAlarm(this.mContext, systemAlarmDispatcher.getWorkManager().getWorkDatabase(), startStopToken.getId());
+            systemAlarmDispatcher.onExecuted(startStopToken.getId(), false);
+        }
+    }
+
+    private void handleConstraintsChanged(@NonNull Intent intent, int i, @NonNull SystemAlarmDispatcher systemAlarmDispatcher) {
+        Logger.get().debug(TAG, "Handling constraints changed " + intent);
+        new ConstraintsCommandHandler(this.mContext, this.mClock, i, systemAlarmDispatcher).handleConstraintsChanged();
+    }
+
+    private void handleReschedule(@NonNull Intent intent, int i, @NonNull SystemAlarmDispatcher systemAlarmDispatcher) {
+        Logger.get().debug(TAG, "Handling reschedule " + intent + ", " + i);
+        systemAlarmDispatcher.getWorkManager().rescheduleEligibleWork();
+    }
+
+    private void handleExecutionCompleted(@NonNull Intent intent, int i) {
+        WorkGenerationalId readWorkGenerationalId = readWorkGenerationalId(intent);
+        boolean z = intent.getExtras().getBoolean(KEY_NEEDS_RESCHEDULE);
+        Logger.get().debug(TAG, "Handling onExecutionCompleted " + intent + ", " + i);
+        onExecuted(readWorkGenerationalId, z);
+    }
+
+    private static boolean hasKeys(@Nullable Bundle bundle, @NonNull String... strArr) {
+        if (bundle == null || bundle.isEmpty()) {
+            return false;
+        }
+        for (String str : strArr) {
+            if (bundle.get(str) == null) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/ConstraintProxy.java

@@ -0,0 +1,69 @@
+package androidx.work.impl.background.systemalarm;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import androidx.work.Constraints;
+import androidx.work.Logger;
+import androidx.work.NetworkType;
+import androidx.work.impl.model.WorkSpec;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes.dex */
+abstract class ConstraintProxy extends BroadcastReceiver {
+    private static final String TAG = Logger.tagWithPrefix("ConstraintProxy");
+
+    @Override // android.content.BroadcastReceiver
+    public void onReceive(Context context, Intent intent) {
+        Logger.get().debug(TAG, "onReceive : " + intent);
+        context.startService(CommandHandler.createConstraintsChangedIntent(context));
+    }
+
+    public static class BatteryNotLowProxy extends ConstraintProxy {
+        @Override // androidx.work.impl.background.systemalarm.ConstraintProxy, android.content.BroadcastReceiver
+        public /* bridge */ /* synthetic */ void onReceive(Context context, Intent intent) {
+            super.onReceive(context, intent);
+        }
+    }
+
+    public static class BatteryChargingProxy extends ConstraintProxy {
+        @Override // androidx.work.impl.background.systemalarm.ConstraintProxy, android.content.BroadcastReceiver
+        public /* bridge */ /* synthetic */ void onReceive(Context context, Intent intent) {
+            super.onReceive(context, intent);
+        }
+    }
+
+    public static class StorageNotLowProxy extends ConstraintProxy {
+        @Override // androidx.work.impl.background.systemalarm.ConstraintProxy, android.content.BroadcastReceiver
+        public /* bridge */ /* synthetic */ void onReceive(Context context, Intent intent) {
+            super.onReceive(context, intent);
+        }
+    }
+
+    public static class NetworkStateProxy extends ConstraintProxy {
+        @Override // androidx.work.impl.background.systemalarm.ConstraintProxy, android.content.BroadcastReceiver
+        public /* bridge */ /* synthetic */ void onReceive(Context context, Intent intent) {
+            super.onReceive(context, intent);
+        }
+    }
+
+    public static void updateAll(Context context, List<WorkSpec> list) {
+        Iterator<WorkSpec> it = list.iterator();
+        boolean z = false;
+        boolean z2 = false;
+        boolean z3 = false;
+        boolean z4 = false;
+        while (it.hasNext()) {
+            Constraints constraints = it.next().constraints;
+            z |= constraints.requiresBatteryNotLow();
+            z2 |= constraints.requiresCharging();
+            z3 |= constraints.requiresStorageNotLow();
+            z4 |= constraints.getRequiredNetworkType() != NetworkType.NOT_REQUIRED;
+            if (z && z2 && z3 && z4) {
+                break;
+            }
+        }
+        context.sendBroadcast(ConstraintProxyUpdateReceiver.newConstraintProxyUpdateIntent(context, z, z2, z3, z4));
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/ConstraintProxyUpdateReceiver.java

@@ -0,0 +1,58 @@
+package androidx.work.impl.background.systemalarm;
+
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.work.Logger;
+import androidx.work.impl.WorkManagerImpl;
+import androidx.work.impl.background.systemalarm.ConstraintProxy;
+import androidx.work.impl.utils.PackageManagerHelper;
+
+/* loaded from: classes.dex */
+public class ConstraintProxyUpdateReceiver extends BroadcastReceiver {
+    static final String ACTION = "androidx.work.impl.background.systemalarm.UpdateProxies";
+    static final String KEY_BATTERY_CHARGING_PROXY_ENABLED = "KEY_BATTERY_CHARGING_PROXY_ENABLED";
+    static final String KEY_BATTERY_NOT_LOW_PROXY_ENABLED = "KEY_BATTERY_NOT_LOW_PROXY_ENABLED";
+    static final String KEY_NETWORK_STATE_PROXY_ENABLED = "KEY_NETWORK_STATE_PROXY_ENABLED";
+    static final String KEY_STORAGE_NOT_LOW_PROXY_ENABLED = "KEY_STORAGE_NOT_LOW_PROXY_ENABLED";
+    static final String TAG = Logger.tagWithPrefix("ConstrntProxyUpdtRecvr");
+
+    @NonNull
+    public static Intent newConstraintProxyUpdateIntent(@NonNull Context context, boolean z, boolean z2, boolean z3, boolean z4) {
+        Intent intent = new Intent(ACTION);
+        intent.setComponent(new ComponentName(context, (Class<?>) ConstraintProxyUpdateReceiver.class));
+        intent.putExtra(KEY_BATTERY_NOT_LOW_PROXY_ENABLED, z).putExtra(KEY_BATTERY_CHARGING_PROXY_ENABLED, z2).putExtra(KEY_STORAGE_NOT_LOW_PROXY_ENABLED, z3).putExtra(KEY_NETWORK_STATE_PROXY_ENABLED, z4);
+        return intent;
+    }
+
+    @Override // android.content.BroadcastReceiver
+    public void onReceive(@NonNull final Context context, @Nullable final Intent intent) {
+        String action = intent != null ? intent.getAction() : null;
+        if (!ACTION.equals(action)) {
+            Logger.get().debug(TAG, "Ignoring unknown action " + action);
+            return;
+        }
+        final BroadcastReceiver.PendingResult goAsync = goAsync();
+        WorkManagerImpl.getInstance(context).getWorkTaskExecutor().executeOnTaskThread(new Runnable() { // from class: androidx.work.impl.background.systemalarm.ConstraintProxyUpdateReceiver.1
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    boolean booleanExtra = intent.getBooleanExtra(ConstraintProxyUpdateReceiver.KEY_BATTERY_NOT_LOW_PROXY_ENABLED, false);
+                    boolean booleanExtra2 = intent.getBooleanExtra(ConstraintProxyUpdateReceiver.KEY_BATTERY_CHARGING_PROXY_ENABLED, false);
+                    boolean booleanExtra3 = intent.getBooleanExtra(ConstraintProxyUpdateReceiver.KEY_STORAGE_NOT_LOW_PROXY_ENABLED, false);
+                    boolean booleanExtra4 = intent.getBooleanExtra(ConstraintProxyUpdateReceiver.KEY_NETWORK_STATE_PROXY_ENABLED, false);
+                    Logger.get().debug(ConstraintProxyUpdateReceiver.TAG, "Updating proxies: (BatteryNotLowProxy (" + booleanExtra + "), BatteryChargingProxy (" + booleanExtra2 + "), StorageNotLowProxy (" + booleanExtra3 + "), NetworkStateProxy (" + booleanExtra4 + "), ");
+                    PackageManagerHelper.setComponentEnabled(context, ConstraintProxy.BatteryNotLowProxy.class, booleanExtra);
+                    PackageManagerHelper.setComponentEnabled(context, ConstraintProxy.BatteryChargingProxy.class, booleanExtra2);
+                    PackageManagerHelper.setComponentEnabled(context, ConstraintProxy.StorageNotLowProxy.class, booleanExtra3);
+                    PackageManagerHelper.setComponentEnabled(context, ConstraintProxy.NetworkStateProxy.class, booleanExtra4);
+                } finally {
+                    goAsync.finish();
+                }
+            }
+        });
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/ConstraintsCommandHandler.java

@@ -0,0 +1,53 @@
+package androidx.work.impl.background.systemalarm;
+
+import android.content.Context;
+import android.content.Intent;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.WorkerThread;
+import androidx.work.Clock;
+import androidx.work.Logger;
+import androidx.work.impl.background.systemalarm.SystemAlarmDispatcher;
+import androidx.work.impl.constraints.WorkConstraintsTracker;
+import androidx.work.impl.model.WorkSpec;
+import androidx.work.impl.model.WorkSpecKt;
+import java.util.ArrayList;
+import java.util.List;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+class ConstraintsCommandHandler {
+    private static final String TAG = Logger.tagWithPrefix("ConstraintsCmdHandler");
+    private final Clock mClock;
+    private final Context mContext;
+    private final SystemAlarmDispatcher mDispatcher;
+    private final int mStartId;
+    private final WorkConstraintsTracker mWorkConstraintsTracker;
+
+    public ConstraintsCommandHandler(@NonNull Context context, Clock clock, int i, @NonNull SystemAlarmDispatcher systemAlarmDispatcher) {
+        this.mContext = context;
+        this.mClock = clock;
+        this.mStartId = i;
+        this.mDispatcher = systemAlarmDispatcher;
+        this.mWorkConstraintsTracker = new WorkConstraintsTracker(systemAlarmDispatcher.getWorkManager().getTrackers());
+    }
+
+    @WorkerThread
+    public void handleConstraintsChanged() {
+        List<WorkSpec> scheduledWork = this.mDispatcher.getWorkManager().getWorkDatabase().workSpecDao().getScheduledWork();
+        ConstraintProxy.updateAll(this.mContext, scheduledWork);
+        ArrayList<WorkSpec> arrayList = new ArrayList(scheduledWork.size());
+        long currentTimeMillis = this.mClock.currentTimeMillis();
+        for (WorkSpec workSpec : scheduledWork) {
+            if (currentTimeMillis >= workSpec.calculateNextRunTime() && (!workSpec.hasConstraints() || this.mWorkConstraintsTracker.areAllConstraintsMet(workSpec))) {
+                arrayList.add(workSpec);
+            }
+        }
+        for (WorkSpec workSpec2 : arrayList) {
+            String str = workSpec2.id;
+            Intent createDelayMetIntent = CommandHandler.createDelayMetIntent(this.mContext, WorkSpecKt.generationalId(workSpec2));
+            Logger.get().debug(TAG, "Creating a delay_met command for workSpec with id (" + str + ")");
+            this.mDispatcher.getTaskExecutor().getMainThreadExecutor().execute(new SystemAlarmDispatcher.AddRunnable(this.mDispatcher, createDelayMetIntent, this.mStartId));
+        }
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/DelayMetCommandHandler$$ExternalSyntheticLambda0.java

@@ -0,0 +1,15 @@
+package androidx.work.impl.background.systemalarm;
+
+/* loaded from: classes.dex */
+public final /* synthetic */ class DelayMetCommandHandler$$ExternalSyntheticLambda0 implements Runnable {
+    public final /* synthetic */ DelayMetCommandHandler f$0;
+
+    public /* synthetic */ DelayMetCommandHandler$$ExternalSyntheticLambda0(DelayMetCommandHandler delayMetCommandHandler) {
+        this.f$0 = delayMetCommandHandler;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        this.f$0.stopWork();
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/DelayMetCommandHandler$$ExternalSyntheticLambda1.java

@@ -0,0 +1,15 @@
+package androidx.work.impl.background.systemalarm;
+
+/* loaded from: classes.dex */
+public final /* synthetic */ class DelayMetCommandHandler$$ExternalSyntheticLambda1 implements Runnable {
+    public final /* synthetic */ DelayMetCommandHandler f$0;
+
+    public /* synthetic */ DelayMetCommandHandler$$ExternalSyntheticLambda1(DelayMetCommandHandler delayMetCommandHandler) {
+        this.f$0 = delayMetCommandHandler;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        this.f$0.startWork();
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/DelayMetCommandHandler.java

@@ -0,0 +1,168 @@
+package androidx.work.impl.background.systemalarm;
+
+import android.content.Context;
+import android.os.PowerManager;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.WorkerThread;
+import androidx.work.Logger;
+import androidx.work.impl.StartStopToken;
+import androidx.work.impl.background.systemalarm.SystemAlarmDispatcher;
+import androidx.work.impl.constraints.ConstraintsState;
+import androidx.work.impl.constraints.OnConstraintsStateChangedListener;
+import androidx.work.impl.constraints.WorkConstraintsTracker;
+import androidx.work.impl.constraints.WorkConstraintsTrackerKt;
+import androidx.work.impl.constraints.trackers.Trackers;
+import androidx.work.impl.model.WorkGenerationalId;
+import androidx.work.impl.model.WorkSpec;
+import androidx.work.impl.utils.WakeLocks;
+import androidx.work.impl.utils.WorkTimer;
+import com.facebook.AuthenticationTokenClaims;
+import java.util.concurrent.Executor;
+import kotlinx.coroutines.CoroutineDispatcher;
+import kotlinx.coroutines.Job;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public class DelayMetCommandHandler implements OnConstraintsStateChangedListener, WorkTimer.TimeLimitExceededListener {
+    private static final int STATE_INITIAL = 0;
+    private static final int STATE_START_REQUESTED = 1;
+    private static final int STATE_STOP_REQUESTED = 2;
+    private static final String TAG = Logger.tagWithPrefix("DelayMetCommandHandler");
+    private final Context mContext;
+    private final CoroutineDispatcher mCoroutineDispatcher;
+    private int mCurrentState;
+    private final SystemAlarmDispatcher mDispatcher;
+    private boolean mHasConstraints;
+    private volatile Job mJob;
+    private final Object mLock;
+    private final Executor mMainThreadExecutor;
+    private final Executor mSerialExecutor;
+    private final int mStartId;
+    private final StartStopToken mToken;
+
+    @Nullable
+    private PowerManager.WakeLock mWakeLock;
+    private final WorkConstraintsTracker mWorkConstraintsTracker;
+    private final WorkGenerationalId mWorkGenerationalId;
+
+    public DelayMetCommandHandler(@NonNull Context context, int i, @NonNull SystemAlarmDispatcher systemAlarmDispatcher, @NonNull StartStopToken startStopToken) {
+        this.mContext = context;
+        this.mStartId = i;
+        this.mDispatcher = systemAlarmDispatcher;
+        this.mWorkGenerationalId = startStopToken.getId();
+        this.mToken = startStopToken;
+        Trackers trackers = systemAlarmDispatcher.getWorkManager().getTrackers();
+        this.mSerialExecutor = systemAlarmDispatcher.getTaskExecutor().getSerialTaskExecutor();
+        this.mMainThreadExecutor = systemAlarmDispatcher.getTaskExecutor().getMainThreadExecutor();
+        this.mCoroutineDispatcher = systemAlarmDispatcher.getTaskExecutor().getTaskCoroutineDispatcher();
+        this.mWorkConstraintsTracker = new WorkConstraintsTracker(trackers);
+        this.mHasConstraints = false;
+        this.mCurrentState = 0;
+        this.mLock = new Object();
+    }
+
+    @Override // androidx.work.impl.constraints.OnConstraintsStateChangedListener
+    public void onConstraintsStateChanged(@NonNull WorkSpec workSpec, @NonNull ConstraintsState constraintsState) {
+        if (constraintsState instanceof ConstraintsState.ConstraintsMet) {
+            this.mSerialExecutor.execute(new DelayMetCommandHandler$$ExternalSyntheticLambda1(this));
+        } else {
+            this.mSerialExecutor.execute(new DelayMetCommandHandler$$ExternalSyntheticLambda0(this));
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void startWork() {
+        if (this.mCurrentState == 0) {
+            this.mCurrentState = 1;
+            Logger.get().debug(TAG, "onAllConstraintsMet for " + this.mWorkGenerationalId);
+            if (this.mDispatcher.getProcessor().startWork(this.mToken)) {
+                this.mDispatcher.getWorkTimer().startTimer(this.mWorkGenerationalId, AuthenticationTokenClaims.MAX_TIME_SINCE_TOKEN_ISSUED, this);
+                return;
+            } else {
+                cleanUp();
+                return;
+            }
+        }
+        Logger.get().debug(TAG, "Already started work for " + this.mWorkGenerationalId);
+    }
+
+    public void onExecuted(boolean z) {
+        Logger.get().debug(TAG, "onExecuted " + this.mWorkGenerationalId + ", " + z);
+        cleanUp();
+        if (z) {
+            this.mMainThreadExecutor.execute(new SystemAlarmDispatcher.AddRunnable(this.mDispatcher, CommandHandler.createScheduleWorkIntent(this.mContext, this.mWorkGenerationalId), this.mStartId));
+        }
+        if (this.mHasConstraints) {
+            this.mMainThreadExecutor.execute(new SystemAlarmDispatcher.AddRunnable(this.mDispatcher, CommandHandler.createConstraintsChangedIntent(this.mContext), this.mStartId));
+        }
+    }
+
+    @Override // androidx.work.impl.utils.WorkTimer.TimeLimitExceededListener
+    public void onTimeLimitExceeded(@NonNull WorkGenerationalId workGenerationalId) {
+        Logger.get().debug(TAG, "Exceeded time limits on execution for " + workGenerationalId);
+        this.mSerialExecutor.execute(new DelayMetCommandHandler$$ExternalSyntheticLambda0(this));
+    }
+
+    @WorkerThread
+    public void handleProcessWork() {
+        String workSpecId = this.mWorkGenerationalId.getWorkSpecId();
+        this.mWakeLock = WakeLocks.newWakeLock(this.mContext, workSpecId + " (" + this.mStartId + ")");
+        Logger logger = Logger.get();
+        String str = TAG;
+        logger.debug(str, "Acquiring wakelock " + this.mWakeLock + "for WorkSpec " + workSpecId);
+        this.mWakeLock.acquire();
+        WorkSpec workSpec = this.mDispatcher.getWorkManager().getWorkDatabase().workSpecDao().getWorkSpec(workSpecId);
+        if (workSpec == null) {
+            this.mSerialExecutor.execute(new DelayMetCommandHandler$$ExternalSyntheticLambda0(this));
+            return;
+        }
+        boolean hasConstraints = workSpec.hasConstraints();
+        this.mHasConstraints = hasConstraints;
+        if (!hasConstraints) {
+            Logger.get().debug(str, "No constraints for " + workSpecId);
+            this.mSerialExecutor.execute(new DelayMetCommandHandler$$ExternalSyntheticLambda1(this));
+            return;
+        }
+        this.mJob = WorkConstraintsTrackerKt.listen(this.mWorkConstraintsTracker, workSpec, this.mCoroutineDispatcher, this);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void stopWork() {
+        String workSpecId = this.mWorkGenerationalId.getWorkSpecId();
+        if (this.mCurrentState < 2) {
+            this.mCurrentState = 2;
+            Logger logger = Logger.get();
+            String str = TAG;
+            logger.debug(str, "Stopping work for WorkSpec " + workSpecId);
+            this.mMainThreadExecutor.execute(new SystemAlarmDispatcher.AddRunnable(this.mDispatcher, CommandHandler.createStopWorkIntent(this.mContext, this.mWorkGenerationalId), this.mStartId));
+            if (this.mDispatcher.getProcessor().isEnqueued(this.mWorkGenerationalId.getWorkSpecId())) {
+                Logger.get().debug(str, "WorkSpec " + workSpecId + " needs to be rescheduled");
+                this.mMainThreadExecutor.execute(new SystemAlarmDispatcher.AddRunnable(this.mDispatcher, CommandHandler.createScheduleWorkIntent(this.mContext, this.mWorkGenerationalId), this.mStartId));
+                return;
+            }
+            Logger.get().debug(str, "Processor does not have WorkSpec " + workSpecId + ". No need to reschedule");
+            return;
+        }
+        Logger.get().debug(TAG, "Already stopped work for " + workSpecId);
+    }
+
+    private void cleanUp() {
+        synchronized (this.mLock) {
+            try {
+                if (this.mJob != null) {
+                    this.mJob.cancel(null);
+                }
+                this.mDispatcher.getWorkTimer().stopTimer(this.mWorkGenerationalId);
+                PowerManager.WakeLock wakeLock = this.mWakeLock;
+                if (wakeLock != null && wakeLock.isHeld()) {
+                    Logger.get().debug(TAG, "Releasing wakelock " + this.mWakeLock + "for WorkSpec " + this.mWorkGenerationalId);
+                    this.mWakeLock.release();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/RescheduleReceiver.java

@@ -0,0 +1,22 @@
+package androidx.work.impl.background.systemalarm;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import androidx.work.Logger;
+import androidx.work.impl.WorkManagerImpl;
+
+/* loaded from: classes.dex */
+public class RescheduleReceiver extends BroadcastReceiver {
+    private static final String TAG = Logger.tagWithPrefix("RescheduleReceiver");
+
+    @Override // android.content.BroadcastReceiver
+    public void onReceive(Context context, Intent intent) {
+        Logger.get().debug(TAG, "Received intent " + intent);
+        try {
+            WorkManagerImpl.getInstance(context).setReschedulePendingResult(goAsync());
+        } catch (IllegalStateException e) {
+            Logger.get().error(TAG, "Cannot reschedule jobs. WorkManager needs to be initialized via a ContentProvider#onCreate() or an Application#onCreate().", e);
+        }
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/SystemAlarmDispatcher.java

@@ -0,0 +1,287 @@
+package androidx.work.impl.background.systemalarm;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Looper;
+import android.os.PowerManager;
+import android.text.TextUtils;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.work.Logger;
+import androidx.work.impl.ExecutionListener;
+import androidx.work.impl.Processor;
+import androidx.work.impl.StartStopTokens;
+import androidx.work.impl.WorkLauncher;
+import androidx.work.impl.WorkLauncherImpl;
+import androidx.work.impl.WorkManagerImpl;
+import androidx.work.impl.model.WorkGenerationalId;
+import androidx.work.impl.utils.WakeLocks;
+import androidx.work.impl.utils.WorkTimer;
+import androidx.work.impl.utils.taskexecutor.SerialExecutor;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Executor;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public class SystemAlarmDispatcher implements ExecutionListener {
+    private static final int DEFAULT_START_ID = 0;
+    private static final String KEY_START_ID = "KEY_START_ID";
+    private static final String PROCESS_COMMAND_TAG = "ProcessCommand";
+    static final String TAG = Logger.tagWithPrefix("SystemAlarmDispatcher");
+    final CommandHandler mCommandHandler;
+
+    @Nullable
+    private CommandsCompletedListener mCompletedListener;
+    final Context mContext;
+    Intent mCurrentIntent;
+    final List<Intent> mIntents;
+    private final Processor mProcessor;
+    private StartStopTokens mStartStopTokens;
+    final TaskExecutor mTaskExecutor;
+    private final WorkLauncher mWorkLauncher;
+    private final WorkManagerImpl mWorkManager;
+    private final WorkTimer mWorkTimer;
+
+    public interface CommandsCompletedListener {
+        void onAllCommandsCompleted();
+    }
+
+    public Processor getProcessor() {
+        return this.mProcessor;
+    }
+
+    public TaskExecutor getTaskExecutor() {
+        return this.mTaskExecutor;
+    }
+
+    public WorkManagerImpl getWorkManager() {
+        return this.mWorkManager;
+    }
+
+    public WorkTimer getWorkTimer() {
+        return this.mWorkTimer;
+    }
+
+    public WorkLauncher getWorkerLauncher() {
+        return this.mWorkLauncher;
+    }
+
+    public SystemAlarmDispatcher(@NonNull Context context) {
+        this(context, null, null, null);
+    }
+
+    @VisibleForTesting
+    public SystemAlarmDispatcher(@NonNull Context context, @Nullable Processor processor, @Nullable WorkManagerImpl workManagerImpl, @Nullable WorkLauncher workLauncher) {
+        Context applicationContext = context.getApplicationContext();
+        this.mContext = applicationContext;
+        this.mStartStopTokens = StartStopTokens.create();
+        workManagerImpl = workManagerImpl == null ? WorkManagerImpl.getInstance(context) : workManagerImpl;
+        this.mWorkManager = workManagerImpl;
+        this.mCommandHandler = new CommandHandler(applicationContext, workManagerImpl.getConfiguration().getClock(), this.mStartStopTokens);
+        this.mWorkTimer = new WorkTimer(workManagerImpl.getConfiguration().getRunnableScheduler());
+        processor = processor == null ? workManagerImpl.getProcessor() : processor;
+        this.mProcessor = processor;
+        TaskExecutor workTaskExecutor = workManagerImpl.getWorkTaskExecutor();
+        this.mTaskExecutor = workTaskExecutor;
+        this.mWorkLauncher = workLauncher == null ? new WorkLauncherImpl(processor, workTaskExecutor) : workLauncher;
+        processor.addExecutionListener(this);
+        this.mIntents = new ArrayList();
+        this.mCurrentIntent = null;
+    }
+
+    public void onDestroy() {
+        Logger.get().debug(TAG, "Destroying SystemAlarmDispatcher");
+        this.mProcessor.removeExecutionListener(this);
+        this.mCompletedListener = null;
+    }
+
+    @Override // androidx.work.impl.ExecutionListener
+    public void onExecuted(@NonNull WorkGenerationalId workGenerationalId, boolean z) {
+        this.mTaskExecutor.getMainThreadExecutor().execute(new AddRunnable(this, CommandHandler.createExecutionCompletedIntent(this.mContext, workGenerationalId, z), 0));
+    }
+
+    @MainThread
+    public boolean add(@NonNull Intent intent, int i) {
+        Logger logger = Logger.get();
+        String str = TAG;
+        logger.debug(str, "Adding command " + intent + " (" + i + ")");
+        assertMainThread();
+        String action = intent.getAction();
+        if (TextUtils.isEmpty(action)) {
+            Logger.get().warning(str, "Unknown command. Ignoring");
+            return false;
+        }
+        if ("ACTION_CONSTRAINTS_CHANGED".equals(action) && hasIntentWithAction("ACTION_CONSTRAINTS_CHANGED")) {
+            return false;
+        }
+        intent.putExtra(KEY_START_ID, i);
+        synchronized (this.mIntents) {
+            try {
+                boolean z = !this.mIntents.isEmpty();
+                this.mIntents.add(intent);
+                if (!z) {
+                    processCommand();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return true;
+    }
+
+    public void setCompletedListener(@NonNull CommandsCompletedListener commandsCompletedListener) {
+        if (this.mCompletedListener != null) {
+            Logger.get().error(TAG, "A completion listener for SystemAlarmDispatcher already exists.");
+        } else {
+            this.mCompletedListener = commandsCompletedListener;
+        }
+    }
+
+    @MainThread
+    public void dequeueAndCheckForCompletion() {
+        Logger logger = Logger.get();
+        String str = TAG;
+        logger.debug(str, "Checking if commands are complete.");
+        assertMainThread();
+        synchronized (this.mIntents) {
+            try {
+                if (this.mCurrentIntent != null) {
+                    Logger.get().debug(str, "Removing command " + this.mCurrentIntent);
+                    if (!this.mIntents.remove(0).equals(this.mCurrentIntent)) {
+                        throw new IllegalStateException("Dequeue-d command is not the first.");
+                    }
+                    this.mCurrentIntent = null;
+                }
+                SerialExecutor serialTaskExecutor = this.mTaskExecutor.getSerialTaskExecutor();
+                if (!this.mCommandHandler.hasPendingCommands() && this.mIntents.isEmpty() && !serialTaskExecutor.hasPendingTasks()) {
+                    Logger.get().debug(str, "No more commands & intents.");
+                    CommandsCompletedListener commandsCompletedListener = this.mCompletedListener;
+                    if (commandsCompletedListener != null) {
+                        commandsCompletedListener.onAllCommandsCompleted();
+                    }
+                } else if (!this.mIntents.isEmpty()) {
+                    processCommand();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @MainThread
+    private void processCommand() {
+        assertMainThread();
+        PowerManager.WakeLock newWakeLock = WakeLocks.newWakeLock(this.mContext, PROCESS_COMMAND_TAG);
+        try {
+            newWakeLock.acquire();
+            this.mWorkManager.getWorkTaskExecutor().executeOnTaskThread(new Runnable() { // from class: androidx.work.impl.background.systemalarm.SystemAlarmDispatcher.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    Executor mainThreadExecutor;
+                    DequeueAndCheckForCompletion dequeueAndCheckForCompletion;
+                    synchronized (SystemAlarmDispatcher.this.mIntents) {
+                        SystemAlarmDispatcher systemAlarmDispatcher = SystemAlarmDispatcher.this;
+                        systemAlarmDispatcher.mCurrentIntent = systemAlarmDispatcher.mIntents.get(0);
+                    }
+                    Intent intent = SystemAlarmDispatcher.this.mCurrentIntent;
+                    if (intent != null) {
+                        String action = intent.getAction();
+                        int intExtra = SystemAlarmDispatcher.this.mCurrentIntent.getIntExtra(SystemAlarmDispatcher.KEY_START_ID, 0);
+                        Logger logger = Logger.get();
+                        String str = SystemAlarmDispatcher.TAG;
+                        logger.debug(str, "Processing command " + SystemAlarmDispatcher.this.mCurrentIntent + ", " + intExtra);
+                        PowerManager.WakeLock newWakeLock2 = WakeLocks.newWakeLock(SystemAlarmDispatcher.this.mContext, action + " (" + intExtra + ")");
+                        try {
+                            Logger.get().debug(str, "Acquiring operation wake lock (" + action + ") " + newWakeLock2);
+                            newWakeLock2.acquire();
+                            SystemAlarmDispatcher systemAlarmDispatcher2 = SystemAlarmDispatcher.this;
+                            systemAlarmDispatcher2.mCommandHandler.onHandleIntent(systemAlarmDispatcher2.mCurrentIntent, intExtra, systemAlarmDispatcher2);
+                            Logger.get().debug(str, "Releasing operation wake lock (" + action + ") " + newWakeLock2);
+                            newWakeLock2.release();
+                            mainThreadExecutor = SystemAlarmDispatcher.this.mTaskExecutor.getMainThreadExecutor();
+                            dequeueAndCheckForCompletion = new DequeueAndCheckForCompletion(SystemAlarmDispatcher.this);
+                        } catch (Throwable th) {
+                            try {
+                                Logger logger2 = Logger.get();
+                                String str2 = SystemAlarmDispatcher.TAG;
+                                logger2.error(str2, "Unexpected error in onHandleIntent", th);
+                                Logger.get().debug(str2, "Releasing operation wake lock (" + action + ") " + newWakeLock2);
+                                newWakeLock2.release();
+                                mainThreadExecutor = SystemAlarmDispatcher.this.mTaskExecutor.getMainThreadExecutor();
+                                dequeueAndCheckForCompletion = new DequeueAndCheckForCompletion(SystemAlarmDispatcher.this);
+                            } catch (Throwable th2) {
+                                Logger.get().debug(SystemAlarmDispatcher.TAG, "Releasing operation wake lock (" + action + ") " + newWakeLock2);
+                                newWakeLock2.release();
+                                SystemAlarmDispatcher.this.mTaskExecutor.getMainThreadExecutor().execute(new DequeueAndCheckForCompletion(SystemAlarmDispatcher.this));
+                                throw th2;
+                            }
+                        }
+                        mainThreadExecutor.execute(dequeueAndCheckForCompletion);
+                    }
+                }
+            });
+        } finally {
+            newWakeLock.release();
+        }
+    }
+
+    @MainThread
+    private boolean hasIntentWithAction(@NonNull String str) {
+        assertMainThread();
+        synchronized (this.mIntents) {
+            try {
+                Iterator<Intent> it = this.mIntents.iterator();
+                while (it.hasNext()) {
+                    if (str.equals(it.next().getAction())) {
+                        return true;
+                    }
+                }
+                return false;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private void assertMainThread() {
+        if (Looper.getMainLooper().getThread() != Thread.currentThread()) {
+            throw new IllegalStateException("Needs to be invoked on the main thread.");
+        }
+    }
+
+    public static class DequeueAndCheckForCompletion implements Runnable {
+        private final SystemAlarmDispatcher mDispatcher;
+
+        public DequeueAndCheckForCompletion(@NonNull SystemAlarmDispatcher systemAlarmDispatcher) {
+            this.mDispatcher = systemAlarmDispatcher;
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            this.mDispatcher.dequeueAndCheckForCompletion();
+        }
+    }
+
+    public static class AddRunnable implements Runnable {
+        private final SystemAlarmDispatcher mDispatcher;
+        private final Intent mIntent;
+        private final int mStartId;
+
+        public AddRunnable(@NonNull SystemAlarmDispatcher systemAlarmDispatcher, @NonNull Intent intent, int i) {
+            this.mDispatcher = systemAlarmDispatcher;
+            this.mIntent = intent;
+            this.mStartId = i;
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            this.mDispatcher.add(this.mIntent, this.mStartId);
+        }
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/SystemAlarmScheduler.java

@@ -0,0 +1,42 @@
+package androidx.work.impl.background.systemalarm;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.work.Logger;
+import androidx.work.impl.Scheduler;
+import androidx.work.impl.model.WorkSpec;
+import androidx.work.impl.model.WorkSpecKt;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public class SystemAlarmScheduler implements Scheduler {
+    private static final String TAG = Logger.tagWithPrefix("SystemAlarmScheduler");
+    private final Context mContext;
+
+    @Override // androidx.work.impl.Scheduler
+    public boolean hasLimitedSchedulingSlots() {
+        return true;
+    }
+
+    public SystemAlarmScheduler(@NonNull Context context) {
+        this.mContext = context.getApplicationContext();
+    }
+
+    @Override // androidx.work.impl.Scheduler
+    public void schedule(@NonNull WorkSpec... workSpecArr) {
+        for (WorkSpec workSpec : workSpecArr) {
+            scheduleWorkSpec(workSpec);
+        }
+    }
+
+    @Override // androidx.work.impl.Scheduler
+    public void cancel(@NonNull String str) {
+        this.mContext.startService(CommandHandler.createStopWorkIntent(this.mContext, str));
+    }
+
+    private void scheduleWorkSpec(@NonNull WorkSpec workSpec) {
+        Logger.get().debug(TAG, "Scheduling work with workSpecId " + workSpec.id);
+        this.mContext.startService(CommandHandler.createScheduleWorkIntent(this.mContext, WorkSpecKt.generationalId(workSpec)));
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/SystemAlarmService.java

@@ -0,0 +1,63 @@
+package androidx.work.impl.background.systemalarm;
+
+import android.content.Intent;
+import androidx.annotation.MainThread;
+import androidx.annotation.RestrictTo;
+import androidx.lifecycle.LifecycleService;
+import androidx.work.Logger;
+import androidx.work.impl.background.systemalarm.SystemAlarmDispatcher;
+import androidx.work.impl.utils.WakeLocks;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public class SystemAlarmService extends LifecycleService implements SystemAlarmDispatcher.CommandsCompletedListener {
+    private static final String TAG = Logger.tagWithPrefix("SystemAlarmService");
+    private SystemAlarmDispatcher mDispatcher;
+    private boolean mIsShutdown;
+
+    @Override // androidx.lifecycle.LifecycleService, android.app.Service
+    public void onCreate() {
+        super.onCreate();
+        initializeDispatcher();
+        this.mIsShutdown = false;
+    }
+
+    @Override // androidx.lifecycle.LifecycleService, android.app.Service
+    public void onDestroy() {
+        super.onDestroy();
+        this.mIsShutdown = true;
+        this.mDispatcher.onDestroy();
+    }
+
+    @Override // androidx.lifecycle.LifecycleService, android.app.Service
+    public int onStartCommand(Intent intent, int i, int i2) {
+        super.onStartCommand(intent, i, i2);
+        if (this.mIsShutdown) {
+            Logger.get().info(TAG, "Re-initializing SystemAlarmDispatcher after a request to shut-down.");
+            this.mDispatcher.onDestroy();
+            initializeDispatcher();
+            this.mIsShutdown = false;
+        }
+        if (intent == null) {
+            return 3;
+        }
+        this.mDispatcher.add(intent, i2);
+        return 3;
+    }
+
+    @Override // androidx.work.impl.background.systemalarm.SystemAlarmDispatcher.CommandsCompletedListener
+    @MainThread
+    public void onAllCommandsCompleted() {
+        this.mIsShutdown = true;
+        Logger.get().debug(TAG, "All commands completed in dispatcher");
+        WakeLocks.checkWakeLocks();
+        stopSelf();
+    }
+
+    @MainThread
+    private void initializeDispatcher() {
+        SystemAlarmDispatcher systemAlarmDispatcher = new SystemAlarmDispatcher(this);
+        this.mDispatcher = systemAlarmDispatcher;
+        systemAlarmDispatcher.setCompletedListener(this);
+    }
+}

decompiled/sources/androidx/work/impl/background/systemalarm/package-info.java

@@ -0,0 +1,5 @@
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+package androidx.work.impl.background.systemalarm;
+
+import androidx.annotation.RestrictTo;
+