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/greedy/DelayedWorkTracker.java

@@ -0,0 +1,50 @@
+package androidx.work.impl.background.greedy;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.work.Clock;
+import androidx.work.Logger;
+import androidx.work.RunnableScheduler;
+import androidx.work.impl.Scheduler;
+import androidx.work.impl.model.WorkSpec;
+import java.util.HashMap;
+import java.util.Map;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public class DelayedWorkTracker {
+    static final String TAG = Logger.tagWithPrefix("DelayedWorkTracker");
+    private final Clock mClock;
+    final Scheduler mImmediateScheduler;
+    private final RunnableScheduler mRunnableScheduler;
+    private final Map<String, Runnable> mRunnables = new HashMap();
+
+    public DelayedWorkTracker(@NonNull Scheduler scheduler, @NonNull RunnableScheduler runnableScheduler, @NonNull Clock clock) {
+        this.mImmediateScheduler = scheduler;
+        this.mRunnableScheduler = runnableScheduler;
+        this.mClock = clock;
+    }
+
+    public void schedule(@NonNull final WorkSpec workSpec, long j) {
+        Runnable remove = this.mRunnables.remove(workSpec.id);
+        if (remove != null) {
+            this.mRunnableScheduler.cancel(remove);
+        }
+        Runnable runnable = new Runnable() { // from class: androidx.work.impl.background.greedy.DelayedWorkTracker.1
+            @Override // java.lang.Runnable
+            public void run() {
+                Logger.get().debug(DelayedWorkTracker.TAG, "Scheduling work " + workSpec.id);
+                DelayedWorkTracker.this.mImmediateScheduler.schedule(workSpec);
+            }
+        };
+        this.mRunnables.put(workSpec.id, runnable);
+        this.mRunnableScheduler.scheduleWithDelay(j - this.mClock.currentTimeMillis(), runnable);
+    }
+
+    public void unschedule(@NonNull String str) {
+        Runnable remove = this.mRunnables.remove(str);
+        if (remove != null) {
+            this.mRunnableScheduler.cancel(remove);
+        }
+    }
+}

decompiled/sources/androidx/work/impl/background/greedy/GreedyScheduler.java

