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/workers/CombineContinuationsWorker.java

@@ -0,0 +1,24 @@
+package androidx.work.impl.workers;
+
+import android.content.Context;
+import androidx.work.ListenableWorker;
+import androidx.work.Worker;
+import androidx.work.WorkerParameters;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class CombineContinuationsWorker extends Worker {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public CombineContinuationsWorker(Context context, WorkerParameters workerParams) {
+        super(context, workerParams);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(workerParams, "workerParams");
+    }
+
+    @Override // androidx.work.Worker
+    public ListenableWorker.Result doWork() {
+        ListenableWorker.Result success = ListenableWorker.Result.success(getInputData());
+        Intrinsics.checkNotNullExpressionValue(success, "success(inputData)");
+        return success;
+    }
+}

decompiled/sources/androidx/work/impl/workers/ConstraintTrackingWorker$doWork$2.java

@@ -0,0 +1,56 @@
+package androidx.work.impl.workers;
+
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+@DebugMetadata(c = "androidx.work.impl.workers.ConstraintTrackingWorker$doWork$2", f = "ConstraintTrackingWorker.kt", l = {TokenParametersOuterClass$TokenParameters.LASTADVERTISEDBUNDLES_FIELD_NUMBER}, m = "invokeSuspend")
+/* loaded from: classes.dex */
+public final class ConstraintTrackingWorker$doWork$2 extends SuspendLambda implements Function2 {
+    int label;
+    final /* synthetic */ ConstraintTrackingWorker this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ConstraintTrackingWorker$doWork$2(ConstraintTrackingWorker constraintTrackingWorker, Continuation continuation) {
+        super(2, continuation);
+        this.this$0 = constraintTrackingWorker;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new ConstraintTrackingWorker$doWork$2(this.this$0, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((ConstraintTrackingWorker$doWork$2) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            ConstraintTrackingWorker constraintTrackingWorker = this.this$0;
+            this.label = 1;
+            obj = constraintTrackingWorker.setupAndRunConstraintTrackingWork(this);
+            if (obj == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return obj;
+    }
+}

decompiled/sources/androidx/work/impl/workers/ConstraintTrackingWorker$runWorker$1.java

@@ -0,0 +1,28 @@
+package androidx.work.impl.workers;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+
+@DebugMetadata(c = "androidx.work.impl.workers.ConstraintTrackingWorker", f = "ConstraintTrackingWorker.kt", l = {125}, m = "runWorker")
+/* loaded from: classes.dex */
+public final class ConstraintTrackingWorker$runWorker$1 extends ContinuationImpl {
+    int label;
+    /* synthetic */ Object result;
+    final /* synthetic */ ConstraintTrackingWorker this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ConstraintTrackingWorker$runWorker$1(ConstraintTrackingWorker constraintTrackingWorker, Continuation continuation) {
+        super(continuation);
+        this.this$0 = constraintTrackingWorker;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object runWorker;
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        runWorker = this.this$0.runWorker(null, null, null, this);
+        return runWorker;
+    }
+}

decompiled/sources/androidx/work/impl/workers/ConstraintTrackingWorker$runWorker$2$constraintTrackingJob$1.java

@@ -0,0 +1,68 @@
+package androidx.work.impl.workers;
+
+import androidx.work.impl.constraints.WorkConstraintsTracker;
+import androidx.work.impl.model.WorkSpec;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+@DebugMetadata(c = "androidx.work.impl.workers.ConstraintTrackingWorker$runWorker$2$constraintTrackingJob$1", f = "ConstraintTrackingWorker.kt", l = {129}, m = "invokeSuspend")
+/* loaded from: classes.dex */
+public final class ConstraintTrackingWorker$runWorker$2$constraintTrackingJob$1 extends SuspendLambda implements Function2 {
+    final /* synthetic */ AtomicInteger $atomicReason;
+    final /* synthetic */ ListenableFuture $future;
+    final /* synthetic */ WorkConstraintsTracker $workConstraintsTracker;
+    final /* synthetic */ WorkSpec $workSpec;
+    int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ConstraintTrackingWorker$runWorker$2$constraintTrackingJob$1(WorkConstraintsTracker workConstraintsTracker, WorkSpec workSpec, AtomicInteger atomicInteger, ListenableFuture listenableFuture, Continuation continuation) {
+        super(2, continuation);
+        this.$workConstraintsTracker = workConstraintsTracker;
+        this.$workSpec = workSpec;
+        this.$atomicReason = atomicInteger;
+        this.$future = listenableFuture;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new ConstraintTrackingWorker$runWorker$2$constraintTrackingJob$1(this.$workConstraintsTracker, this.$workSpec, this.$atomicReason, this.$future, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((ConstraintTrackingWorker$runWorker$2$constraintTrackingJob$1) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            WorkConstraintsTracker workConstraintsTracker = this.$workConstraintsTracker;
+            WorkSpec workSpec = this.$workSpec;
+            this.label = 1;
+            obj = ConstraintTrackingWorkerKt.awaitConstraintsNotMet(workConstraintsTracker, workSpec, this);
+            if (obj == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        this.$atomicReason.set(((Number) obj).intValue());
+        this.$future.cancel(true);
+        return Unit.INSTANCE;
+    }
+}

decompiled/sources/androidx/work/impl/workers/ConstraintTrackingWorker$runWorker$2.java

@@ -0,0 +1,62 @@
+package androidx.work.impl.workers;
+
+import androidx.work.ListenableWorker;
+import androidx.work.impl.constraints.WorkConstraintsTracker;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlinx.coroutines.CoroutineScope;
+
+@DebugMetadata(c = "androidx.work.impl.workers.ConstraintTrackingWorker$runWorker$2", f = "ConstraintTrackingWorker.kt", l = {134}, m = "invokeSuspend")
+@SourceDebugExtension({"SMAP\nConstraintTrackingWorker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 ConstraintTrackingWorker.kt\nandroidx/work/impl/workers/ConstraintTrackingWorker$runWorker$2\n+ 2 LoggerExt.kt\nandroidx/work/LoggerExtKt\n*L\n1#1,168:1\n22#2:169\n22#2:170\n*S KotlinDebug\n*F\n+ 1 ConstraintTrackingWorker.kt\nandroidx/work/impl/workers/ConstraintTrackingWorker$runWorker$2\n*L\n137#1:169\n144#1:170\n*E\n"})
+/* loaded from: classes.dex */
+public final class ConstraintTrackingWorker$runWorker$2 extends SuspendLambda implements Function2 {
+    final /* synthetic */ ListenableWorker $delegate;
+    final /* synthetic */ WorkConstraintsTracker $workConstraintsTracker;
+    final /* synthetic */ WorkSpec $workSpec;
+    private /* synthetic */ Object L$0;
+    Object L$1;
+    Object L$2;
+    int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ConstraintTrackingWorker$runWorker$2(ListenableWorker listenableWorker, WorkConstraintsTracker workConstraintsTracker, WorkSpec workSpec, Continuation continuation) {
+        super(2, continuation);
+        this.$delegate = listenableWorker;
+        this.$workConstraintsTracker = workConstraintsTracker;
+        this.$workSpec = workSpec;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        ConstraintTrackingWorker$runWorker$2 constraintTrackingWorker$runWorker$2 = new ConstraintTrackingWorker$runWorker$2(this.$delegate, this.$workConstraintsTracker, this.$workSpec, continuation);
+        constraintTrackingWorker$runWorker$2.L$0 = obj;
+        return constraintTrackingWorker$runWorker$2;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((ConstraintTrackingWorker$runWorker$2) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:19:0x00e0  */
+    /* JADX WARN: Removed duplicated region for block: B:22:0x00e9 A[ADDED_TO_REGION] */
+    /* JADX WARN: Removed duplicated region for block: B:26:0x00e2  */
+    /* JADX WARN: Type inference failed for: r2v0, types: [int, kotlinx.coroutines.Job] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object invokeSuspend(java.lang.Object r19) {
+        /*
+            Method dump skipped, instructions count: 250
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.work.impl.workers.ConstraintTrackingWorker$runWorker$2.invokeSuspend(java.lang.Object):java.lang.Object");
+    }
+}

decompiled/sources/androidx/work/impl/workers/ConstraintTrackingWorker$setupAndRunConstraintTrackingWork$1.java

@@ -0,0 +1,30 @@
+package androidx.work.impl.workers;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+
+@DebugMetadata(c = "androidx.work.impl.workers.ConstraintTrackingWorker", f = "ConstraintTrackingWorker.kt", l = {97}, m = "setupAndRunConstraintTrackingWork")
+/* loaded from: classes.dex */
+public final class ConstraintTrackingWorker$setupAndRunConstraintTrackingWork$1 extends ContinuationImpl {
+    Object L$0;
+    Object L$1;
+    int label;
+    /* synthetic */ Object result;
+    final /* synthetic */ ConstraintTrackingWorker this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ConstraintTrackingWorker$setupAndRunConstraintTrackingWork$1(ConstraintTrackingWorker constraintTrackingWorker, Continuation continuation) {
+        super(continuation);
+        this.this$0 = constraintTrackingWorker;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object obj2;
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        obj2 = this.this$0.setupAndRunConstraintTrackingWork(this);
+        return obj2;
+    }
+}

decompiled/sources/androidx/work/impl/workers/ConstraintTrackingWorker$setupAndRunConstraintTrackingWork$5.java

@@ -0,0 +1,67 @@
+package androidx.work.impl.workers;
+
+import androidx.work.ListenableWorker;
+import androidx.work.impl.constraints.WorkConstraintsTracker;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+@DebugMetadata(c = "androidx.work.impl.workers.ConstraintTrackingWorker$setupAndRunConstraintTrackingWork$5", f = "ConstraintTrackingWorker.kt", l = {98}, m = "invokeSuspend")
+/* loaded from: classes.dex */
+public final class ConstraintTrackingWorker$setupAndRunConstraintTrackingWork$5 extends SuspendLambda implements Function2 {
+    final /* synthetic */ ListenableWorker $delegate;
+    final /* synthetic */ WorkConstraintsTracker $workConstraintsTracker;
+    final /* synthetic */ WorkSpec $workSpec;
+    int label;
+    final /* synthetic */ ConstraintTrackingWorker this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ConstraintTrackingWorker$setupAndRunConstraintTrackingWork$5(ConstraintTrackingWorker constraintTrackingWorker, ListenableWorker listenableWorker, WorkConstraintsTracker workConstraintsTracker, WorkSpec workSpec, Continuation continuation) {
+        super(2, continuation);
+        this.this$0 = constraintTrackingWorker;
+        this.$delegate = listenableWorker;
+        this.$workConstraintsTracker = workConstraintsTracker;
+        this.$workSpec = workSpec;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new ConstraintTrackingWorker$setupAndRunConstraintTrackingWork$5(this.this$0, this.$delegate, this.$workConstraintsTracker, this.$workSpec, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((ConstraintTrackingWorker$setupAndRunConstraintTrackingWork$5) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            ConstraintTrackingWorker constraintTrackingWorker = this.this$0;
+            ListenableWorker listenableWorker = this.$delegate;
+            WorkConstraintsTracker workConstraintsTracker = this.$workConstraintsTracker;
+            WorkSpec workSpec = this.$workSpec;
+            this.label = 1;
+            obj = constraintTrackingWorker.runWorker(listenableWorker, workConstraintsTracker, workSpec, this);
+            if (obj == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return obj;
+    }
+}

decompiled/sources/androidx/work/impl/workers/ConstraintTrackingWorker.java

@@ -0,0 +1,121 @@
+package androidx.work.impl.workers;
+
+import android.content.Context;
+import androidx.annotation.RestrictTo;
+import androidx.work.CoroutineWorker;
+import androidx.work.WorkerParameters;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.Executor;
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlinx.coroutines.BuildersKt;
+import kotlinx.coroutines.ExecutorsKt;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+@SourceDebugExtension({"SMAP\nConstraintTrackingWorker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 ConstraintTrackingWorker.kt\nandroidx/work/impl/workers/ConstraintTrackingWorker\n+ 2 LoggerExt.kt\nandroidx/work/LoggerExtKt\n*L\n1#1,168:1\n29#2:169\n19#2:170\n19#2:171\n19#2:172\n*S KotlinDebug\n*F\n+ 1 ConstraintTrackingWorker.kt\nandroidx/work/impl/workers/ConstraintTrackingWorker\n*L\n65#1:169\n75#1:170\n78#1:171\n87#1:172\n*E\n"})
+/* loaded from: classes.dex */
+public final class ConstraintTrackingWorker extends CoroutineWorker {
+    private final WorkerParameters workerParameters;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ConstraintTrackingWorker(Context appContext, WorkerParameters workerParameters) {
+        super(appContext, workerParameters);
+        Intrinsics.checkNotNullParameter(appContext, "appContext");
+        Intrinsics.checkNotNullParameter(workerParameters, "workerParameters");
+        this.workerParameters = workerParameters;
+    }
+
+    @Override // androidx.work.CoroutineWorker
+    public Object doWork(Continuation continuation) {
+        Executor backgroundExecutor = getBackgroundExecutor();
+        Intrinsics.checkNotNullExpressionValue(backgroundExecutor, "backgroundExecutor");
+        return BuildersKt.withContext(ExecutorsKt.from(backgroundExecutor), new ConstraintTrackingWorker$doWork$2(this, null), continuation);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x015c  */
+    /* JADX WARN: Removed duplicated region for block: B:26:0x0166  */
+    /* JADX WARN: Removed duplicated region for block: B:29:0x013c  */
+    /* JADX WARN: Removed duplicated region for block: B:31:0x013f  */
+    /* JADX WARN: Removed duplicated region for block: B:41:0x0040  */
+    /* JADX WARN: Removed duplicated region for block: B:9:0x0025  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object setupAndRunConstraintTrackingWork(kotlin.coroutines.Continuation r14) {
+        /*
+            Method dump skipped, instructions count: 430
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.work.impl.workers.ConstraintTrackingWorker.setupAndRunConstraintTrackingWork(kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x0031  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object runWorker(androidx.work.ListenableWorker r5, androidx.work.impl.constraints.WorkConstraintsTracker r6, androidx.work.impl.model.WorkSpec r7, kotlin.coroutines.Continuation r8) {
+        /*
+            r4 = this;
+            boolean r0 = r8 instanceof androidx.work.impl.workers.ConstraintTrackingWorker$runWorker$1
+            if (r0 == 0) goto L13
+            r0 = r8
+            androidx.work.impl.workers.ConstraintTrackingWorker$runWorker$1 r0 = (androidx.work.impl.workers.ConstraintTrackingWorker$runWorker$1) r0
+            int r1 = r0.label
+            r2 = -2147483648(0xffffffff80000000, float:-0.0)
+            r3 = r1 & r2
+            if (r3 == 0) goto L13
+            int r1 = r1 - r2
+            r0.label = r1
+            goto L18
+        L13:
+            androidx.work.impl.workers.ConstraintTrackingWorker$runWorker$1 r0 = new androidx.work.impl.workers.ConstraintTrackingWorker$runWorker$1
+            r0.<init>(r4, r8)
+        L18:
+            java.lang.Object r8 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L31
+            if (r2 != r3) goto L29
+            kotlin.ResultKt.throwOnFailure(r8)
+            goto L43
+        L29:
+            java.lang.IllegalStateException r5 = new java.lang.IllegalStateException
+            java.lang.String r6 = "call to 'resume' before 'invoke' with coroutine"
+            r5.<init>(r6)
+            throw r5
+        L31:
+            kotlin.ResultKt.throwOnFailure(r8)
+            androidx.work.impl.workers.ConstraintTrackingWorker$runWorker$2 r8 = new androidx.work.impl.workers.ConstraintTrackingWorker$runWorker$2
+            r2 = 0
+            r8.<init>(r5, r6, r7, r2)
+            r0.label = r3
+            java.lang.Object r8 = kotlinx.coroutines.CoroutineScopeKt.coroutineScope(r8, r0)
+            if (r8 != r1) goto L43
+            return r1
+        L43:
+            java.lang.String r5 = "delegate: ListenableWork….cancel()\n        }\n    }"
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r8, r5)
+            return r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.work.impl.workers.ConstraintTrackingWorker.runWorker(androidx.work.ListenableWorker, androidx.work.impl.constraints.WorkConstraintsTracker, androidx.work.impl.model.WorkSpec, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public static final class ConstraintUnsatisfiedException extends CancellationException {
+        private final int stopReason;
+
+        public final int getStopReason() {
+            return this.stopReason;
+        }
+
+        public ConstraintUnsatisfiedException(int i) {
+            this.stopReason = i;
+        }
+    }
+}

decompiled/sources/androidx/work/impl/workers/ConstraintTrackingWorkerKt$awaitConstraintsNotMet$1.java

@@ -0,0 +1,25 @@
+package androidx.work.impl.workers;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+
+@DebugMetadata(c = "androidx.work.impl.workers.ConstraintTrackingWorkerKt", f = "ConstraintTrackingWorker.kt", l = {160}, m = "awaitConstraintsNotMet")
+/* loaded from: classes.dex */
+public final class ConstraintTrackingWorkerKt$awaitConstraintsNotMet$1 extends ContinuationImpl {
+    int label;
+    /* synthetic */ Object result;
+
+    public ConstraintTrackingWorkerKt$awaitConstraintsNotMet$1(Continuation continuation) {
+        super(continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object awaitConstraintsNotMet;
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        awaitConstraintsNotMet = ConstraintTrackingWorkerKt.awaitConstraintsNotMet(null, null, this);
+        return awaitConstraintsNotMet;
+    }
+}

decompiled/sources/androidx/work/impl/workers/ConstraintTrackingWorkerKt$awaitConstraintsNotMet$2.java

@@ -0,0 +1,51 @@
+package androidx.work.impl.workers;
+
+import androidx.work.Logger;
+import androidx.work.impl.constraints.ConstraintsState;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@DebugMetadata(c = "androidx.work.impl.workers.ConstraintTrackingWorkerKt$awaitConstraintsNotMet$2", f = "ConstraintTrackingWorker.kt", l = {}, m = "invokeSuspend")
+@SourceDebugExtension({"SMAP\nConstraintTrackingWorker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 ConstraintTrackingWorker.kt\nandroidx/work/impl/workers/ConstraintTrackingWorkerKt$awaitConstraintsNotMet$2\n+ 2 LoggerExt.kt\nandroidx/work/LoggerExtKt\n*L\n1#1,168:1\n19#2:169\n*S KotlinDebug\n*F\n+ 1 ConstraintTrackingWorker.kt\nandroidx/work/impl/workers/ConstraintTrackingWorkerKt$awaitConstraintsNotMet$2\n*L\n158#1:169\n*E\n"})
+/* loaded from: classes.dex */
+public final class ConstraintTrackingWorkerKt$awaitConstraintsNotMet$2 extends SuspendLambda implements Function2 {
+    final /* synthetic */ WorkSpec $workSpec;
+    int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ConstraintTrackingWorkerKt$awaitConstraintsNotMet$2(WorkSpec workSpec, Continuation continuation) {
+        super(2, continuation);
+        this.$workSpec = workSpec;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new ConstraintTrackingWorkerKt$awaitConstraintsNotMet$2(this.$workSpec, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(ConstraintsState constraintsState, Continuation continuation) {
+        return ((ConstraintTrackingWorkerKt$awaitConstraintsNotMet$2) create(constraintsState, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        String str;
+        IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (this.label != 0) {
+            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+        }
+        ResultKt.throwOnFailure(obj);
+        str = ConstraintTrackingWorkerKt.TAG;
+        WorkSpec workSpec = this.$workSpec;
+        Logger.get().debug(str, "Constraints changed for " + workSpec);
+        return Unit.INSTANCE;
+    }
+}

decompiled/sources/androidx/work/impl/workers/ConstraintTrackingWorkerKt.java

@@ -0,0 +1,77 @@
+package androidx.work.impl.workers;
+
+import androidx.work.Logger;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nConstraintTrackingWorker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 ConstraintTrackingWorker.kt\nandroidx/work/impl/workers/ConstraintTrackingWorkerKt\n+ 2 Transform.kt\nkotlinx/coroutines/flow/FlowKt__TransformKt\n+ 3 Emitters.kt\nkotlinx/coroutines/flow/FlowKt__EmittersKt\n+ 4 SafeCollector.common.kt\nkotlinx/coroutines/flow/internal/SafeCollector_commonKt\n*L\n1#1,168:1\n36#2:169\n21#2:170\n23#2:174\n50#3:171\n55#3:173\n107#4:172\n*S KotlinDebug\n*F\n+ 1 ConstraintTrackingWorker.kt\nandroidx/work/impl/workers/ConstraintTrackingWorkerKt\n*L\n159#1:169\n159#1:170\n159#1:174\n159#1:171\n159#1:173\n159#1:172\n*E\n"})
+/* loaded from: classes.dex */
+public final class ConstraintTrackingWorkerKt {
+    public static final String ARGUMENT_CLASS_NAME = "androidx.work.impl.workers.ConstraintTrackingWorker.ARGUMENT_CLASS_NAME";
+    private static final String TAG;
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x0031  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.lang.Object awaitConstraintsNotMet(androidx.work.impl.constraints.WorkConstraintsTracker r4, androidx.work.impl.model.WorkSpec r5, kotlin.coroutines.Continuation r6) {
+        /*
+            boolean r0 = r6 instanceof androidx.work.impl.workers.ConstraintTrackingWorkerKt$awaitConstraintsNotMet$1
+            if (r0 == 0) goto L13
+            r0 = r6
+            androidx.work.impl.workers.ConstraintTrackingWorkerKt$awaitConstraintsNotMet$1 r0 = (androidx.work.impl.workers.ConstraintTrackingWorkerKt$awaitConstraintsNotMet$1) r0
+            int r1 = r0.label
+            r2 = -2147483648(0xffffffff80000000, float:-0.0)
+            r3 = r1 & r2
+            if (r3 == 0) goto L13
+            int r1 = r1 - r2
+            r0.label = r1
+            goto L18
+        L13:
+            androidx.work.impl.workers.ConstraintTrackingWorkerKt$awaitConstraintsNotMet$1 r0 = new androidx.work.impl.workers.ConstraintTrackingWorkerKt$awaitConstraintsNotMet$1
+            r0.<init>(r6)
+        L18:
+            java.lang.Object r6 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L31
+            if (r2 != r3) goto L29
+            kotlin.ResultKt.throwOnFailure(r6)
+            goto L50
+        L29:
+            java.lang.IllegalStateException r4 = new java.lang.IllegalStateException
+            java.lang.String r5 = "call to 'resume' before 'invoke' with coroutine"
+            r4.<init>(r5)
+            throw r4
+        L31:
+            kotlin.ResultKt.throwOnFailure(r6)
+            kotlinx.coroutines.flow.Flow r4 = r4.track(r5)
+            androidx.work.impl.workers.ConstraintTrackingWorkerKt$awaitConstraintsNotMet$2 r6 = new androidx.work.impl.workers.ConstraintTrackingWorkerKt$awaitConstraintsNotMet$2
+            r2 = 0
+            r6.<init>(r5, r2)
+            kotlinx.coroutines.flow.Flow r4 = kotlinx.coroutines.flow.FlowKt.onEach(r4, r6)
+            androidx.work.impl.workers.ConstraintTrackingWorkerKt$awaitConstraintsNotMet$$inlined$filterIsInstance$1 r5 = new androidx.work.impl.workers.ConstraintTrackingWorkerKt$awaitConstraintsNotMet$$inlined$filterIsInstance$1
+            r5.<init>()
+            r0.label = r3
+            java.lang.Object r6 = kotlinx.coroutines.flow.FlowKt.first(r5, r0)
+            if (r6 != r1) goto L50
+            return r1
+        L50:
+            androidx.work.impl.constraints.ConstraintsState$ConstraintsNotMet r6 = (androidx.work.impl.constraints.ConstraintsState.ConstraintsNotMet) r6
+            int r4 = r6.getReason()
+            java.lang.Integer r4 = kotlin.coroutines.jvm.internal.Boxing.boxInt(r4)
+            return r4
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.work.impl.workers.ConstraintTrackingWorkerKt.awaitConstraintsNotMet(androidx.work.impl.constraints.WorkConstraintsTracker, androidx.work.impl.model.WorkSpec, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("ConstraintTrkngWrkr");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"ConstraintTrkngWrkr\")");
+        TAG = tagWithPrefix;
+    }
+}

decompiled/sources/androidx/work/impl/workers/DiagnosticsWorker.java

@@ -0,0 +1,81 @@
+package androidx.work.impl.workers;
+
+import android.content.Context;
+import androidx.work.ListenableWorker;
+import androidx.work.Logger;
+import androidx.work.Worker;
+import androidx.work.WorkerParameters;
+import androidx.work.impl.WorkDatabase;
+import androidx.work.impl.WorkManagerImpl;
+import androidx.work.impl.model.SystemIdInfoDao;
+import androidx.work.impl.model.WorkNameDao;
+import androidx.work.impl.model.WorkSpec;
+import androidx.work.impl.model.WorkSpecDao;
+import androidx.work.impl.model.WorkTagDao;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class DiagnosticsWorker extends Worker {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public DiagnosticsWorker(Context context, WorkerParameters parameters) {
+        super(context, parameters);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(parameters, "parameters");
+    }
+
+    @Override // androidx.work.Worker
+    public ListenableWorker.Result doWork() {
+        String str;
+        String str2;
+        String workSpecRows;
+        String str3;
+        String str4;
+        String workSpecRows2;
+        String str5;
+        String str6;
+        String workSpecRows3;
+        WorkManagerImpl workManagerImpl = WorkManagerImpl.getInstance(getApplicationContext());
+        Intrinsics.checkNotNullExpressionValue(workManagerImpl, "getInstance(applicationContext)");
+        WorkDatabase workDatabase = workManagerImpl.getWorkDatabase();
+        Intrinsics.checkNotNullExpressionValue(workDatabase, "workManager.workDatabase");
+        WorkSpecDao workSpecDao = workDatabase.workSpecDao();
+        WorkNameDao workNameDao = workDatabase.workNameDao();
+        WorkTagDao workTagDao = workDatabase.workTagDao();
+        SystemIdInfoDao systemIdInfoDao = workDatabase.systemIdInfoDao();
+        List<WorkSpec> recentlyCompletedWork = workSpecDao.getRecentlyCompletedWork(workManagerImpl.getConfiguration().getClock().currentTimeMillis() - TimeUnit.DAYS.toMillis(1L));
+        List<WorkSpec> runningWork = workSpecDao.getRunningWork();
+        List<WorkSpec> allEligibleWorkSpecsForScheduling = workSpecDao.getAllEligibleWorkSpecsForScheduling(200);
+        if (!recentlyCompletedWork.isEmpty()) {
+            Logger logger = Logger.get();
+            str5 = DiagnosticsWorkerKt.TAG;
+            logger.info(str5, "Recently completed work:\n\n");
+            Logger logger2 = Logger.get();
+            str6 = DiagnosticsWorkerKt.TAG;
+            workSpecRows3 = DiagnosticsWorkerKt.workSpecRows(workNameDao, workTagDao, systemIdInfoDao, recentlyCompletedWork);
+            logger2.info(str6, workSpecRows3);
+        }
+        if (!runningWork.isEmpty()) {
+            Logger logger3 = Logger.get();
+            str3 = DiagnosticsWorkerKt.TAG;
+            logger3.info(str3, "Running work:\n\n");
+            Logger logger4 = Logger.get();
+            str4 = DiagnosticsWorkerKt.TAG;
+            workSpecRows2 = DiagnosticsWorkerKt.workSpecRows(workNameDao, workTagDao, systemIdInfoDao, runningWork);
+            logger4.info(str4, workSpecRows2);
+        }
+        if (!allEligibleWorkSpecsForScheduling.isEmpty()) {
+            Logger logger5 = Logger.get();
+            str = DiagnosticsWorkerKt.TAG;
+            logger5.info(str, "Enqueued work:\n\n");
+            Logger logger6 = Logger.get();
+            str2 = DiagnosticsWorkerKt.TAG;
+            workSpecRows = DiagnosticsWorkerKt.workSpecRows(workNameDao, workTagDao, systemIdInfoDao, allEligibleWorkSpecsForScheduling);
+            logger6.info(str2, workSpecRows);
+        }
+        ListenableWorker.Result success = ListenableWorker.Result.success();
+        Intrinsics.checkNotNullExpressionValue(success, "success()");
+        return success;
+    }
+}

decompiled/sources/androidx/work/impl/workers/DiagnosticsWorkerKt.java

@@ -0,0 +1,47 @@
+package androidx.work.impl.workers;
+
+import androidx.work.Logger;
+import androidx.work.impl.model.SystemIdInfo;
+import androidx.work.impl.model.SystemIdInfoDao;
+import androidx.work.impl.model.WorkNameDao;
+import androidx.work.impl.model.WorkSpec;
+import androidx.work.impl.model.WorkSpecKt;
+import androidx.work.impl.model.WorkTagDao;
+import java.util.List;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nDiagnosticsWorker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 DiagnosticsWorker.kt\nandroidx/work/impl/workers/DiagnosticsWorkerKt\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,86:1\n1855#2,2:87\n*S KotlinDebug\n*F\n+ 1 DiagnosticsWorker.kt\nandroidx/work/impl/workers/DiagnosticsWorkerKt\n*L\n75#1:87,2\n*E\n"})
+/* loaded from: classes.dex */
+public final class DiagnosticsWorkerKt {
+    private static final String TAG;
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("DiagnosticsWrkr");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"DiagnosticsWrkr\")");
+        TAG = tagWithPrefix;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final String workSpecRows(WorkNameDao workNameDao, WorkTagDao workTagDao, SystemIdInfoDao systemIdInfoDao, List<WorkSpec> list) {
+        String joinToString$default;
+        String joinToString$default2;
+        StringBuilder sb = new StringBuilder();
+        sb.append("\n Id \t Class Name\t Job Id\t State\t Unique Name\t Tags\t");
+        for (WorkSpec workSpec : list) {
+            SystemIdInfo systemIdInfo = systemIdInfoDao.getSystemIdInfo(WorkSpecKt.generationalId(workSpec));
+            Integer valueOf = systemIdInfo != null ? Integer.valueOf(systemIdInfo.systemId) : null;
+            joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(workNameDao.getNamesForWorkSpecId(workSpec.id), ",", null, null, 0, null, null, 62, null);
+            joinToString$default2 = CollectionsKt___CollectionsKt.joinToString$default(workTagDao.getTagsForWorkSpecId(workSpec.id), ",", null, null, 0, null, null, 62, null);
+            sb.append(workSpecRow(workSpec, joinToString$default, valueOf, joinToString$default2));
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
+        return sb2;
+    }
+
+    private static final String workSpecRow(WorkSpec workSpec, String str, Integer num, String str2) {
+        return '\n' + workSpec.id + "\t " + workSpec.workerClassName + "\t " + num + "\t " + workSpec.state.name() + "\t " + str + "\t " + str2 + '\t';
+    }
+}