@@ -0,0 +1,242 @@
+package androidx.work.impl.background.greedy;
+
+import android.content.Context;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.work.Configuration;
+import androidx.work.Constraints;
+import androidx.work.Logger;
+import androidx.work.RunnableScheduler;
+import androidx.work.WorkInfo;
+import androidx.work.WorkRequest;
+import androidx.work.impl.ExecutionListener;
+import androidx.work.impl.Processor;
+import androidx.work.impl.Scheduler;
+import androidx.work.impl.StartStopToken;
+import androidx.work.impl.StartStopTokens;
+import androidx.work.impl.WorkLauncher;
+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.model.WorkSpecKt;
+import androidx.work.impl.utils.ProcessUtils;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import kotlinx.coroutines.Job;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public class GreedyScheduler implements Scheduler, OnConstraintsStateChangedListener, ExecutionListener {
+    private static final int NON_THROTTLE_RUN_ATTEMPT_COUNT = 5;
+    private static final String TAG = Logger.tagWithPrefix("GreedyScheduler");
+    private final Configuration mConfiguration;
+    private final WorkConstraintsTracker mConstraintsTracker;
+    private final Context mContext;
+    private DelayedWorkTracker mDelayedWorkTracker;
+    Boolean mInDefaultProcess;
+    private final Processor mProcessor;
+    private boolean mRegisteredExecutionListener;
+    private final TaskExecutor mTaskExecutor;
+    private final TimeLimiter mTimeLimiter;
+    private final WorkLauncher mWorkLauncher;
+    private final Map<WorkGenerationalId, Job> mConstrainedWorkSpecs = new HashMap();
+    private final Object mLock = new Object();
+    private final StartStopTokens mStartStopTokens = StartStopTokens.create();
+    private final Map<WorkGenerationalId, AttemptData> mFirstRunAttempts = new HashMap();
+
+    @Override // androidx.work.impl.Scheduler
+    public boolean hasLimitedSchedulingSlots() {
+        return false;
+    }
+
+    @VisibleForTesting
+    public void setDelayedWorkTracker(@NonNull DelayedWorkTracker delayedWorkTracker) {
+        this.mDelayedWorkTracker = delayedWorkTracker;
+    }
+
+    public GreedyScheduler(@NonNull Context context, @NonNull Configuration configuration, @NonNull Trackers trackers, @NonNull Processor processor, @NonNull WorkLauncher workLauncher, @NonNull TaskExecutor taskExecutor) {
+        this.mContext = context;
+        RunnableScheduler runnableScheduler = configuration.getRunnableScheduler();
+        this.mDelayedWorkTracker = new DelayedWorkTracker(this, runnableScheduler, configuration.getClock());
+        this.mTimeLimiter = new TimeLimiter(runnableScheduler, workLauncher);
+        this.mTaskExecutor = taskExecutor;
+        this.mConstraintsTracker = new WorkConstraintsTracker(trackers);
+        this.mConfiguration = configuration;
+        this.mProcessor = processor;
+        this.mWorkLauncher = workLauncher;
+    }
+
+    @Override // androidx.work.impl.Scheduler
+    public void schedule(@NonNull WorkSpec... workSpecArr) {
+        if (this.mInDefaultProcess == null) {
+            checkDefaultProcess();
+        }
+        if (!this.mInDefaultProcess.booleanValue()) {
+            Logger.get().info(TAG, "Ignoring schedule request in a secondary process");
+            return;
+        }
+        registerExecutionListenerIfNeeded();
+        HashSet<WorkSpec> hashSet = new HashSet();
+        HashSet hashSet2 = new HashSet();
+        for (WorkSpec workSpec : workSpecArr) {
+            if (!this.mStartStopTokens.contains(WorkSpecKt.generationalId(workSpec))) {
+                long max = Math.max(workSpec.calculateNextRunTime(), throttleIfNeeded(workSpec));
+                long currentTimeMillis = this.mConfiguration.getClock().currentTimeMillis();
+                if (workSpec.state == WorkInfo.State.ENQUEUED) {
+                    if (currentTimeMillis < max) {
+                        DelayedWorkTracker delayedWorkTracker = this.mDelayedWorkTracker;
+                        if (delayedWorkTracker != null) {
+                            delayedWorkTracker.schedule(workSpec, max);
+                        }
+                    } else if (workSpec.hasConstraints()) {
+                        Constraints constraints = workSpec.constraints;
+                        if (constraints.requiresDeviceIdle()) {
+                            Logger.get().debug(TAG, "Ignoring " + workSpec + ". Requires device idle.");
+                        } else if (constraints.hasContentUriTriggers()) {
+                            Logger.get().debug(TAG, "Ignoring " + workSpec + ". Requires ContentUri triggers.");
+                        } else {
+                            hashSet.add(workSpec);
+                            hashSet2.add(workSpec.id);
+                        }
+                    } else if (!this.mStartStopTokens.contains(WorkSpecKt.generationalId(workSpec))) {
+                        Logger.get().debug(TAG, "Starting work for " + workSpec.id);
+                        StartStopToken startStopToken = this.mStartStopTokens.tokenFor(workSpec);
+                        this.mTimeLimiter.track(startStopToken);
+                        this.mWorkLauncher.startWork(startStopToken);
+                    }
+                }
+            }
+        }
+        synchronized (this.mLock) {
+            try {
+                if (!hashSet.isEmpty()) {
+                    Logger.get().debug(TAG, "Starting tracking for " + TextUtils.join(",", hashSet2));
+                    for (WorkSpec workSpec2 : hashSet) {
+                        WorkGenerationalId generationalId = WorkSpecKt.generationalId(workSpec2);
+                        if (!this.mConstrainedWorkSpecs.containsKey(generationalId)) {
+                            this.mConstrainedWorkSpecs.put(generationalId, WorkConstraintsTrackerKt.listen(this.mConstraintsTracker, workSpec2, this.mTaskExecutor.getTaskCoroutineDispatcher(), this));
+                        }
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private void checkDefaultProcess() {
+        this.mInDefaultProcess = Boolean.valueOf(ProcessUtils.isDefaultProcess(this.mContext, this.mConfiguration));
+    }
+
+    @Override // androidx.work.impl.Scheduler
+    public void cancel(@NonNull String str) {
+        if (this.mInDefaultProcess == null) {
+            checkDefaultProcess();
+        }
+        if (!this.mInDefaultProcess.booleanValue()) {
+            Logger.get().info(TAG, "Ignoring schedule request in non-main process");
+            return;
+        }
+        registerExecutionListenerIfNeeded();
+        Logger.get().debug(TAG, "Cancelling work ID " + str);
+        DelayedWorkTracker delayedWorkTracker = this.mDelayedWorkTracker;
+        if (delayedWorkTracker != null) {
+            delayedWorkTracker.unschedule(str);
+        }
+        for (StartStopToken startStopToken : this.mStartStopTokens.remove(str)) {
+            this.mTimeLimiter.cancel(startStopToken);
+            this.mWorkLauncher.stopWork(startStopToken);
+        }
+    }
+
+    @Override // androidx.work.impl.constraints.OnConstraintsStateChangedListener
+    public void onConstraintsStateChanged(@NonNull WorkSpec workSpec, @NonNull ConstraintsState constraintsState) {
+        WorkGenerationalId generationalId = WorkSpecKt.generationalId(workSpec);
+        if (constraintsState instanceof ConstraintsState.ConstraintsMet) {
+            if (this.mStartStopTokens.contains(generationalId)) {
+                return;
+            }
+            Logger.get().debug(TAG, "Constraints met: Scheduling work ID " + generationalId);
+            StartStopToken startStopToken = this.mStartStopTokens.tokenFor(generationalId);
+            this.mTimeLimiter.track(startStopToken);
+            this.mWorkLauncher.startWork(startStopToken);
+            return;
+        }
+        Logger.get().debug(TAG, "Constraints not met: Cancelling work ID " + generationalId);
+        StartStopToken remove = this.mStartStopTokens.remove(generationalId);
+        if (remove != null) {
+            this.mTimeLimiter.cancel(remove);
+            this.mWorkLauncher.stopWorkWithReason(remove, ((ConstraintsState.ConstraintsNotMet) constraintsState).getReason());
+        }
+    }
+
+    @Override // androidx.work.impl.ExecutionListener
+    public void onExecuted(@NonNull WorkGenerationalId workGenerationalId, boolean z) {
+        StartStopToken remove = this.mStartStopTokens.remove(workGenerationalId);
+        if (remove != null) {
+            this.mTimeLimiter.cancel(remove);
+        }
+        removeConstraintTrackingFor(workGenerationalId);
+        if (z) {
+            return;
+        }
+        synchronized (this.mLock) {
+            this.mFirstRunAttempts.remove(workGenerationalId);
+        }
+    }
+
+    private void removeConstraintTrackingFor(@NonNull WorkGenerationalId workGenerationalId) {
+        Job remove;
+        synchronized (this.mLock) {
+            remove = this.mConstrainedWorkSpecs.remove(workGenerationalId);
+        }
+        if (remove != null) {
+            Logger.get().debug(TAG, "Stopping tracking for " + workGenerationalId);
+            remove.cancel(null);
+        }
+    }
+
+    private void registerExecutionListenerIfNeeded() {
+        if (this.mRegisteredExecutionListener) {
+            return;
+        }
+        this.mProcessor.addExecutionListener(this);
+        this.mRegisteredExecutionListener = true;
+    }
+
+    private long throttleIfNeeded(WorkSpec workSpec) {
+        long max;
+        synchronized (this.mLock) {
+            try {
+                WorkGenerationalId generationalId = WorkSpecKt.generationalId(workSpec);
+                AttemptData attemptData = this.mFirstRunAttempts.get(generationalId);
+                if (attemptData == null) {
+                    attemptData = new AttemptData(workSpec.runAttemptCount, this.mConfiguration.getClock().currentTimeMillis());
+                    this.mFirstRunAttempts.put(generationalId, attemptData);
+                }
+                max = attemptData.mTimeStamp + (Math.max((workSpec.runAttemptCount - attemptData.mRunAttemptCount) - 5, 0) * WorkRequest.DEFAULT_BACKOFF_DELAY_MILLIS);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return max;
+    }
+
+    public static class AttemptData {
+        final int mRunAttemptCount;
+        final long mTimeStamp;
+
+        private AttemptData(int i, long j) {
+            this.mRunAttemptCount = i;
+            this.mTimeStamp = j;
+        }
+    }
+}

decompiled/sources/androidx/work/impl/background/greedy/TimeLimiter.java

@@ -0,0 +1,72 @@
+package androidx.work.impl.background.greedy;
+
+import androidx.work.RunnableScheduler;
+import androidx.work.impl.StartStopToken;
+import androidx.work.impl.WorkLauncher;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nTimeLimiter.kt\nKotlin\n*S Kotlin\n*F\n+ 1 TimeLimiter.kt\nandroidx/work/impl/background/greedy/TimeLimiter\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,45:1\n1#2:46\n*E\n"})
+/* loaded from: classes.dex */
+public final class TimeLimiter {
+    private final WorkLauncher launcher;
+    private final Object lock;
+    private final RunnableScheduler runnableScheduler;
+    private final long timeoutMs;
+    private final Map<StartStopToken, Runnable> tracked;
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public TimeLimiter(RunnableScheduler runnableScheduler, WorkLauncher launcher) {
+        this(runnableScheduler, launcher, 0L, 4, null);
+        Intrinsics.checkNotNullParameter(runnableScheduler, "runnableScheduler");
+        Intrinsics.checkNotNullParameter(launcher, "launcher");
+    }
+
+    public TimeLimiter(RunnableScheduler runnableScheduler, WorkLauncher launcher, long j) {
+        Intrinsics.checkNotNullParameter(runnableScheduler, "runnableScheduler");
+        Intrinsics.checkNotNullParameter(launcher, "launcher");
+        this.runnableScheduler = runnableScheduler;
+        this.launcher = launcher;
+        this.timeoutMs = j;
+        this.lock = new Object();
+        this.tracked = new LinkedHashMap();
+    }
+
+    public /* synthetic */ TimeLimiter(RunnableScheduler runnableScheduler, WorkLauncher workLauncher, long j, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(runnableScheduler, workLauncher, (i & 4) != 0 ? TimeUnit.MINUTES.toMillis(90L) : j);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void track$lambda$0(TimeLimiter timeLimiter, StartStopToken startStopToken) {
+        timeLimiter.launcher.stopWork(startStopToken, 3);
+    }
+
+    public final void track(final StartStopToken token) {
+        Intrinsics.checkNotNullParameter(token, "token");
+        Runnable runnable = new Runnable() { // from class: androidx.work.impl.background.greedy.TimeLimiter$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                TimeLimiter.track$lambda$0(TimeLimiter.this, token);
+            }
+        };
+        synchronized (this.lock) {
+            this.tracked.put(token, runnable);
+        }
+        this.runnableScheduler.scheduleWithDelay(this.timeoutMs, runnable);
+    }
+
+    public final void cancel(StartStopToken token) {
+        Runnable remove;
+        Intrinsics.checkNotNullParameter(token, "token");
+        synchronized (this.lock) {
+            remove = this.tracked.remove(token);
+        }
+        if (remove != null) {
+            this.runnableScheduler.cancel(remove);
+        }
+    }
+}

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

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

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;
+

decompiled/sources/androidx/work/impl/background/systemjob/JobScheduler21.java

@@ -0,0 +1,23 @@
+package androidx.work.impl.background.systemjob;
+
+import android.app.job.JobInfo;
+import android.app.job.JobScheduler;
+import androidx.annotation.RequiresApi;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+
+@RequiresApi(21)
+/* loaded from: classes.dex */
+final class JobScheduler21 {
+    public static final JobScheduler21 INSTANCE = new JobScheduler21();
+
+    private JobScheduler21() {
+    }
+
+    public final List<JobInfo> getAllPendingJobs(JobScheduler jobScheduler) {
+        Intrinsics.checkNotNullParameter(jobScheduler, "jobScheduler");
+        List<JobInfo> allPendingJobs = jobScheduler.getAllPendingJobs();
+        Intrinsics.checkNotNullExpressionValue(allPendingJobs, "jobScheduler.allPendingJobs");
+        return allPendingJobs;
+    }
+}

decompiled/sources/androidx/work/impl/background/systemjob/JobScheduler34$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.work.impl.background.systemjob;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class JobScheduler34$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/work/impl/background/systemjob/JobScheduler34.java

@@ -0,0 +1,22 @@
+package androidx.work.impl.background.systemjob;
+
+import android.app.job.JobScheduler;
+import androidx.annotation.RequiresApi;
+import kotlin.jvm.internal.Intrinsics;
+
+@RequiresApi(34)
+/* loaded from: classes.dex */
+final class JobScheduler34 {
+    public static final JobScheduler34 INSTANCE = new JobScheduler34();
+
+    private JobScheduler34() {
+    }
+
+    public final JobScheduler forNamespace(JobScheduler jobScheduler) {
+        JobScheduler forNamespace;
+        Intrinsics.checkNotNullParameter(jobScheduler, "jobScheduler");
+        forNamespace = jobScheduler.forNamespace(JobSchedulerExtKt.WORKMANAGER_NAMESPACE);
+        Intrinsics.checkNotNullExpressionValue(forNamespace, "jobScheduler.forNamespace(WORKMANAGER_NAMESPACE)");
+        return forNamespace;
+    }
+}

decompiled/sources/androidx/work/impl/background/systemjob/JobSchedulerExtKt.java

@@ -0,0 +1,91 @@
+package androidx.work.impl.background.systemjob;
+
+import android.app.job.JobInfo;
+import android.app.job.JobScheduler;
+import android.content.Context;
+import android.os.Build;
+import androidx.annotation.RequiresApi;
+import androidx.work.Configuration;
+import androidx.work.Logger;
+import androidx.work.impl.WorkDatabase;
+import com.ironsource.mediationsdk.utils.IronSourceConstants;
+import java.util.List;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nJobSchedulerExt.kt\nKotlin\n*S Kotlin\n*F\n+ 1 JobSchedulerExt.kt\nandroidx/work/impl/background/systemjob/JobSchedulerExtKt\n+ 2 LoggerExt.kt\nandroidx/work/LoggerExtKt\n*L\n1#1,127:1\n32#2:128\n*S KotlinDebug\n*F\n+ 1 JobSchedulerExt.kt\nandroidx/work/impl/background/systemjob/JobSchedulerExtKt\n*L\n70#1:128\n*E\n"})
+/* loaded from: classes.dex */
+public final class JobSchedulerExtKt {
+    private static final String TAG;
+    public static final String WORKMANAGER_NAMESPACE = "androidx.work.systemjobscheduler";
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("SystemJobScheduler");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"SystemJobScheduler\")");
+        TAG = tagWithPrefix;
+    }
+
+    @RequiresApi(21)
+    public static final JobScheduler getWmJobScheduler(Context context) {
+        Intrinsics.checkNotNullParameter(context, "<this>");
+        Object systemService = context.getSystemService("jobscheduler");
+        Intrinsics.checkNotNull(systemService, "null cannot be cast to non-null type android.app.job.JobScheduler");
+        JobScheduler jobScheduler = (JobScheduler) systemService;
+        return Build.VERSION.SDK_INT >= 34 ? JobScheduler34.INSTANCE.forNamespace(jobScheduler) : jobScheduler;
+    }
+
+    @RequiresApi(21)
+    public static final List<JobInfo> getSafePendingJobs(JobScheduler jobScheduler) {
+        Intrinsics.checkNotNullParameter(jobScheduler, "<this>");
+        try {
+            return JobScheduler21.INSTANCE.getAllPendingJobs(jobScheduler);
+        } catch (Throwable th) {
+            Logger.get().error(TAG, "getAllPendingJobs() is not reliable on this device.", th);
+            return null;
+        }
+    }
+
+    @RequiresApi(23)
+    public static final String createErrorMessage(Context context, WorkDatabase workDatabase, Configuration configuration) {
+        String str;
+        List listOfNotNull;
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(workDatabase, "workDatabase");
+        Intrinsics.checkNotNullParameter(configuration, "configuration");
+        int i = Build.VERSION.SDK_INT;
+        int i2 = i >= 31 ? IronSourceConstants.REWARDED_VIDEO_DAILY_CAPPED : 100;
+        int size = workDatabase.workSpecDao().getScheduledWork().size();
+        String str2 = "<faulty JobScheduler failed to getPendingJobs>";
+        if (i >= 34) {
+            JobScheduler wmJobScheduler = getWmJobScheduler(context);
+            List<JobInfo> safePendingJobs = getSafePendingJobs(wmJobScheduler);
+            if (safePendingJobs != null) {
+                List<JobInfo> pendingJobs = SystemJobScheduler.getPendingJobs(context, wmJobScheduler);
+                int size2 = pendingJobs != null ? safePendingJobs.size() - pendingJobs.size() : 0;
+                String str3 = null;
+                if (size2 == 0) {
+                    str = null;
+                } else {
+                    str = size2 + " of which are not owned by WorkManager";
+                }
+                Object systemService = context.getSystemService("jobscheduler");
+                Intrinsics.checkNotNull(systemService, "null cannot be cast to non-null type android.app.job.JobScheduler");
+                List<JobInfo> pendingJobs2 = SystemJobScheduler.getPendingJobs(context, (JobScheduler) systemService);
+                int size3 = pendingJobs2 != null ? pendingJobs2.size() : 0;
+                if (size3 != 0) {
+                    str3 = size3 + " from WorkManager in the default namespace";
+                }
+                listOfNotNull = CollectionsKt__CollectionsKt.listOfNotNull(safePendingJobs.size() + " jobs in \"androidx.work.systemjobscheduler\" namespace", str, str3);
+                str2 = CollectionsKt___CollectionsKt.joinToString$default(listOfNotNull, ",\n", null, null, 0, null, null, 62, null);
+            }
+        } else {
+            List<JobInfo> pendingJobs3 = SystemJobScheduler.getPendingJobs(context, getWmJobScheduler(context));
+            if (pendingJobs3 != null) {
+                str2 = pendingJobs3.size() + " jobs from WorkManager";
+            }
+        }
+        return "JobScheduler " + i2 + " job limit exceeded.\nIn JobScheduler there are " + str2 + ".\nThere are " + size + " jobs tracked by WorkManager's database;\nthe Configuration limit is " + configuration.getMaxSchedulerLimit() + '.';
+    }
+}

decompiled/sources/androidx/work/impl/background/systemjob/SystemJobInfoConverter$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.work.impl.background.systemjob;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class SystemJobInfoConverter$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/work/impl/background/systemjob/SystemJobInfoConverter$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.work.impl.background.systemjob;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class SystemJobInfoConverter$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/work/impl/background/systemjob/SystemJobInfoConverter$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.work.impl.background.systemjob;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class SystemJobInfoConverter$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/work/impl/background/systemjob/SystemJobInfoConverter.java

@@ -0,0 +1,152 @@
+package androidx.work.impl.background.systemjob;
+
+import android.annotation.SuppressLint;
+import android.app.job.JobInfo;
+import android.content.ComponentName;
+import android.content.Context;
+import android.net.NetworkRequest;
+import android.os.Build;
+import android.os.PersistableBundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.work.BackoffPolicy;
+import androidx.work.Clock;
+import androidx.work.Constraints;
+import androidx.work.Logger;
+import androidx.work.NetworkType;
+import androidx.work.impl.model.WorkSpec;
+import java.util.Iterator;
+
+@RequiresApi(api = 23)
+@SuppressLint({"ClassVerificationFailure"})
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+class SystemJobInfoConverter {
+    static final String EXTRA_IS_PERIODIC = "EXTRA_IS_PERIODIC";
+    static final String EXTRA_WORK_SPEC_GENERATION = "EXTRA_WORK_SPEC_GENERATION";
+    static final String EXTRA_WORK_SPEC_ID = "EXTRA_WORK_SPEC_ID";
+    private static final String TAG = Logger.tagWithPrefix("SystemJobInfoConverter");
+    private final Clock mClock;
+    private final boolean mMarkImportantWhileForeground;
+    private final ComponentName mWorkServiceComponent;
+
+    public SystemJobInfoConverter(@NonNull Context context, Clock clock, boolean z) {
+        this.mClock = clock;
+        this.mWorkServiceComponent = new ComponentName(context.getApplicationContext(), (Class<?>) SystemJobService.class);
+        this.mMarkImportantWhileForeground = z;
+    }
+
+    public JobInfo convert(WorkSpec workSpec, int i) {
+        String traceTag;
+        Constraints constraints = workSpec.constraints;
+        PersistableBundle persistableBundle = new PersistableBundle();
+        persistableBundle.putString(EXTRA_WORK_SPEC_ID, workSpec.id);
+        persistableBundle.putInt(EXTRA_WORK_SPEC_GENERATION, workSpec.getGeneration());
+        persistableBundle.putBoolean(EXTRA_IS_PERIODIC, workSpec.isPeriodic());
+        JobInfo.Builder extras = new JobInfo.Builder(i, this.mWorkServiceComponent).setRequiresCharging(constraints.requiresCharging()).setRequiresDeviceIdle(constraints.requiresDeviceIdle()).setExtras(persistableBundle);
+        NetworkRequest requiredNetworkRequest = constraints.getRequiredNetworkRequest();
+        int i2 = Build.VERSION.SDK_INT;
+        if (i2 >= 28 && requiredNetworkRequest != null) {
+            SystemJobInfoConverterExtKt.setRequiredNetworkRequest(extras, requiredNetworkRequest);
+        } else {
+            setRequiredNetwork(extras, constraints.getRequiredNetworkType());
+        }
+        if (!constraints.requiresDeviceIdle()) {
+            extras.setBackoffCriteria(workSpec.backoffDelayDuration, workSpec.backoffPolicy == BackoffPolicy.LINEAR ? 0 : 1);
+        }
+        long max = Math.max(workSpec.calculateNextRunTime() - this.mClock.currentTimeMillis(), 0L);
+        if (i2 <= 28) {
+            extras.setMinimumLatency(max);
+        } else if (max > 0) {
+            extras.setMinimumLatency(max);
+        } else if (!workSpec.expedited && this.mMarkImportantWhileForeground) {
+            extras.setImportantWhileForeground(true);
+        }
+        if (constraints.hasContentUriTriggers()) {
+            Iterator<Constraints.ContentUriTrigger> it = constraints.getContentUriTriggers().iterator();
+            while (it.hasNext()) {
+                extras.addTriggerContentUri(convertContentUriTrigger(it.next()));
+            }
+            extras.setTriggerContentUpdateDelay(constraints.getContentTriggerUpdateDelayMillis());
+            extras.setTriggerContentMaxDelay(constraints.getContentTriggerMaxDelayMillis());
+        }
+        extras.setPersisted(false);
+        int i3 = Build.VERSION.SDK_INT;
+        extras.setRequiresBatteryNotLow(constraints.requiresBatteryNotLow());
+        extras.setRequiresStorageNotLow(constraints.requiresStorageNotLow());
+        boolean z = workSpec.runAttemptCount > 0;
+        boolean z2 = max > 0;
+        if (i3 >= 31 && workSpec.expedited && !z && !z2) {
+            extras.setExpedited(true);
+        }
+        if (i3 >= 35 && (traceTag = workSpec.getTraceTag()) != null) {
+            extras.setTraceTag(traceTag);
+        }
+        return extras.build();
+    }
+
+    @RequiresApi(24)
+    private static JobInfo.TriggerContentUri convertContentUriTrigger(Constraints.ContentUriTrigger contentUriTrigger) {
+        return new JobInfo.TriggerContentUri(contentUriTrigger.getUri(), contentUriTrigger.isTriggeredForDescendants() ? 1 : 0);
+    }
+
+    public static void setRequiredNetwork(@NonNull JobInfo.Builder builder, @NonNull NetworkType networkType) {
+        if (Build.VERSION.SDK_INT >= 30 && networkType == NetworkType.TEMPORARILY_UNMETERED) {
+            builder.setRequiredNetwork(new NetworkRequest.Builder().addCapability(25).build());
+        } else {
+            builder.setRequiredNetworkType(convertNetworkType(networkType));
+        }
+    }
+
+    /* renamed from: androidx.work.impl.background.systemjob.SystemJobInfoConverter$1, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass1 {
+        static final /* synthetic */ int[] $SwitchMap$androidx$work$NetworkType;
+
+        static {
+            int[] iArr = new int[NetworkType.values().length];
+            $SwitchMap$androidx$work$NetworkType = iArr;
+            try {
+                iArr[NetworkType.NOT_REQUIRED.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$androidx$work$NetworkType[NetworkType.CONNECTED.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                $SwitchMap$androidx$work$NetworkType[NetworkType.UNMETERED.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                $SwitchMap$androidx$work$NetworkType[NetworkType.NOT_ROAMING.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                $SwitchMap$androidx$work$NetworkType[NetworkType.METERED.ordinal()] = 5;
+            } catch (NoSuchFieldError unused5) {
+            }
+        }
+    }
+
+    public static int convertNetworkType(NetworkType networkType) {
+        int i = AnonymousClass1.$SwitchMap$androidx$work$NetworkType[networkType.ordinal()];
+        if (i == 1) {
+            return 0;
+        }
+        if (i == 2) {
+            return 1;
+        }
+        if (i == 3) {
+            return 2;
+        }
+        if (i == 4) {
+            return 3;
+        }
+        if (i == 5) {
+            return 4;
+        }
+        Logger.get().debug(TAG, "API version too low. Cannot convert network type value " + networkType);
+        return 1;
+    }
+}

decompiled/sources/androidx/work/impl/background/systemjob/SystemJobInfoConverterExtKt.java

@@ -0,0 +1,15 @@
+package androidx.work.impl.background.systemjob;
+
+import android.app.job.JobInfo;
+import android.net.NetworkRequest;
+import androidx.annotation.RequiresApi;
+import kotlin.jvm.internal.Intrinsics;
+
+@RequiresApi(28)
+/* loaded from: classes.dex */
+public final class SystemJobInfoConverterExtKt {
+    public static final void setRequiredNetworkRequest(JobInfo.Builder builder, NetworkRequest networkRequest) {
+        Intrinsics.checkNotNullParameter(builder, "builder");
+        builder.setRequiredNetwork(networkRequest);
+    }
+}

decompiled/sources/androidx/work/impl/background/systemjob/SystemJobScheduler.java

@@ -0,0 +1,250 @@
+package androidx.work.impl.background.systemjob;
+
+import android.app.job.JobInfo;
+import android.app.job.JobScheduler;
+import android.content.ComponentName;
+import android.content.Context;
+import android.os.Build;
+import android.os.PersistableBundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.core.util.Consumer;
+import androidx.work.Configuration;
+import androidx.work.Logger;
+import androidx.work.OutOfQuotaPolicy;
+import androidx.work.WorkInfo;
+import androidx.work.impl.Scheduler;
+import androidx.work.impl.WorkDatabase;
+import androidx.work.impl.model.SystemIdInfo;
+import androidx.work.impl.model.SystemIdInfoKt;
+import androidx.work.impl.model.WorkGenerationalId;
+import androidx.work.impl.model.WorkSpec;
+import androidx.work.impl.model.WorkSpecDao;
+import androidx.work.impl.model.WorkSpecKt;
+import androidx.work.impl.utils.IdGenerator;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+
+@RequiresApi(23)
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public class SystemJobScheduler implements Scheduler {
+    private static final String TAG = Logger.tagWithPrefix("SystemJobScheduler");
+    private final Configuration mConfiguration;
+    private final Context mContext;
+    private final JobScheduler mJobScheduler;
+    private final SystemJobInfoConverter mSystemJobInfoConverter;
+    private final WorkDatabase mWorkDatabase;
+
+    @Override // androidx.work.impl.Scheduler
+    public boolean hasLimitedSchedulingSlots() {
+        return true;
+    }
+
+    public SystemJobScheduler(@NonNull Context context, @NonNull WorkDatabase workDatabase, @NonNull Configuration configuration) {
+        this(context, workDatabase, configuration, JobSchedulerExtKt.getWmJobScheduler(context), new SystemJobInfoConverter(context, configuration.getClock(), configuration.isMarkingJobsAsImportantWhileForeground()));
+    }
+
+    @VisibleForTesting
+    public SystemJobScheduler(@NonNull Context context, @NonNull WorkDatabase workDatabase, @NonNull Configuration configuration, @NonNull JobScheduler jobScheduler, @NonNull SystemJobInfoConverter systemJobInfoConverter) {
+        this.mContext = context;
+        this.mJobScheduler = jobScheduler;
+        this.mSystemJobInfoConverter = systemJobInfoConverter;
+        this.mWorkDatabase = workDatabase;
+        this.mConfiguration = configuration;
+    }
+
+    @Override // androidx.work.impl.Scheduler
+    public void schedule(@NonNull WorkSpec... workSpecArr) {
+        IdGenerator idGenerator = new IdGenerator(this.mWorkDatabase);
+        for (WorkSpec workSpec : workSpecArr) {
+            this.mWorkDatabase.beginTransaction();
+            try {
+                WorkSpec workSpec2 = this.mWorkDatabase.workSpecDao().getWorkSpec(workSpec.id);
+                if (workSpec2 == null) {
+                    Logger.get().warning(TAG, "Skipping scheduling " + workSpec.id + " because it's no longer in the DB");
+                    this.mWorkDatabase.setTransactionSuccessful();
+                } else if (workSpec2.state != WorkInfo.State.ENQUEUED) {
+                    Logger.get().warning(TAG, "Skipping scheduling " + workSpec.id + " because it is no longer enqueued");
+                    this.mWorkDatabase.setTransactionSuccessful();
+                } else {
+                    WorkGenerationalId generationalId = WorkSpecKt.generationalId(workSpec);
+                    SystemIdInfo systemIdInfo = this.mWorkDatabase.systemIdInfoDao().getSystemIdInfo(generationalId);
+                    int nextJobSchedulerIdWithRange = systemIdInfo != null ? systemIdInfo.systemId : idGenerator.nextJobSchedulerIdWithRange(this.mConfiguration.getMinJobSchedulerId(), this.mConfiguration.getMaxJobSchedulerId());
+                    if (systemIdInfo == null) {
+                        this.mWorkDatabase.systemIdInfoDao().insertSystemIdInfo(SystemIdInfoKt.systemIdInfo(generationalId, nextJobSchedulerIdWithRange));
+                    }
+                    scheduleInternal(workSpec, nextJobSchedulerIdWithRange);
+                    this.mWorkDatabase.setTransactionSuccessful();
+                }
+            } finally {
+                this.mWorkDatabase.endTransaction();
+            }
+        }
+    }
+
+    @VisibleForTesting
+    public void scheduleInternal(@NonNull WorkSpec workSpec, int i) {
+        JobInfo convert = this.mSystemJobInfoConverter.convert(workSpec, i);
+        Logger logger = Logger.get();
+        String str = TAG;
+        logger.debug(str, "Scheduling work ID " + workSpec.id + "Job ID " + i);
+        try {
+            if (this.mJobScheduler.schedule(convert) == 0) {
+                Logger.get().warning(str, "Unable to schedule work ID " + workSpec.id);
+                if (workSpec.expedited && workSpec.outOfQuotaPolicy == OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST) {
+                    workSpec.expedited = false;
+                    Logger.get().debug(str, String.format("Scheduling a non-expedited job (work ID %s)", workSpec.id));
+                    scheduleInternal(workSpec, i);
+                }
+            }
+        } catch (IllegalStateException e) {
+            String createErrorMessage = JobSchedulerExtKt.createErrorMessage(this.mContext, this.mWorkDatabase, this.mConfiguration);
+            Logger.get().error(TAG, createErrorMessage);
+            IllegalStateException illegalStateException = new IllegalStateException(createErrorMessage, e);
+            Consumer<Throwable> schedulingExceptionHandler = this.mConfiguration.getSchedulingExceptionHandler();
+            if (schedulingExceptionHandler != null) {
+                schedulingExceptionHandler.accept(illegalStateException);
+                return;
+            }
+            throw illegalStateException;
+        } catch (Throwable th) {
+            Logger.get().error(TAG, "Unable to schedule " + workSpec, th);
+        }
+    }
+
+    @Override // androidx.work.impl.Scheduler
+    public void cancel(@NonNull String str) {
+        List<Integer> pendingJobIds = getPendingJobIds(this.mContext, this.mJobScheduler, str);
+        if (pendingJobIds == null || pendingJobIds.isEmpty()) {
+            return;
+        }
+        Iterator<Integer> it = pendingJobIds.iterator();
+        while (it.hasNext()) {
+            cancelJobById(this.mJobScheduler, it.next().intValue());
+        }
+        this.mWorkDatabase.systemIdInfoDao().removeSystemIdInfo(str);
+    }
+
+    private static void cancelJobById(@NonNull JobScheduler jobScheduler, int i) {
+        try {
+            jobScheduler.cancel(i);
+        } catch (Throwable th) {
+            Logger.get().error(TAG, String.format(Locale.getDefault(), "Exception while trying to cancel job (%d)", Integer.valueOf(i)), th);
+        }
+    }
+
+    public static void cancelAllInAllNamespaces(@NonNull Context context) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            JobSchedulerExtKt.getWmJobScheduler(context).cancelAll();
+        }
+        JobScheduler jobScheduler = (JobScheduler) context.getSystemService("jobscheduler");
+        List<JobInfo> pendingJobs = getPendingJobs(context, jobScheduler);
+        if (pendingJobs == null || pendingJobs.isEmpty()) {
+            return;
+        }
+        Iterator<JobInfo> it = pendingJobs.iterator();
+        while (it.hasNext()) {
+            cancelJobById(jobScheduler, it.next().getId());
+        }
+    }
+
+    public static boolean reconcileJobs(@NonNull Context context, @NonNull WorkDatabase workDatabase) {
+        JobScheduler wmJobScheduler = JobSchedulerExtKt.getWmJobScheduler(context);
+        List<JobInfo> pendingJobs = getPendingJobs(context, wmJobScheduler);
+        List<String> workSpecIds = workDatabase.systemIdInfoDao().getWorkSpecIds();
+        boolean z = false;
+        HashSet hashSet = new HashSet(pendingJobs != null ? pendingJobs.size() : 0);
+        if (pendingJobs != null && !pendingJobs.isEmpty()) {
+            for (JobInfo jobInfo : pendingJobs) {
+                WorkGenerationalId workGenerationalIdFromJobInfo = getWorkGenerationalIdFromJobInfo(jobInfo);
+                if (workGenerationalIdFromJobInfo != null) {
+                    hashSet.add(workGenerationalIdFromJobInfo.getWorkSpecId());
+                } else {
+                    cancelJobById(wmJobScheduler, jobInfo.getId());
+                }
+            }
+        }
+        Iterator<String> it = workSpecIds.iterator();
+        while (true) {
+            if (!it.hasNext()) {
+                break;
+            }
+            if (!hashSet.contains(it.next())) {
+                Logger.get().debug(TAG, "Reconciling jobs");
+                z = true;
+                break;
+            }
+        }
+        if (z) {
+            workDatabase.beginTransaction();
+            try {
+                WorkSpecDao workSpecDao = workDatabase.workSpecDao();
+                Iterator<String> it2 = workSpecIds.iterator();
+                while (it2.hasNext()) {
+                    workSpecDao.markWorkSpecScheduled(it2.next(), -1L);
+                }
+                workDatabase.setTransactionSuccessful();
+                workDatabase.endTransaction();
+            } catch (Throwable th) {
+                workDatabase.endTransaction();
+                throw th;
+            }
+        }
+        return z;
+    }
+
+    @Nullable
+    public static List<JobInfo> getPendingJobs(@NonNull Context context, @NonNull JobScheduler jobScheduler) {
+        List<JobInfo> safePendingJobs = JobSchedulerExtKt.getSafePendingJobs(jobScheduler);
+        if (safePendingJobs == null) {
+            return null;
+        }
+        ArrayList arrayList = new ArrayList(safePendingJobs.size());
+        ComponentName componentName = new ComponentName(context, (Class<?>) SystemJobService.class);
+        for (JobInfo jobInfo : safePendingJobs) {
+            if (componentName.equals(jobInfo.getService())) {
+                arrayList.add(jobInfo);
+            }
+        }
+        return arrayList;
+    }
+
+    @Nullable
+    private static List<Integer> getPendingJobIds(@NonNull Context context, @NonNull JobScheduler jobScheduler, @NonNull String str) {
+        List<JobInfo> pendingJobs = getPendingJobs(context, jobScheduler);
+        if (pendingJobs == null) {
+            return null;
+        }
+        ArrayList arrayList = new ArrayList(2);
+        for (JobInfo jobInfo : pendingJobs) {
+            WorkGenerationalId workGenerationalIdFromJobInfo = getWorkGenerationalIdFromJobInfo(jobInfo);
+            if (workGenerationalIdFromJobInfo != null && str.equals(workGenerationalIdFromJobInfo.getWorkSpecId())) {
+                arrayList.add(Integer.valueOf(jobInfo.getId()));
+            }
+        }
+        return arrayList;
+    }
+
+    @Nullable
+    private static WorkGenerationalId getWorkGenerationalIdFromJobInfo(@NonNull JobInfo jobInfo) {
+        PersistableBundle extras = jobInfo.getExtras();
+        if (extras == null) {
+            return null;
+        }
+        try {
+            if (!extras.containsKey("EXTRA_WORK_SPEC_ID")) {
+                return null;
+            }
+            return new WorkGenerationalId(extras.getString("EXTRA_WORK_SPEC_ID"), extras.getInt("EXTRA_WORK_SPEC_GENERATION", 0));
+        } catch (NullPointerException unused) {
+            return null;
+        }
+    }
+}

decompiled/sources/androidx/work/impl/background/systemjob/SystemJobService.java

@@ -0,0 +1,211 @@
+package androidx.work.impl.background.systemjob;
+
+import android.app.Application;
+import android.app.job.JobParameters;
+import android.app.job.JobService;
+import android.net.Network;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Looper;
+import android.os.PersistableBundle;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.work.Logger;
+import androidx.work.WorkInfo;
+import androidx.work.WorkerParameters;
+import androidx.work.impl.ExecutionListener;
+import androidx.work.impl.Processor;
+import androidx.work.impl.StartStopToken;
+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 java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+@RequiresApi(23)
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public class SystemJobService extends JobService implements ExecutionListener {
+    private static final String TAG = Logger.tagWithPrefix("SystemJobService");
+    private final Map<WorkGenerationalId, JobParameters> mJobParameters = new HashMap();
+    private final StartStopTokens mStartStopTokens = StartStopTokens.create(false);
+    private WorkLauncher mWorkLauncher;
+    private WorkManagerImpl mWorkManagerImpl;
+
+    public static int stopReason(int i) {
+        switch (i) {
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+            case 9:
+            case 10:
+            case 11:
+            case 12:
+            case 13:
+            case 14:
+            case 15:
+                return i;
+            default:
+                return WorkInfo.STOP_REASON_UNKNOWN;
+        }
+    }
+
+    @Override // android.app.Service
+    public void onCreate() {
+        super.onCreate();
+        try {
+            WorkManagerImpl workManagerImpl = WorkManagerImpl.getInstance(getApplicationContext());
+            this.mWorkManagerImpl = workManagerImpl;
+            Processor processor = workManagerImpl.getProcessor();
+            this.mWorkLauncher = new WorkLauncherImpl(processor, this.mWorkManagerImpl.getWorkTaskExecutor());
+            processor.addExecutionListener(this);
+        } catch (IllegalStateException e) {
+            if (!Application.class.equals(getApplication().getClass())) {
+                throw new IllegalStateException("WorkManager needs to be initialized via a ContentProvider#onCreate() or an Application#onCreate().", e);
+            }
+            Logger.get().warning(TAG, "Could not find WorkManager instance; this may be because an auto-backup is in progress. Ignoring JobScheduler commands for now. Please make sure that you are initializing WorkManager if you have manually disabled WorkManagerInitializer.");
+        }
+    }
+
+    @Override // android.app.Service
+    public void onDestroy() {
+        super.onDestroy();
+        WorkManagerImpl workManagerImpl = this.mWorkManagerImpl;
+        if (workManagerImpl != null) {
+            workManagerImpl.getProcessor().removeExecutionListener(this);
+        }
+    }
+
+    @Override // android.app.job.JobService
+    public boolean onStartJob(@NonNull JobParameters jobParameters) {
+        assertMainThread("onStartJob");
+        if (this.mWorkManagerImpl == null) {
+            Logger.get().debug(TAG, "WorkManager is not initialized; requesting retry.");
+            jobFinished(jobParameters, true);
+            return false;
+        }
+        WorkGenerationalId workGenerationalIdFromJobParameters = workGenerationalIdFromJobParameters(jobParameters);
+        if (workGenerationalIdFromJobParameters == null) {
+            Logger.get().error(TAG, "WorkSpec id not found!");
+            return false;
+        }
+        if (this.mJobParameters.containsKey(workGenerationalIdFromJobParameters)) {
+            Logger.get().debug(TAG, "Job is already being executed by SystemJobService: " + workGenerationalIdFromJobParameters);
+            return false;
+        }
+        Logger.get().debug(TAG, "onStartJob for " + workGenerationalIdFromJobParameters);
+        this.mJobParameters.put(workGenerationalIdFromJobParameters, jobParameters);
+        int i = Build.VERSION.SDK_INT;
+        WorkerParameters.RuntimeExtras runtimeExtras = new WorkerParameters.RuntimeExtras();
+        if (Api24Impl.getTriggeredContentUris(jobParameters) != null) {
+            runtimeExtras.triggeredContentUris = Arrays.asList(Api24Impl.getTriggeredContentUris(jobParameters));
+        }
+        if (Api24Impl.getTriggeredContentAuthorities(jobParameters) != null) {
+            runtimeExtras.triggeredContentAuthorities = Arrays.asList(Api24Impl.getTriggeredContentAuthorities(jobParameters));
+        }
+        if (i >= 28) {
+            runtimeExtras.network = Api28Impl.getNetwork(jobParameters);
+        }
+        this.mWorkLauncher.startWork(this.mStartStopTokens.tokenFor(workGenerationalIdFromJobParameters), runtimeExtras);
+        return true;
+    }
+
+    @Override // android.app.job.JobService
+    public boolean onStopJob(@NonNull JobParameters jobParameters) {
+        assertMainThread("onStopJob");
+        if (this.mWorkManagerImpl == null) {
+            Logger.get().debug(TAG, "WorkManager is not initialized; requesting retry.");
+            return true;
+        }
+        WorkGenerationalId workGenerationalIdFromJobParameters = workGenerationalIdFromJobParameters(jobParameters);
+        if (workGenerationalIdFromJobParameters == null) {
+            Logger.get().error(TAG, "WorkSpec id not found!");
+            return false;
+        }
+        Logger.get().debug(TAG, "onStopJob for " + workGenerationalIdFromJobParameters);
+        this.mJobParameters.remove(workGenerationalIdFromJobParameters);
+        StartStopToken remove = this.mStartStopTokens.remove(workGenerationalIdFromJobParameters);
+        if (remove != null) {
+            this.mWorkLauncher.stopWorkWithReason(remove, Build.VERSION.SDK_INT >= 31 ? Api31Impl.getStopReason(jobParameters) : WorkInfo.STOP_REASON_UNKNOWN);
+        }
+        return !this.mWorkManagerImpl.getProcessor().isCancelled(workGenerationalIdFromJobParameters.getWorkSpecId());
+    }
+
+    @Override // androidx.work.impl.ExecutionListener
+    @MainThread
+    public void onExecuted(@NonNull WorkGenerationalId workGenerationalId, boolean z) {
+        assertMainThread("onExecuted");
+        Logger.get().debug(TAG, workGenerationalId.getWorkSpecId() + " executed on JobScheduler");
+        JobParameters remove = this.mJobParameters.remove(workGenerationalId);
+        this.mStartStopTokens.remove(workGenerationalId);
+        if (remove != null) {
+            jobFinished(remove, z);
+        }
+    }
+
+    @Nullable
+    private static WorkGenerationalId workGenerationalIdFromJobParameters(@NonNull JobParameters jobParameters) {
+        try {
+            PersistableBundle extras = jobParameters.getExtras();
+            if (extras == null || !extras.containsKey("EXTRA_WORK_SPEC_ID")) {
+                return null;
+            }
+            return new WorkGenerationalId(extras.getString("EXTRA_WORK_SPEC_ID"), extras.getInt("EXTRA_WORK_SPEC_GENERATION"));
+        } catch (NullPointerException unused) {
+            return null;
+        }
+    }
+
+    @RequiresApi(24)
+    public static class Api24Impl {
+        private Api24Impl() {
+        }
+
+        public static Uri[] getTriggeredContentUris(JobParameters jobParameters) {
+            return jobParameters.getTriggeredContentUris();
+        }
+
+        public static String[] getTriggeredContentAuthorities(JobParameters jobParameters) {
+            return jobParameters.getTriggeredContentAuthorities();
+        }
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static Network getNetwork(JobParameters jobParameters) {
+            return jobParameters.getNetwork();
+        }
+    }
+
+    @RequiresApi(31)
+    public static class Api31Impl {
+        private Api31Impl() {
+        }
+
+        public static int getStopReason(JobParameters jobParameters) {
+            return SystemJobService.stopReason(jobParameters.getStopReason());
+        }
+    }
+
+    private static void assertMainThread(String str) {
+        if (Looper.getMainLooper().getThread() == Thread.currentThread()) {
+            return;
+        }
+        throw new IllegalStateException("Cannot invoke " + str + " on a background thread");
+    }
+}

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

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