Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/androidx/work/impl/constraints/ConstraintListener.java

@@ -0,0 +1,9 @@
+package androidx.work.impl.constraints;
+
+import androidx.annotation.MainThread;
+
+/* loaded from: classes.dex */
+public interface ConstraintListener<T> {
+    @MainThread
+    void onConstraintChanged(T t);
+}

decompiled-community/sources/androidx/work/impl/constraints/ConstraintsState.java

@@ -0,0 +1,64 @@
+package androidx.work.impl.constraints;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+
+/* loaded from: classes.dex */
+public abstract class ConstraintsState {
+    public /* synthetic */ ConstraintsState(DefaultConstructorMarker defaultConstructorMarker) {
+        this();
+    }
+
+    public static final class ConstraintsMet extends ConstraintsState {
+        public static final ConstraintsMet INSTANCE = new ConstraintsMet();
+
+        private ConstraintsMet() {
+            super(null);
+        }
+    }
+
+    private ConstraintsState() {
+    }
+
+    public static final class ConstraintsNotMet extends ConstraintsState {
+        private final int reason;
+
+        public static /* synthetic */ ConstraintsNotMet copy$default(ConstraintsNotMet constraintsNotMet, int i, int i2, Object obj) {
+            if ((i2 & 1) != 0) {
+                i = constraintsNotMet.reason;
+            }
+            return constraintsNotMet.copy(i);
+        }
+
+        public final int component1() {
+            return this.reason;
+        }
+
+        public final ConstraintsNotMet copy(int i) {
+            return new ConstraintsNotMet(i);
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            return (obj instanceof ConstraintsNotMet) && this.reason == ((ConstraintsNotMet) obj).reason;
+        }
+
+        public final int getReason() {
+            return this.reason;
+        }
+
+        public int hashCode() {
+            return Integer.hashCode(this.reason);
+        }
+
+        public String toString() {
+            return "ConstraintsNotMet(reason=" + this.reason + ')';
+        }
+
+        public ConstraintsNotMet(int i) {
+            super(null);
+            this.reason = i;
+        }
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/NetworkRequestConstraintController$track$1$job$1.java

@@ -0,0 +1,72 @@
+package androidx.work.impl.constraints;
+
+import androidx.work.Logger;
+import androidx.work.impl.constraints.ConstraintsState;
+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;
+import kotlinx.coroutines.DelayKt;
+import kotlinx.coroutines.channels.ProducerScope;
+
+@DebugMetadata(c = "androidx.work.impl.constraints.NetworkRequestConstraintController$track$1$job$1", f = "WorkConstraintsTracker.kt", l = {148}, m = "invokeSuspend")
+/* loaded from: classes.dex */
+public final class NetworkRequestConstraintController$track$1$job$1 extends SuspendLambda implements Function2 {
+    final /* synthetic */ ProducerScope $$this$callbackFlow;
+    int label;
+    final /* synthetic */ NetworkRequestConstraintController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public NetworkRequestConstraintController$track$1$job$1(NetworkRequestConstraintController networkRequestConstraintController, ProducerScope producerScope, Continuation continuation) {
+        super(2, continuation);
+        this.this$0 = networkRequestConstraintController;
+        this.$$this$callbackFlow = producerScope;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new NetworkRequestConstraintController$track$1$job$1(this.this$0, this.$$this$callbackFlow, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((NetworkRequestConstraintController$track$1$job$1) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        long j;
+        String str;
+        long j2;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            j = this.this$0.timeoutMs;
+            this.label = 1;
+            if (DelayKt.delay(j, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        Logger logger = Logger.get();
+        str = WorkConstraintsTrackerKt.TAG;
+        StringBuilder sb = new StringBuilder();
+        sb.append("NetworkRequestConstraintController didn't receive neither  onCapabilitiesChanged/onLost callback, sending `ConstraintsNotMet` after ");
+        j2 = this.this$0.timeoutMs;
+        sb.append(j2);
+        sb.append(" ms");
+        logger.debug(str, sb.toString());
+        this.$$this$callbackFlow.mo4126trySendJP2dKIU(new ConstraintsState.ConstraintsNotMet(7));
+        return Unit.INSTANCE;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/NetworkRequestConstraintController$track$1.java

@@ -0,0 +1,137 @@
+package androidx.work.impl.constraints;
+
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkRequest;
+import androidx.work.Constraints;
+import androidx.work.Logger;
+import androidx.work.impl.constraints.ConstraintsState;
+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.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.BuildersKt__Builders_commonKt;
+import kotlinx.coroutines.Job;
+import kotlinx.coroutines.channels.ProduceKt;
+import kotlinx.coroutines.channels.ProducerScope;
+import kotlinx.coroutines.channels.SendChannel;
+
+@DebugMetadata(c = "androidx.work.impl.constraints.NetworkRequestConstraintController$track$1", f = "WorkConstraintsTracker.kt", l = {182}, m = "invokeSuspend")
+/* loaded from: classes.dex */
+public final class NetworkRequestConstraintController$track$1 extends SuspendLambda implements Function2 {
+    final /* synthetic */ Constraints $constraints;
+    private /* synthetic */ Object L$0;
+    int label;
+    final /* synthetic */ NetworkRequestConstraintController this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public NetworkRequestConstraintController$track$1(Constraints constraints, NetworkRequestConstraintController networkRequestConstraintController, Continuation continuation) {
+        super(2, continuation);
+        this.$constraints = constraints;
+        this.this$0 = networkRequestConstraintController;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        NetworkRequestConstraintController$track$1 networkRequestConstraintController$track$1 = new NetworkRequestConstraintController$track$1(this.$constraints, this.this$0, continuation);
+        networkRequestConstraintController$track$1.L$0 = obj;
+        return networkRequestConstraintController$track$1;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(ProducerScope producerScope, Continuation continuation) {
+        return ((NetworkRequestConstraintController$track$1) create(producerScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r4v1, types: [android.net.ConnectivityManager$NetworkCallback, androidx.work.impl.constraints.NetworkRequestConstraintController$track$1$networkCallback$1] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        final Job launch$default;
+        String str;
+        ConnectivityManager connectivityManager;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            final ProducerScope producerScope = (ProducerScope) this.L$0;
+            NetworkRequest requiredNetworkRequest = this.$constraints.getRequiredNetworkRequest();
+            if (requiredNetworkRequest != null) {
+                launch$default = BuildersKt__Builders_commonKt.launch$default(producerScope, null, null, new NetworkRequestConstraintController$track$1$job$1(this.this$0, producerScope, null), 3, null);
+                final ?? r4 = new ConnectivityManager.NetworkCallback() { // from class: androidx.work.impl.constraints.NetworkRequestConstraintController$track$1$networkCallback$1
+                    @Override // android.net.ConnectivityManager.NetworkCallback
+                    public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {
+                        String str2;
+                        Intrinsics.checkNotNullParameter(network, "network");
+                        Intrinsics.checkNotNullParameter(networkCapabilities, "networkCapabilities");
+                        Job.DefaultImpls.cancel$default(Job.this, null, 1, null);
+                        Logger logger = Logger.get();
+                        str2 = WorkConstraintsTrackerKt.TAG;
+                        logger.debug(str2, "NetworkRequestConstraintController onCapabilitiesChanged callback");
+                        producerScope.mo4126trySendJP2dKIU(ConstraintsState.ConstraintsMet.INSTANCE);
+                    }
+
+                    @Override // android.net.ConnectivityManager.NetworkCallback
+                    public void onLost(Network network) {
+                        String str2;
+                        Intrinsics.checkNotNullParameter(network, "network");
+                        Job.DefaultImpls.cancel$default(Job.this, null, 1, null);
+                        Logger logger = Logger.get();
+                        str2 = WorkConstraintsTrackerKt.TAG;
+                        logger.debug(str2, "NetworkRequestConstraintController onLost callback");
+                        producerScope.mo4126trySendJP2dKIU(new ConstraintsState.ConstraintsNotMet(7));
+                    }
+                };
+                Logger logger = Logger.get();
+                str = WorkConstraintsTrackerKt.TAG;
+                logger.debug(str, "NetworkRequestConstraintController register callback");
+                connectivityManager = this.this$0.connManager;
+                connectivityManager.registerNetworkCallback(requiredNetworkRequest, (ConnectivityManager.NetworkCallback) r4);
+                final NetworkRequestConstraintController networkRequestConstraintController = this.this$0;
+                Function0 function0 = new Function0() { // from class: androidx.work.impl.constraints.NetworkRequestConstraintController$track$1.1
+                    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                    {
+                        super(0);
+                    }
+
+                    @Override // kotlin.jvm.functions.Function0
+                    public /* bridge */ /* synthetic */ Object invoke() {
+                        m191invoke();
+                        return Unit.INSTANCE;
+                    }
+
+                    /* renamed from: invoke, reason: collision with other method in class */
+                    public final void m191invoke() {
+                        String str2;
+                        ConnectivityManager connectivityManager2;
+                        Logger logger2 = Logger.get();
+                        str2 = WorkConstraintsTrackerKt.TAG;
+                        logger2.debug(str2, "NetworkRequestConstraintController unregister callback");
+                        connectivityManager2 = NetworkRequestConstraintController.this.connManager;
+                        connectivityManager2.unregisterNetworkCallback(r4);
+                    }
+                };
+                this.label = 1;
+                if (ProduceKt.awaitClose(producerScope, function0, this) == coroutine_suspended) {
+                    return coroutine_suspended;
+                }
+            } else {
+                SendChannel.DefaultImpls.close$default(producerScope.getChannel(), null, 1, null);
+                return Unit.INSTANCE;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/NetworkRequestConstraintController.java

@@ -0,0 +1,49 @@
+package androidx.work.impl.constraints;
+
+import android.net.ConnectivityManager;
+import androidx.annotation.RequiresApi;
+import androidx.work.Constraints;
+import androidx.work.impl.constraints.controllers.ConstraintController;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowKt;
+
+@RequiresApi(28)
+/* loaded from: classes.dex */
+public final class NetworkRequestConstraintController implements ConstraintController {
+    private final ConnectivityManager connManager;
+    private final long timeoutMs;
+
+    public NetworkRequestConstraintController(ConnectivityManager connManager, long j) {
+        Intrinsics.checkNotNullParameter(connManager, "connManager");
+        this.connManager = connManager;
+        this.timeoutMs = j;
+    }
+
+    public /* synthetic */ NetworkRequestConstraintController(ConnectivityManager connectivityManager, long j, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(connectivityManager, (i & 2) != 0 ? WorkConstraintsTrackerKt.DefaultNetworkRequestTimeoutMs : j);
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public Flow track(Constraints constraints) {
+        Intrinsics.checkNotNullParameter(constraints, "constraints");
+        return FlowKt.callbackFlow(new NetworkRequestConstraintController$track$1(constraints, this, null));
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public boolean hasConstraint(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        return workSpec.constraints.getRequiredNetworkRequest() != null;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public boolean isCurrentlyConstrained(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        if (hasConstraint(workSpec)) {
+            throw new IllegalStateException("isCurrentlyConstrained() must never be called onNetworkRequestConstraintController. isCurrentlyConstrained() is called only on older platforms where NetworkRequest isn't supported");
+        }
+        return false;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/NetworkState.java

@@ -0,0 +1,87 @@
+package androidx.work.impl.constraints;
+
+/* loaded from: classes.dex */
+public final class NetworkState {
+    private final boolean isConnected;
+    private final boolean isMetered;
+    private final boolean isNotRoaming;
+    private final boolean isValidated;
+
+    public static /* synthetic */ NetworkState copy$default(NetworkState networkState, boolean z, boolean z2, boolean z3, boolean z4, int i, Object obj) {
+        if ((i & 1) != 0) {
+            z = networkState.isConnected;
+        }
+        if ((i & 2) != 0) {
+            z2 = networkState.isValidated;
+        }
+        if ((i & 4) != 0) {
+            z3 = networkState.isMetered;
+        }
+        if ((i & 8) != 0) {
+            z4 = networkState.isNotRoaming;
+        }
+        return networkState.copy(z, z2, z3, z4);
+    }
+
+    public final boolean component1() {
+        return this.isConnected;
+    }
+
+    public final boolean component2() {
+        return this.isValidated;
+    }
+
+    public final boolean component3() {
+        return this.isMetered;
+    }
+
+    public final boolean component4() {
+        return this.isNotRoaming;
+    }
+
+    public final NetworkState copy(boolean z, boolean z2, boolean z3, boolean z4) {
+        return new NetworkState(z, z2, z3, z4);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof NetworkState)) {
+            return false;
+        }
+        NetworkState networkState = (NetworkState) obj;
+        return this.isConnected == networkState.isConnected && this.isValidated == networkState.isValidated && this.isMetered == networkState.isMetered && this.isNotRoaming == networkState.isNotRoaming;
+    }
+
+    public int hashCode() {
+        return (((((Boolean.hashCode(this.isConnected) * 31) + Boolean.hashCode(this.isValidated)) * 31) + Boolean.hashCode(this.isMetered)) * 31) + Boolean.hashCode(this.isNotRoaming);
+    }
+
+    public final boolean isConnected() {
+        return this.isConnected;
+    }
+
+    public final boolean isMetered() {
+        return this.isMetered;
+    }
+
+    public final boolean isNotRoaming() {
+        return this.isNotRoaming;
+    }
+
+    public final boolean isValidated() {
+        return this.isValidated;
+    }
+
+    public String toString() {
+        return "NetworkState(isConnected=" + this.isConnected + ", isValidated=" + this.isValidated + ", isMetered=" + this.isMetered + ", isNotRoaming=" + this.isNotRoaming + ')';
+    }
+
+    public NetworkState(boolean z, boolean z2, boolean z3, boolean z4) {
+        this.isConnected = z;
+        this.isValidated = z2;
+        this.isMetered = z3;
+        this.isNotRoaming = z4;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/OnConstraintsStateChangedListener.java

@@ -0,0 +1,8 @@
+package androidx.work.impl.constraints;
+
+import androidx.work.impl.model.WorkSpec;
+
+/* loaded from: classes.dex */
+public interface OnConstraintsStateChangedListener {
+    void onConstraintsStateChanged(WorkSpec workSpec, ConstraintsState constraintsState);
+}

decompiled-community/sources/androidx/work/impl/constraints/WorkConstraintsTracker.java

@@ -0,0 +1,233 @@
+package androidx.work.impl.constraints;
+
+import androidx.work.Logger;
+import androidx.work.impl.constraints.ConstraintsState;
+import androidx.work.impl.constraints.controllers.ConstraintController;
+import androidx.work.impl.model.WorkSpec;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+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.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowCollector;
+import kotlinx.coroutines.flow.FlowKt;
+import kotlinx.coroutines.flow.internal.CombineKt;
+
+@SourceDebugExtension({"SMAP\nWorkConstraintsTracker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 WorkConstraintsTracker.kt\nandroidx/work/impl/constraints/WorkConstraintsTracker\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n+ 3 Zip.kt\nkotlinx/coroutines/flow/FlowKt__ZipKt\n+ 4 ArraysJVM.kt\nkotlin/collections/ArraysKt__ArraysJVMKt\n+ 5 SafeCollector.common.kt\nkotlinx/coroutines/flow/internal/SafeCollector_commonKt\n*L\n1#1,205:1\n766#2:206\n857#2,2:207\n1549#2:209\n1620#2,3:210\n766#2:218\n857#2,2:219\n287#3:213\n288#3:216\n37#4,2:214\n107#5:217\n*S KotlinDebug\n*F\n+ 1 WorkConstraintsTracker.kt\nandroidx/work/impl/constraints/WorkConstraintsTracker\n*L\n92#1:206\n92#1:207,2\n92#1:209\n92#1:210,3\n100#1:218\n100#1:219,2\n93#1:213\n93#1:216\n93#1:214,2\n93#1:217\n*E\n"})
+/* loaded from: classes.dex */
+public final class WorkConstraintsTracker {
+    private final List<ConstraintController> controllers;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public WorkConstraintsTracker(List<? extends ConstraintController> controllers) {
+        Intrinsics.checkNotNullParameter(controllers, "controllers");
+        this.controllers = controllers;
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public WorkConstraintsTracker(androidx.work.impl.constraints.trackers.Trackers r4) {
+        /*
+            r3 = this;
+            java.lang.String r0 = "trackers"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r4, r0)
+            r0 = 8
+            androidx.work.impl.constraints.controllers.ConstraintController[] r0 = new androidx.work.impl.constraints.controllers.ConstraintController[r0]
+            androidx.work.impl.constraints.controllers.BatteryChargingController r1 = new androidx.work.impl.constraints.controllers.BatteryChargingController
+            androidx.work.impl.constraints.trackers.ConstraintTracker r2 = r4.getBatteryChargingTracker()
+            r1.<init>(r2)
+            r2 = 0
+            r0[r2] = r1
+            androidx.work.impl.constraints.controllers.BatteryNotLowController r1 = new androidx.work.impl.constraints.controllers.BatteryNotLowController
+            androidx.work.impl.constraints.trackers.BatteryNotLowTracker r2 = r4.getBatteryNotLowTracker()
+            r1.<init>(r2)
+            r2 = 1
+            r0[r2] = r1
+            androidx.work.impl.constraints.controllers.StorageNotLowController r1 = new androidx.work.impl.constraints.controllers.StorageNotLowController
+            androidx.work.impl.constraints.trackers.ConstraintTracker r2 = r4.getStorageNotLowTracker()
+            r1.<init>(r2)
+            r2 = 2
+            r0[r2] = r1
+            androidx.work.impl.constraints.controllers.NetworkConnectedController r1 = new androidx.work.impl.constraints.controllers.NetworkConnectedController
+            androidx.work.impl.constraints.trackers.ConstraintTracker r2 = r4.getNetworkStateTracker()
+            r1.<init>(r2)
+            r2 = 3
+            r0[r2] = r1
+            androidx.work.impl.constraints.controllers.NetworkUnmeteredController r1 = new androidx.work.impl.constraints.controllers.NetworkUnmeteredController
+            androidx.work.impl.constraints.trackers.ConstraintTracker r2 = r4.getNetworkStateTracker()
+            r1.<init>(r2)
+            r2 = 4
+            r0[r2] = r1
+            androidx.work.impl.constraints.controllers.NetworkNotRoamingController r1 = new androidx.work.impl.constraints.controllers.NetworkNotRoamingController
+            androidx.work.impl.constraints.trackers.ConstraintTracker r2 = r4.getNetworkStateTracker()
+            r1.<init>(r2)
+            r2 = 5
+            r0[r2] = r1
+            androidx.work.impl.constraints.controllers.NetworkMeteredController r1 = new androidx.work.impl.constraints.controllers.NetworkMeteredController
+            androidx.work.impl.constraints.trackers.ConstraintTracker r2 = r4.getNetworkStateTracker()
+            r1.<init>(r2)
+            r2 = 6
+            r0[r2] = r1
+            int r1 = android.os.Build.VERSION.SDK_INT
+            r2 = 28
+            if (r1 < r2) goto L6c
+            android.content.Context r4 = r4.getContext()
+            androidx.work.impl.constraints.NetworkRequestConstraintController r4 = androidx.work.impl.constraints.WorkConstraintsTrackerKt.NetworkRequestConstraintController(r4)
+            goto L6d
+        L6c:
+            r4 = 0
+        L6d:
+            r1 = 7
+            r0[r1] = r4
+            java.util.List r4 = kotlin.collections.CollectionsKt.listOfNotNull(r0)
+            r3.<init>(r4)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.work.impl.constraints.WorkConstraintsTracker.<init>(androidx.work.impl.constraints.trackers.Trackers):void");
+    }
+
+    public final Flow track(WorkSpec spec) {
+        Intrinsics.checkNotNullParameter(spec, "spec");
+        List<ConstraintController> list = this.controllers;
+        ArrayList arrayList = new ArrayList();
+        for (Object obj : list) {
+            if (((ConstraintController) obj).hasConstraint(spec)) {
+                arrayList.add(obj);
+            }
+        }
+        ArrayList arrayList2 = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(arrayList, 10));
+        Iterator it = arrayList.iterator();
+        while (it.hasNext()) {
+            arrayList2.add(((ConstraintController) it.next()).track(spec.constraints));
+        }
+        final Flow[] flowArr = (Flow[]) CollectionsKt___CollectionsKt.toList(arrayList2).toArray(new Flow[0]);
+        return FlowKt.distinctUntilChanged(new Flow() { // from class: androidx.work.impl.constraints.WorkConstraintsTracker$track$$inlined$combine$1
+            @Override // kotlinx.coroutines.flow.Flow
+            public Object collect(FlowCollector flowCollector, Continuation continuation) {
+                Object coroutine_suspended;
+                final Flow[] flowArr2 = flowArr;
+                Object combineInternal = CombineKt.combineInternal(flowCollector, flowArr2, new Function0() { // from class: androidx.work.impl.constraints.WorkConstraintsTracker$track$$inlined$combine$1.2
+                    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                    {
+                        super(0);
+                    }
+
+                    @Override // kotlin.jvm.functions.Function0
+                    public final ConstraintsState[] invoke() {
+                        return new ConstraintsState[flowArr2.length];
+                    }
+                }, new AnonymousClass3(null), continuation);
+                coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                return combineInternal == coroutine_suspended ? combineInternal : Unit.INSTANCE;
+            }
+
+            @DebugMetadata(c = "androidx.work.impl.constraints.WorkConstraintsTracker$track$$inlined$combine$1$3", f = "WorkConstraintsTracker.kt", l = {292}, m = "invokeSuspend")
+            @SourceDebugExtension({"SMAP\nZip.kt\nKotlin\n*S Kotlin\n*F\n+ 1 Zip.kt\nkotlinx/coroutines/flow/FlowKt__ZipKt$combine$6$2\n+ 2 WorkConstraintsTracker.kt\nandroidx/work/impl/constraints/WorkConstraintsTracker\n+ 3 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n*L\n1#1,332:1\n94#2:333\n1282#3,2:334\n*S KotlinDebug\n*F\n+ 1 WorkConstraintsTracker.kt\nandroidx/work/impl/constraints/WorkConstraintsTracker\n*L\n94#1:334,2\n*E\n"})
+            /* renamed from: androidx.work.impl.constraints.WorkConstraintsTracker$track$$inlined$combine$1$3, reason: invalid class name */
+            public static final class AnonymousClass3 extends SuspendLambda implements Function3 {
+                private /* synthetic */ Object L$0;
+                /* synthetic */ Object L$1;
+                int label;
+
+                public AnonymousClass3(Continuation continuation) {
+                    super(3, continuation);
+                }
+
+                @Override // kotlin.jvm.functions.Function3
+                public final Object invoke(FlowCollector flowCollector, ConstraintsState[] constraintsStateArr, Continuation continuation) {
+                    AnonymousClass3 anonymousClass3 = new AnonymousClass3(continuation);
+                    anonymousClass3.L$0 = flowCollector;
+                    anonymousClass3.L$1 = constraintsStateArr;
+                    return anonymousClass3.invokeSuspend(Unit.INSTANCE);
+                }
+
+                @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+                public final Object invokeSuspend(Object obj) {
+                    Object coroutine_suspended;
+                    ConstraintsState constraintsState;
+                    coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                    int i = this.label;
+                    if (i == 0) {
+                        ResultKt.throwOnFailure(obj);
+                        FlowCollector flowCollector = (FlowCollector) this.L$0;
+                        ConstraintsState[] constraintsStateArr = (ConstraintsState[]) ((Object[]) this.L$1);
+                        int length = constraintsStateArr.length;
+                        int i2 = 0;
+                        while (true) {
+                            if (i2 >= length) {
+                                constraintsState = null;
+                                break;
+                            }
+                            constraintsState = constraintsStateArr[i2];
+                            if (!Intrinsics.areEqual(constraintsState, ConstraintsState.ConstraintsMet.INSTANCE)) {
+                                break;
+                            }
+                            i2++;
+                        }
+                        if (constraintsState == null) {
+                            constraintsState = ConstraintsState.ConstraintsMet.INSTANCE;
+                        }
+                        this.label = 1;
+                        if (flowCollector.emit(constraintsState, this) == coroutine_suspended) {
+                            return coroutine_suspended;
+                        }
+                    } else {
+                        if (i != 1) {
+                            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+                        }
+                        ResultKt.throwOnFailure(obj);
+                    }
+                    return Unit.INSTANCE;
+                }
+            }
+        });
+    }
+
+    public final boolean areAllConstraintsMet(WorkSpec workSpec) {
+        String str;
+        String joinToString$default;
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        List<ConstraintController> list = this.controllers;
+        ArrayList arrayList = new ArrayList();
+        for (Object obj : list) {
+            if (((ConstraintController) obj).isCurrentlyConstrained(workSpec)) {
+                arrayList.add(obj);
+            }
+        }
+        if (!arrayList.isEmpty()) {
+            Logger logger = Logger.get();
+            str = WorkConstraintsTrackerKt.TAG;
+            StringBuilder sb = new StringBuilder();
+            sb.append("Work ");
+            sb.append(workSpec.id);
+            sb.append(" constrained by ");
+            joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(arrayList, null, null, null, 0, null, new Function1() { // from class: androidx.work.impl.constraints.WorkConstraintsTracker$areAllConstraintsMet$1
+                @Override // kotlin.jvm.functions.Function1
+                public final CharSequence invoke(ConstraintController it) {
+                    Intrinsics.checkNotNullParameter(it, "it");
+                    String simpleName = it.getClass().getSimpleName();
+                    Intrinsics.checkNotNullExpressionValue(simpleName, "it.javaClass.simpleName");
+                    return simpleName;
+                }
+            }, 31, null);
+            sb.append(joinToString$default);
+            logger.debug(str, sb.toString());
+        }
+        return arrayList.isEmpty();
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/WorkConstraintsTrackerKt$listen$1.java

@@ -0,0 +1,70 @@
+package androidx.work.impl.constraints;
+
+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;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowCollector;
+
+@DebugMetadata(c = "androidx.work.impl.constraints.WorkConstraintsTrackerKt$listen$1", f = "WorkConstraintsTracker.kt", l = {64}, m = "invokeSuspend")
+/* loaded from: classes.dex */
+public final class WorkConstraintsTrackerKt$listen$1 extends SuspendLambda implements Function2 {
+    final /* synthetic */ OnConstraintsStateChangedListener $listener;
+    final /* synthetic */ WorkSpec $spec;
+    final /* synthetic */ WorkConstraintsTracker $this_listen;
+    int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public WorkConstraintsTrackerKt$listen$1(WorkConstraintsTracker workConstraintsTracker, WorkSpec workSpec, OnConstraintsStateChangedListener onConstraintsStateChangedListener, Continuation continuation) {
+        super(2, continuation);
+        this.$this_listen = workConstraintsTracker;
+        this.$spec = workSpec;
+        this.$listener = onConstraintsStateChangedListener;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new WorkConstraintsTrackerKt$listen$1(this.$this_listen, this.$spec, this.$listener, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((WorkConstraintsTrackerKt$listen$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);
+            Flow track = this.$this_listen.track(this.$spec);
+            final OnConstraintsStateChangedListener onConstraintsStateChangedListener = this.$listener;
+            final WorkSpec workSpec = this.$spec;
+            FlowCollector flowCollector = new FlowCollector() { // from class: androidx.work.impl.constraints.WorkConstraintsTrackerKt$listen$1.1
+                @Override // kotlinx.coroutines.flow.FlowCollector
+                public final Object emit(ConstraintsState constraintsState, Continuation continuation) {
+                    OnConstraintsStateChangedListener.this.onConstraintsStateChanged(workSpec, constraintsState);
+                    return Unit.INSTANCE;
+                }
+            };
+            this.label = 1;
+            if (track.collect(flowCollector, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/WorkConstraintsTrackerKt.java

@@ -0,0 +1,46 @@
+package androidx.work.impl.constraints;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import androidx.annotation.RequiresApi;
+import androidx.work.Logger;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.BuildersKt__Builders_commonKt;
+import kotlinx.coroutines.CompletableJob;
+import kotlinx.coroutines.CoroutineDispatcher;
+import kotlinx.coroutines.CoroutineScopeKt;
+import kotlinx.coroutines.Job;
+import kotlinx.coroutines.JobKt__JobKt;
+
+/* loaded from: classes.dex */
+public final class WorkConstraintsTrackerKt {
+    private static final long DefaultNetworkRequestTimeoutMs;
+    private static final String TAG;
+
+    public static final Job listen(WorkConstraintsTracker workConstraintsTracker, WorkSpec spec, CoroutineDispatcher dispatcher, OnConstraintsStateChangedListener listener) {
+        CompletableJob Job$default;
+        Intrinsics.checkNotNullParameter(workConstraintsTracker, "<this>");
+        Intrinsics.checkNotNullParameter(spec, "spec");
+        Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        Job$default = JobKt__JobKt.Job$default(null, 1, null);
+        BuildersKt__Builders_commonKt.launch$default(CoroutineScopeKt.CoroutineScope(dispatcher.plus(Job$default)), null, null, new WorkConstraintsTrackerKt$listen$1(workConstraintsTracker, spec, listener, null), 3, null);
+        return Job$default;
+    }
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("WorkConstraintsTracker");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"WorkConstraintsTracker\")");
+        TAG = tagWithPrefix;
+        DefaultNetworkRequestTimeoutMs = 1000L;
+    }
+
+    @RequiresApi(28)
+    public static final NetworkRequestConstraintController NetworkRequestConstraintController(Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Object systemService = context.getSystemService("connectivity");
+        Intrinsics.checkNotNull(systemService, "null cannot be cast to non-null type android.net.ConnectivityManager");
+        return new NetworkRequestConstraintController((ConnectivityManager) systemService, 0L, 2, null);
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/BaseConstraintController$track$1.java

@@ -0,0 +1,93 @@
+package androidx.work.impl.constraints.controllers;
+
+import androidx.work.impl.constraints.ConstraintListener;
+import androidx.work.impl.constraints.ConstraintsState;
+import androidx.work.impl.constraints.trackers.ConstraintTracker;
+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.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.channels.ProduceKt;
+import kotlinx.coroutines.channels.ProducerScope;
+
+@DebugMetadata(c = "androidx.work.impl.constraints.controllers.BaseConstraintController$track$1", f = "ContraintControllers.kt", l = {63}, m = "invokeSuspend")
+/* loaded from: classes.dex */
+public final class BaseConstraintController$track$1 extends SuspendLambda implements Function2 {
+    private /* synthetic */ Object L$0;
+    int label;
+    final /* synthetic */ BaseConstraintController<T> this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public BaseConstraintController$track$1(BaseConstraintController<T> baseConstraintController, Continuation continuation) {
+        super(2, continuation);
+        this.this$0 = baseConstraintController;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        BaseConstraintController$track$1 baseConstraintController$track$1 = new BaseConstraintController$track$1(this.this$0, continuation);
+        baseConstraintController$track$1.L$0 = obj;
+        return baseConstraintController$track$1;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(ProducerScope producerScope, Continuation continuation) {
+        return ((BaseConstraintController$track$1) create(producerScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [androidx.work.impl.constraints.ConstraintListener, androidx.work.impl.constraints.controllers.BaseConstraintController$track$1$listener$1] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        ConstraintTracker constraintTracker;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            final ProducerScope producerScope = (ProducerScope) this.L$0;
+            final BaseConstraintController<T> baseConstraintController = this.this$0;
+            final ?? r1 = new ConstraintListener<T>() { // from class: androidx.work.impl.constraints.controllers.BaseConstraintController$track$1$listener$1
+                @Override // androidx.work.impl.constraints.ConstraintListener
+                public void onConstraintChanged(T t) {
+                    producerScope.getChannel().mo4126trySendJP2dKIU(baseConstraintController.isConstrained(t) ? new ConstraintsState.ConstraintsNotMet(baseConstraintController.getReason()) : ConstraintsState.ConstraintsMet.INSTANCE);
+                }
+            };
+            constraintTracker = ((BaseConstraintController) this.this$0).tracker;
+            constraintTracker.addListener(r1);
+            final BaseConstraintController<T> baseConstraintController2 = this.this$0;
+            Function0 function0 = new Function0() { // from class: androidx.work.impl.constraints.controllers.BaseConstraintController$track$1.1
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                {
+                    super(0);
+                }
+
+                @Override // kotlin.jvm.functions.Function0
+                public /* bridge */ /* synthetic */ Object invoke() {
+                    m192invoke();
+                    return Unit.INSTANCE;
+                }
+
+                /* renamed from: invoke, reason: collision with other method in class */
+                public final void m192invoke() {
+                    ConstraintTracker constraintTracker2;
+                    constraintTracker2 = ((BaseConstraintController) baseConstraintController2).tracker;
+                    constraintTracker2.removeListener(r1);
+                }
+            };
+            this.label = 1;
+            if (ProduceKt.awaitClose(producerScope, function0, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/BaseConstraintController.java

@@ -0,0 +1,39 @@
+package androidx.work.impl.constraints.controllers;
+
+import androidx.work.Constraints;
+import androidx.work.impl.constraints.trackers.ConstraintTracker;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowKt;
+
+/* loaded from: classes.dex */
+public abstract class BaseConstraintController<T> implements ConstraintController {
+    private final ConstraintTracker<T> tracker;
+
+    public static /* synthetic */ void getReason$annotations() {
+    }
+
+    public abstract int getReason();
+
+    public boolean isConstrained(T t) {
+        return false;
+    }
+
+    public BaseConstraintController(ConstraintTracker<T> tracker) {
+        Intrinsics.checkNotNullParameter(tracker, "tracker");
+        this.tracker = tracker;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public Flow track(Constraints constraints) {
+        Intrinsics.checkNotNullParameter(constraints, "constraints");
+        return FlowKt.callbackFlow(new BaseConstraintController$track$1(this, null));
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public boolean isCurrentlyConstrained(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        return hasConstraint(workSpec) && isConstrained(this.tracker.readSystemState());
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/BatteryChargingController.java

@@ -0,0 +1,37 @@
+package androidx.work.impl.constraints.controllers;
+
+import androidx.work.impl.constraints.trackers.ConstraintTracker;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class BatteryChargingController extends BaseConstraintController<Boolean> {
+    private final int reason;
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public int getReason() {
+        return this.reason;
+    }
+
+    public boolean isConstrained(boolean z) {
+        return !z;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public /* bridge */ /* synthetic */ boolean isConstrained(Boolean bool) {
+        return isConstrained(bool.booleanValue());
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public BatteryChargingController(ConstraintTracker<Boolean> tracker) {
+        super(tracker);
+        Intrinsics.checkNotNullParameter(tracker, "tracker");
+        this.reason = 6;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public boolean hasConstraint(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        return workSpec.constraints.requiresCharging();
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/BatteryNotLowController.java

@@ -0,0 +1,37 @@
+package androidx.work.impl.constraints.controllers;
+
+import androidx.work.impl.constraints.trackers.BatteryNotLowTracker;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class BatteryNotLowController extends BaseConstraintController<Boolean> {
+    private final int reason;
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public int getReason() {
+        return this.reason;
+    }
+
+    public boolean isConstrained(boolean z) {
+        return !z;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public /* bridge */ /* synthetic */ boolean isConstrained(Boolean bool) {
+        return isConstrained(bool.booleanValue());
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public BatteryNotLowController(BatteryNotLowTracker tracker) {
+        super(tracker);
+        Intrinsics.checkNotNullParameter(tracker, "tracker");
+        this.reason = 5;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public boolean hasConstraint(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        return workSpec.constraints.requiresBatteryNotLow();
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/ConstraintController.java

@@ -0,0 +1,14 @@
+package androidx.work.impl.constraints.controllers;
+
+import androidx.work.Constraints;
+import androidx.work.impl.model.WorkSpec;
+import kotlinx.coroutines.flow.Flow;
+
+/* loaded from: classes.dex */
+public interface ConstraintController {
+    boolean hasConstraint(WorkSpec workSpec);
+
+    boolean isCurrentlyConstrained(WorkSpec workSpec);
+
+    Flow track(Constraints constraints);
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/NetworkConnectedController.java

@@ -0,0 +1,36 @@
+package androidx.work.impl.constraints.controllers;
+
+import androidx.work.NetworkType;
+import androidx.work.impl.constraints.NetworkState;
+import androidx.work.impl.constraints.trackers.ConstraintTracker;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class NetworkConnectedController extends BaseConstraintController<NetworkState> {
+    private final int reason;
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public int getReason() {
+        return this.reason;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public NetworkConnectedController(ConstraintTracker<NetworkState> tracker) {
+        super(tracker);
+        Intrinsics.checkNotNullParameter(tracker, "tracker");
+        this.reason = 7;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public boolean hasConstraint(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        return workSpec.constraints.getRequiredNetworkType() == NetworkType.CONNECTED;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public boolean isConstrained(NetworkState value) {
+        Intrinsics.checkNotNullParameter(value, "value");
+        return (value.isConnected() && value.isValidated()) ? false : true;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/NetworkMeteredController.java

@@ -0,0 +1,55 @@
+package androidx.work.impl.constraints.controllers;
+
+import androidx.work.Logger;
+import androidx.work.NetworkType;
+import androidx.work.impl.constraints.NetworkState;
+import androidx.work.impl.constraints.trackers.ConstraintTracker;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class NetworkMeteredController extends BaseConstraintController<NetworkState> {
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG;
+    private final int reason;
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public int getReason() {
+        return this.reason;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public NetworkMeteredController(ConstraintTracker<NetworkState> tracker) {
+        super(tracker);
+        Intrinsics.checkNotNullParameter(tracker, "tracker");
+        this.reason = 7;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public boolean hasConstraint(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        return workSpec.constraints.getRequiredNetworkType() == NetworkType.METERED;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public boolean isConstrained(NetworkState value) {
+        Intrinsics.checkNotNullParameter(value, "value");
+        return (value.isConnected() && value.isMetered()) ? false : true;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("NetworkMeteredCtrlr");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"NetworkMeteredCtrlr\")");
+        TAG = tagWithPrefix;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/NetworkNotRoamingController.java

@@ -0,0 +1,55 @@
+package androidx.work.impl.constraints.controllers;
+
+import androidx.work.Logger;
+import androidx.work.NetworkType;
+import androidx.work.impl.constraints.NetworkState;
+import androidx.work.impl.constraints.trackers.ConstraintTracker;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class NetworkNotRoamingController extends BaseConstraintController<NetworkState> {
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG;
+    private final int reason;
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public int getReason() {
+        return this.reason;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public NetworkNotRoamingController(ConstraintTracker<NetworkState> tracker) {
+        super(tracker);
+        Intrinsics.checkNotNullParameter(tracker, "tracker");
+        this.reason = 7;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public boolean hasConstraint(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        return workSpec.constraints.getRequiredNetworkType() == NetworkType.NOT_ROAMING;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public boolean isConstrained(NetworkState value) {
+        Intrinsics.checkNotNullParameter(value, "value");
+        return (value.isConnected() && value.isNotRoaming()) ? false : true;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("NetworkNotRoamingCtrlr");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"NetworkNotRoamingCtrlr\")");
+        TAG = tagWithPrefix;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/NetworkUnmeteredController.java

@@ -0,0 +1,38 @@
+package androidx.work.impl.constraints.controllers;
+
+import android.os.Build;
+import androidx.work.NetworkType;
+import androidx.work.impl.constraints.NetworkState;
+import androidx.work.impl.constraints.trackers.ConstraintTracker;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class NetworkUnmeteredController extends BaseConstraintController<NetworkState> {
+    private final int reason;
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public int getReason() {
+        return this.reason;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public NetworkUnmeteredController(ConstraintTracker<NetworkState> tracker) {
+        super(tracker);
+        Intrinsics.checkNotNullParameter(tracker, "tracker");
+        this.reason = 7;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public boolean hasConstraint(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        NetworkType requiredNetworkType = workSpec.constraints.getRequiredNetworkType();
+        return requiredNetworkType == NetworkType.UNMETERED || (Build.VERSION.SDK_INT >= 30 && requiredNetworkType == NetworkType.TEMPORARILY_UNMETERED);
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public boolean isConstrained(NetworkState value) {
+        Intrinsics.checkNotNullParameter(value, "value");
+        return !value.isConnected() || value.isMetered();
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/StorageNotLowController.java

@@ -0,0 +1,37 @@
+package androidx.work.impl.constraints.controllers;
+
+import androidx.work.impl.constraints.trackers.ConstraintTracker;
+import androidx.work.impl.model.WorkSpec;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class StorageNotLowController extends BaseConstraintController<Boolean> {
+    private final int reason;
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public int getReason() {
+        return this.reason;
+    }
+
+    public boolean isConstrained(boolean z) {
+        return !z;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.BaseConstraintController
+    public /* bridge */ /* synthetic */ boolean isConstrained(Boolean bool) {
+        return isConstrained(bool.booleanValue());
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public StorageNotLowController(ConstraintTracker<Boolean> tracker) {
+        super(tracker);
+        Intrinsics.checkNotNullParameter(tracker, "tracker");
+        this.reason = 9;
+    }
+
+    @Override // androidx.work.impl.constraints.controllers.ConstraintController
+    public boolean hasConstraint(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "workSpec");
+        return workSpec.constraints.requiresStorageNotLow();
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/controllers/package-info.java

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

decompiled-community/sources/androidx/work/impl/constraints/package-info.java

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

decompiled-community/sources/androidx/work/impl/constraints/trackers/BatteryChargingTracker.java

@@ -0,0 +1,91 @@
+package androidx.work.impl.constraints.trackers;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.annotation.RestrictTo;
+import androidx.work.Logger;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import kotlin.jvm.internal.Intrinsics;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public final class BatteryChargingTracker extends BroadcastReceiverConstraintTracker<Boolean> {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public BatteryChargingTracker(Context context, TaskExecutor taskExecutor) {
+        super(context, taskExecutor);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.ConstraintTracker
+    public Boolean readSystemState() {
+        String str;
+        Intent registerReceiver = getAppContext().registerReceiver(null, new IntentFilter("android.intent.action.BATTERY_CHANGED"));
+        if (registerReceiver == null) {
+            Logger logger = Logger.get();
+            str = BatteryChargingTrackerKt.TAG;
+            logger.error(str, "getInitialState - null intent received");
+            return Boolean.FALSE;
+        }
+        return Boolean.valueOf(isBatteryChangedIntentCharging(registerReceiver));
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.BroadcastReceiverConstraintTracker
+    public IntentFilter getIntentFilter() {
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction("android.os.action.CHARGING");
+        intentFilter.addAction("android.os.action.DISCHARGING");
+        return intentFilter;
+    }
+
+    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue
+    java.lang.NullPointerException: Cannot invoke "java.util.List.iterator()" because the return value of "jadx.core.dex.visitors.regions.SwitchOverStringVisitor$SwitchData.getNewCases()" is null
+    	at jadx.core.dex.visitors.regions.SwitchOverStringVisitor.restoreSwitchOverString(SwitchOverStringVisitor.java:109)
+    	at jadx.core.dex.visitors.regions.SwitchOverStringVisitor.visitRegion(SwitchOverStringVisitor.java:66)
+    	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseIterativeStepInternal(DepthRegionTraversal.java:77)
+    	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseIterativeStepInternal(DepthRegionTraversal.java:82)
+     */
+    @Override // androidx.work.impl.constraints.trackers.BroadcastReceiverConstraintTracker
+    public void onBroadcastReceive(Intent intent) {
+        String str;
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        String action = intent.getAction();
+        if (action == null) {
+        }
+        Logger logger = Logger.get();
+        str = BatteryChargingTrackerKt.TAG;
+        logger.debug(str, "Received " + action);
+        switch (action.hashCode()) {
+            case -1886648615:
+                if (action.equals("android.intent.action.ACTION_POWER_DISCONNECTED")) {
+                    setState(Boolean.FALSE);
+                    break;
+                }
+                break;
+            case -54942926:
+                if (action.equals("android.os.action.DISCHARGING")) {
+                    setState(Boolean.FALSE);
+                    break;
+                }
+                break;
+            case 948344062:
+                if (action.equals("android.os.action.CHARGING")) {
+                    setState(Boolean.TRUE);
+                    break;
+                }
+                break;
+            case 1019184907:
+                if (action.equals("android.intent.action.ACTION_POWER_CONNECTED")) {
+                    setState(Boolean.TRUE);
+                    break;
+                }
+                break;
+        }
+    }
+
+    private final boolean isBatteryChangedIntentCharging(Intent intent) {
+        int intExtra = intent.getIntExtra("status", -1);
+        return intExtra == 2 || intExtra == 5;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/BatteryChargingTrackerKt.java

@@ -0,0 +1,15 @@
+package androidx.work.impl.constraints.trackers;
+
+import androidx.work.Logger;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class BatteryChargingTrackerKt {
+    private static final String TAG;
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("BatteryChrgTracker");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"BatteryChrgTracker\")");
+        TAG = tagWithPrefix;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/BatteryNotLowTracker.java

@@ -0,0 +1,71 @@
+package androidx.work.impl.constraints.trackers;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.annotation.RestrictTo;
+import androidx.work.Logger;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import com.applovin.sdk.AppLovinEventTypes;
+import kotlin.jvm.internal.Intrinsics;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public final class BatteryNotLowTracker extends BroadcastReceiverConstraintTracker<Boolean> {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public BatteryNotLowTracker(Context context, TaskExecutor taskExecutor) {
+        super(context, taskExecutor);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.ConstraintTracker
+    public Boolean readSystemState() {
+        String str;
+        Intent registerReceiver = getAppContext().registerReceiver(null, new IntentFilter("android.intent.action.BATTERY_CHANGED"));
+        if (registerReceiver == null) {
+            Logger logger = Logger.get();
+            str = BatteryNotLowTrackerKt.TAG;
+            logger.error(str, "getInitialState - null intent received");
+            return Boolean.FALSE;
+        }
+        int intExtra = registerReceiver.getIntExtra("status", -1);
+        float intExtra2 = registerReceiver.getIntExtra(AppLovinEventTypes.USER_COMPLETED_LEVEL, -1) / registerReceiver.getIntExtra("scale", -1);
+        boolean z = true;
+        if (intExtra != 1 && intExtra2 <= 0.15f) {
+            z = false;
+        }
+        return Boolean.valueOf(z);
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.BroadcastReceiverConstraintTracker
+    public IntentFilter getIntentFilter() {
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction("android.intent.action.BATTERY_OKAY");
+        intentFilter.addAction("android.intent.action.BATTERY_LOW");
+        return intentFilter;
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.BroadcastReceiverConstraintTracker
+    public void onBroadcastReceive(Intent intent) {
+        String str;
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        if (intent.getAction() == null) {
+            return;
+        }
+        Logger logger = Logger.get();
+        str = BatteryNotLowTrackerKt.TAG;
+        logger.debug(str, "Received " + intent.getAction());
+        String action = intent.getAction();
+        if (action != null) {
+            int hashCode = action.hashCode();
+            if (hashCode == -1980154005) {
+                if (action.equals("android.intent.action.BATTERY_OKAY")) {
+                    setState(Boolean.TRUE);
+                }
+            } else if (hashCode == 490310653 && action.equals("android.intent.action.BATTERY_LOW")) {
+                setState(Boolean.FALSE);
+            }
+        }
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/BatteryNotLowTrackerKt.java

@@ -0,0 +1,16 @@
+package androidx.work.impl.constraints.trackers;
+
+import androidx.work.Logger;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class BatteryNotLowTrackerKt {
+    public static final float BATTERY_LOW_THRESHOLD = 0.15f;
+    private static final String TAG;
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("BatteryNotLowTracker");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"BatteryNotLowTracker\")");
+        TAG = tagWithPrefix;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/BroadcastReceiverConstraintTracker.java

@@ -0,0 +1,59 @@
+package androidx.work.impl.constraints.trackers;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.annotation.RestrictTo;
+import androidx.work.Logger;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import kotlin.jvm.internal.Intrinsics;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public abstract class BroadcastReceiverConstraintTracker<T> extends ConstraintTracker<T> {
+    private final BroadcastReceiver broadcastReceiver;
+
+    public abstract IntentFilter getIntentFilter();
+
+    public abstract void onBroadcastReceive(Intent intent);
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public BroadcastReceiverConstraintTracker(Context context, TaskExecutor taskExecutor) {
+        super(context, taskExecutor);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+        this.broadcastReceiver = new BroadcastReceiver(this) { // from class: androidx.work.impl.constraints.trackers.BroadcastReceiverConstraintTracker$broadcastReceiver$1
+            final /* synthetic */ BroadcastReceiverConstraintTracker<T> this$0;
+
+            {
+                this.this$0 = this;
+            }
+
+            @Override // android.content.BroadcastReceiver
+            public void onReceive(Context context2, Intent intent) {
+                Intrinsics.checkNotNullParameter(context2, "context");
+                Intrinsics.checkNotNullParameter(intent, "intent");
+                this.this$0.onBroadcastReceive(intent);
+            }
+        };
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.ConstraintTracker
+    public void startTracking() {
+        String str;
+        Logger logger = Logger.get();
+        str = BroadcastReceiverConstraintTrackerKt.TAG;
+        logger.debug(str, getClass().getSimpleName() + ": registering receiver");
+        getAppContext().registerReceiver(this.broadcastReceiver, getIntentFilter());
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.ConstraintTracker
+    public void stopTracking() {
+        String str;
+        Logger logger = Logger.get();
+        str = BroadcastReceiverConstraintTrackerKt.TAG;
+        logger.debug(str, getClass().getSimpleName() + ": unregistering receiver");
+        getAppContext().unregisterReceiver(this.broadcastReceiver);
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/BroadcastReceiverConstraintTrackerKt.java

@@ -0,0 +1,15 @@
+package androidx.work.impl.constraints.trackers;
+
+import androidx.work.Logger;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class BroadcastReceiverConstraintTrackerKt {
+    private static final String TAG;
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("BrdcstRcvrCnstrntTrckr");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"BrdcstRcvrCnstrntTrckr\")");
+        TAG = tagWithPrefix;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/ConstraintTracker.java

@@ -0,0 +1,112 @@
+package androidx.work.impl.constraints.trackers;
+
+import android.content.Context;
+import androidx.annotation.RestrictTo;
+import androidx.work.Logger;
+import androidx.work.impl.constraints.ConstraintListener;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import kotlin.Unit;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+@SourceDebugExtension({"SMAP\nConstraintTracker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 ConstraintTracker.kt\nandroidx/work/impl/constraints/trackers/ConstraintTracker\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,113:1\n1855#2,2:114\n*S KotlinDebug\n*F\n+ 1 ConstraintTracker.kt\nandroidx/work/impl/constraints/trackers/ConstraintTracker\n*L\n90#1:114,2\n*E\n"})
+/* loaded from: classes.dex */
+public abstract class ConstraintTracker<T> {
+    private final Context appContext;
+    private T currentState;
+    private final LinkedHashSet<ConstraintListener<T>> listeners;
+    private final Object lock;
+    private final TaskExecutor taskExecutor;
+
+    public final Context getAppContext() {
+        return this.appContext;
+    }
+
+    public abstract T readSystemState();
+
+    public abstract void startTracking();
+
+    public abstract void stopTracking();
+
+    public ConstraintTracker(Context context, TaskExecutor taskExecutor) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+        this.taskExecutor = taskExecutor;
+        Context applicationContext = context.getApplicationContext();
+        Intrinsics.checkNotNullExpressionValue(applicationContext, "context.applicationContext");
+        this.appContext = applicationContext;
+        this.lock = new Object();
+        this.listeners = new LinkedHashSet<>();
+    }
+
+    public final void addListener(ConstraintListener<T> listener) {
+        String str;
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        synchronized (this.lock) {
+            try {
+                if (this.listeners.add(listener)) {
+                    if (this.listeners.size() == 1) {
+                        this.currentState = readSystemState();
+                        Logger logger = Logger.get();
+                        str = ConstraintTrackerKt.TAG;
+                        logger.debug(str, getClass().getSimpleName() + ": initial state = " + this.currentState);
+                        startTracking();
+                    }
+                    listener.onConstraintChanged(this.currentState);
+                }
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final void removeListener(ConstraintListener<T> listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        synchronized (this.lock) {
+            try {
+                if (this.listeners.remove(listener) && this.listeners.isEmpty()) {
+                    stopTracking();
+                }
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final T getState() {
+        T t = this.currentState;
+        return t == null ? readSystemState() : t;
+    }
+
+    public final void setState(T t) {
+        synchronized (this.lock) {
+            T t2 = this.currentState;
+            if (t2 == null || !Intrinsics.areEqual(t2, t)) {
+                this.currentState = t;
+                final List list = CollectionsKt___CollectionsKt.toList(this.listeners);
+                this.taskExecutor.getMainThreadExecutor().execute(new Runnable() { // from class: androidx.work.impl.constraints.trackers.ConstraintTracker$$ExternalSyntheticLambda0
+                    @Override // java.lang.Runnable
+                    public final void run() {
+                        ConstraintTracker._set_state_$lambda$4$lambda$3(list, this);
+                    }
+                });
+                Unit unit = Unit.INSTANCE;
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void _set_state_$lambda$4$lambda$3(List list, ConstraintTracker constraintTracker) {
+        Iterator<T> it = list.iterator();
+        while (it.hasNext()) {
+            ((ConstraintListener) it.next()).onConstraintChanged(constraintTracker.currentState);
+        }
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/ConstraintTrackerKt.java

@@ -0,0 +1,15 @@
+package androidx.work.impl.constraints.trackers;
+
+import androidx.work.Logger;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class ConstraintTrackerKt {
+    private static final String TAG;
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("ConstraintTracker");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"ConstraintTracker\")");
+        TAG = tagWithPrefix;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/NetworkStateTracker24.java

@@ -0,0 +1,114 @@
+package androidx.work.impl.constraints.trackers;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.os.Build;
+import androidx.annotation.RequiresApi;
+import androidx.work.Logger;
+import androidx.work.impl.constraints.NetworkState;
+import androidx.work.impl.utils.NetworkApi21;
+import androidx.work.impl.utils.NetworkApi24;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import kotlin.jvm.internal.Intrinsics;
+
+@RequiresApi(24)
+/* loaded from: classes.dex */
+public final class NetworkStateTracker24 extends ConstraintTracker<NetworkState> {
+    private final ConnectivityManager connectivityManager;
+    private final NetworkStateTracker24$networkCallback$1 networkCallback;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Type inference failed for: r2v4, types: [androidx.work.impl.constraints.trackers.NetworkStateTracker24$networkCallback$1] */
+    public NetworkStateTracker24(Context context, TaskExecutor taskExecutor) {
+        super(context, taskExecutor);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+        Object systemService = getAppContext().getSystemService("connectivity");
+        Intrinsics.checkNotNull(systemService, "null cannot be cast to non-null type android.net.ConnectivityManager");
+        this.connectivityManager = (ConnectivityManager) systemService;
+        this.networkCallback = new ConnectivityManager.NetworkCallback() { // from class: androidx.work.impl.constraints.trackers.NetworkStateTracker24$networkCallback$1
+            @Override // android.net.ConnectivityManager.NetworkCallback
+            public void onCapabilitiesChanged(Network network, NetworkCapabilities capabilities) {
+                String str;
+                ConnectivityManager connectivityManager;
+                NetworkState activeNetworkState;
+                Intrinsics.checkNotNullParameter(network, "network");
+                Intrinsics.checkNotNullParameter(capabilities, "capabilities");
+                Logger logger = Logger.get();
+                str = NetworkStateTrackerKt.TAG;
+                logger.debug(str, "Network capabilities changed: " + capabilities);
+                NetworkStateTracker24 networkStateTracker24 = NetworkStateTracker24.this;
+                if (Build.VERSION.SDK_INT < 28) {
+                    connectivityManager = networkStateTracker24.connectivityManager;
+                    activeNetworkState = NetworkStateTrackerKt.getActiveNetworkState(connectivityManager);
+                } else {
+                    activeNetworkState = NetworkStateTrackerKt.getActiveNetworkState(capabilities);
+                }
+                networkStateTracker24.setState(activeNetworkState);
+            }
+
+            @Override // android.net.ConnectivityManager.NetworkCallback
+            public void onLost(Network network) {
+                String str;
+                ConnectivityManager connectivityManager;
+                Intrinsics.checkNotNullParameter(network, "network");
+                Logger logger = Logger.get();
+                str = NetworkStateTrackerKt.TAG;
+                logger.debug(str, "Network connection lost");
+                NetworkStateTracker24 networkStateTracker24 = NetworkStateTracker24.this;
+                connectivityManager = networkStateTracker24.connectivityManager;
+                networkStateTracker24.setState(NetworkStateTrackerKt.getActiveNetworkState(connectivityManager));
+            }
+        };
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // androidx.work.impl.constraints.trackers.ConstraintTracker
+    public NetworkState readSystemState() {
+        return NetworkStateTrackerKt.getActiveNetworkState(this.connectivityManager);
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.ConstraintTracker
+    public void startTracking() {
+        String str;
+        String str2;
+        String str3;
+        try {
+            Logger logger = Logger.get();
+            str3 = NetworkStateTrackerKt.TAG;
+            logger.debug(str3, "Registering network callback");
+            NetworkApi24.registerDefaultNetworkCallbackCompat(this.connectivityManager, this.networkCallback);
+        } catch (IllegalArgumentException e) {
+            Logger logger2 = Logger.get();
+            str2 = NetworkStateTrackerKt.TAG;
+            logger2.error(str2, "Received exception while registering network callback", e);
+        } catch (SecurityException e2) {
+            Logger logger3 = Logger.get();
+            str = NetworkStateTrackerKt.TAG;
+            logger3.error(str, "Received exception while registering network callback", e2);
+        }
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.ConstraintTracker
+    public void stopTracking() {
+        String str;
+        String str2;
+        String str3;
+        try {
+            Logger logger = Logger.get();
+            str3 = NetworkStateTrackerKt.TAG;
+            logger.debug(str3, "Unregistering network callback");
+            NetworkApi21.unregisterNetworkCallbackCompat(this.connectivityManager, this.networkCallback);
+        } catch (IllegalArgumentException e) {
+            Logger logger2 = Logger.get();
+            str2 = NetworkStateTrackerKt.TAG;
+            logger2.error(str2, "Received exception while unregistering network callback", e);
+        } catch (SecurityException e2) {
+            Logger logger3 = Logger.get();
+            str = NetworkStateTrackerKt.TAG;
+            logger3.error(str, "Received exception while unregistering network callback", e2);
+        }
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/NetworkStateTrackerKt.java

@@ -0,0 +1,69 @@
+package androidx.work.impl.constraints.trackers;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.net.ConnectivityManagerCompat;
+import androidx.work.Logger;
+import androidx.work.impl.constraints.NetworkState;
+import androidx.work.impl.utils.NetworkApi21;
+import androidx.work.impl.utils.NetworkApi23;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class NetworkStateTrackerKt {
+    private static final String TAG;
+
+    public static /* synthetic */ void getActiveNetworkState$annotations(ConnectivityManager connectivityManager) {
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public static final ConstraintTracker<NetworkState> NetworkStateTracker(Context context, TaskExecutor taskExecutor) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+        return new NetworkStateTracker24(context, taskExecutor);
+    }
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("NetworkStateTracker");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"NetworkStateTracker\")");
+        TAG = tagWithPrefix;
+    }
+
+    public static final boolean isActiveNetworkValidated(ConnectivityManager connectivityManager) {
+        Intrinsics.checkNotNullParameter(connectivityManager, "<this>");
+        try {
+            NetworkCapabilities networkCapabilitiesCompat = NetworkApi21.getNetworkCapabilitiesCompat(connectivityManager, NetworkApi23.getActiveNetworkCompat(connectivityManager));
+            if (networkCapabilitiesCompat != null) {
+                return NetworkApi21.hasCapabilityCompat(networkCapabilitiesCompat, 16);
+            }
+            return false;
+        } catch (SecurityException e) {
+            Logger.get().error(TAG, "Unable to validate active network", e);
+            return false;
+        }
+    }
+
+    public static final NetworkState getActiveNetworkState(ConnectivityManager connectivityManager) {
+        Intrinsics.checkNotNullParameter(connectivityManager, "<this>");
+        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
+        boolean z = false;
+        boolean z2 = activeNetworkInfo != null && activeNetworkInfo.isConnected();
+        boolean isActiveNetworkValidated = isActiveNetworkValidated(connectivityManager);
+        boolean isActiveNetworkMetered = ConnectivityManagerCompat.isActiveNetworkMetered(connectivityManager);
+        if (activeNetworkInfo != null && !activeNetworkInfo.isRoaming()) {
+            z = true;
+        }
+        return new NetworkState(z2, isActiveNetworkValidated, isActiveNetworkMetered, z);
+    }
+
+    @RequiresApi(28)
+    public static final NetworkState getActiveNetworkState(NetworkCapabilities networkCapabilities) {
+        Intrinsics.checkNotNullParameter(networkCapabilities, "<this>");
+        return new NetworkState(networkCapabilities.hasCapability(12), networkCapabilities.hasCapability(16), !networkCapabilities.hasCapability(11), networkCapabilities.hasCapability(18));
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/NetworkStateTrackerPre24.java

@@ -0,0 +1,50 @@
+package androidx.work.impl.constraints.trackers;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import androidx.work.Logger;
+import androidx.work.impl.constraints.NetworkState;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class NetworkStateTrackerPre24 extends BroadcastReceiverConstraintTracker<NetworkState> {
+    private final ConnectivityManager connectivityManager;
+
+    public static /* synthetic */ void getIntentFilter$annotations() {
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public NetworkStateTrackerPre24(Context context, TaskExecutor taskExecutor) {
+        super(context, taskExecutor);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+        Object systemService = getAppContext().getSystemService("connectivity");
+        Intrinsics.checkNotNull(systemService, "null cannot be cast to non-null type android.net.ConnectivityManager");
+        this.connectivityManager = (ConnectivityManager) systemService;
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.BroadcastReceiverConstraintTracker
+    public void onBroadcastReceive(Intent intent) {
+        String str;
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        if (Intrinsics.areEqual(intent.getAction(), "android.net.conn.CONNECTIVITY_CHANGE")) {
+            Logger logger = Logger.get();
+            str = NetworkStateTrackerKt.TAG;
+            logger.debug(str, "Network broadcast received");
+            setState(NetworkStateTrackerKt.getActiveNetworkState(this.connectivityManager));
+        }
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.BroadcastReceiverConstraintTracker
+    public IntentFilter getIntentFilter() {
+        return new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.ConstraintTracker
+    public NetworkState readSystemState() {
+        return NetworkStateTrackerKt.getActiveNetworkState(this.connectivityManager);
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/StorageNotLowTracker.java

@@ -0,0 +1,99 @@
+package androidx.work.impl.constraints.trackers;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.annotation.RestrictTo;
+import androidx.work.Logger;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import kotlin.jvm.internal.Intrinsics;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public final class StorageNotLowTracker extends BroadcastReceiverConstraintTracker<Boolean> {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public StorageNotLowTracker(Context context, TaskExecutor taskExecutor) {
+        super(context, taskExecutor);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:12:0x0033, code lost:
+    
+        if (r0.equals("android.intent.action.DEVICE_STORAGE_OK") == false) goto L18;
+     */
+    @Override // androidx.work.impl.constraints.trackers.ConstraintTracker
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Boolean readSystemState() {
+        /*
+            r5 = this;
+            android.content.Context r0 = r5.getAppContext()
+            r1 = 0
+            android.content.IntentFilter r2 = r5.getIntentFilter()
+            android.content.Intent r0 = r0.registerReceiver(r1, r2)
+            r1 = 1
+            if (r0 == 0) goto L3d
+            java.lang.String r2 = r0.getAction()
+            if (r2 != 0) goto L17
+            goto L3d
+        L17:
+            java.lang.String r0 = r0.getAction()
+            r2 = 0
+            if (r0 == 0) goto L3c
+            int r3 = r0.hashCode()
+            r4 = -1181163412(0xffffffffb998e06c, float:-2.9158907E-4)
+            if (r3 == r4) goto L36
+            r4 = -730838620(0xffffffffd47049a4, float:-4.1281105E12)
+            if (r3 == r4) goto L2d
+            goto L3c
+        L2d:
+            java.lang.String r3 = "android.intent.action.DEVICE_STORAGE_OK"
+            boolean r0 = r0.equals(r3)
+            if (r0 != 0) goto L3d
+            goto L3c
+        L36:
+            java.lang.String r1 = "android.intent.action.DEVICE_STORAGE_LOW"
+            boolean r0 = r0.equals(r1)
+        L3c:
+            r1 = r2
+        L3d:
+            java.lang.Boolean r0 = java.lang.Boolean.valueOf(r1)
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.work.impl.constraints.trackers.StorageNotLowTracker.readSystemState():java.lang.Boolean");
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.BroadcastReceiverConstraintTracker
+    public IntentFilter getIntentFilter() {
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction("android.intent.action.DEVICE_STORAGE_OK");
+        intentFilter.addAction("android.intent.action.DEVICE_STORAGE_LOW");
+        return intentFilter;
+    }
+
+    @Override // androidx.work.impl.constraints.trackers.BroadcastReceiverConstraintTracker
+    public void onBroadcastReceive(Intent intent) {
+        String str;
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        if (intent.getAction() == null) {
+            return;
+        }
+        Logger logger = Logger.get();
+        str = StorageNotLowTrackerKt.TAG;
+        logger.debug(str, "Received " + intent.getAction());
+        String action = intent.getAction();
+        if (action != null) {
+            int hashCode = action.hashCode();
+            if (hashCode == -1181163412) {
+                if (action.equals("android.intent.action.DEVICE_STORAGE_LOW")) {
+                    setState(Boolean.FALSE);
+                }
+            } else if (hashCode == -730838620 && action.equals("android.intent.action.DEVICE_STORAGE_OK")) {
+                setState(Boolean.TRUE);
+            }
+        }
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/StorageNotLowTrackerKt.java

@@ -0,0 +1,15 @@
+package androidx.work.impl.constraints.trackers;
+
+import androidx.work.Logger;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class StorageNotLowTrackerKt {
+    private static final String TAG;
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("StorageNotLowTracker");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"StorageNotLowTracker\")");
+        TAG = tagWithPrefix;
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/Trackers.java

@@ -0,0 +1,146 @@
+package androidx.work.impl.constraints.trackers;
+
+import android.content.Context;
+import androidx.annotation.RestrictTo;
+import androidx.work.impl.constraints.NetworkState;
+import androidx.work.impl.utils.taskexecutor.TaskExecutor;
+import kotlin.jvm.internal.Intrinsics;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public final class Trackers {
+    private final ConstraintTracker<Boolean> batteryChargingTracker;
+    private final BatteryNotLowTracker batteryNotLowTracker;
+    private final Context context;
+    private final ConstraintTracker<NetworkState> networkStateTracker;
+    private final ConstraintTracker<Boolean> storageNotLowTracker;
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public Trackers(Context context, TaskExecutor taskExecutor) {
+        this(context, taskExecutor, null, null, null, null, 60, null);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public Trackers(Context context, TaskExecutor taskExecutor, ConstraintTracker<Boolean> batteryChargingTracker) {
+        this(context, taskExecutor, batteryChargingTracker, null, null, null, 56, null);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+        Intrinsics.checkNotNullParameter(batteryChargingTracker, "batteryChargingTracker");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public Trackers(Context context, TaskExecutor taskExecutor, ConstraintTracker<Boolean> batteryChargingTracker, BatteryNotLowTracker batteryNotLowTracker) {
+        this(context, taskExecutor, batteryChargingTracker, batteryNotLowTracker, null, null, 48, null);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+        Intrinsics.checkNotNullParameter(batteryChargingTracker, "batteryChargingTracker");
+        Intrinsics.checkNotNullParameter(batteryNotLowTracker, "batteryNotLowTracker");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public Trackers(Context context, TaskExecutor taskExecutor, ConstraintTracker<Boolean> batteryChargingTracker, BatteryNotLowTracker batteryNotLowTracker, ConstraintTracker<NetworkState> networkStateTracker) {
+        this(context, taskExecutor, batteryChargingTracker, batteryNotLowTracker, networkStateTracker, null, 32, null);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+        Intrinsics.checkNotNullParameter(batteryChargingTracker, "batteryChargingTracker");
+        Intrinsics.checkNotNullParameter(batteryNotLowTracker, "batteryNotLowTracker");
+        Intrinsics.checkNotNullParameter(networkStateTracker, "networkStateTracker");
+    }
+
+    public final ConstraintTracker<Boolean> getBatteryChargingTracker() {
+        return this.batteryChargingTracker;
+    }
+
+    public final BatteryNotLowTracker getBatteryNotLowTracker() {
+        return this.batteryNotLowTracker;
+    }
+
+    public final Context getContext() {
+        return this.context;
+    }
+
+    public final ConstraintTracker<NetworkState> getNetworkStateTracker() {
+        return this.networkStateTracker;
+    }
+
+    public final ConstraintTracker<Boolean> getStorageNotLowTracker() {
+        return this.storageNotLowTracker;
+    }
+
+    public Trackers(Context context, TaskExecutor taskExecutor, ConstraintTracker<Boolean> batteryChargingTracker, BatteryNotLowTracker batteryNotLowTracker, ConstraintTracker<NetworkState> networkStateTracker, ConstraintTracker<Boolean> storageNotLowTracker) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(taskExecutor, "taskExecutor");
+        Intrinsics.checkNotNullParameter(batteryChargingTracker, "batteryChargingTracker");
+        Intrinsics.checkNotNullParameter(batteryNotLowTracker, "batteryNotLowTracker");
+        Intrinsics.checkNotNullParameter(networkStateTracker, "networkStateTracker");
+        Intrinsics.checkNotNullParameter(storageNotLowTracker, "storageNotLowTracker");
+        this.context = context;
+        this.batteryChargingTracker = batteryChargingTracker;
+        this.batteryNotLowTracker = batteryNotLowTracker;
+        this.networkStateTracker = networkStateTracker;
+        this.storageNotLowTracker = storageNotLowTracker;
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public /* synthetic */ Trackers(android.content.Context r8, androidx.work.impl.utils.taskexecutor.TaskExecutor r9, androidx.work.impl.constraints.trackers.ConstraintTracker r10, androidx.work.impl.constraints.trackers.BatteryNotLowTracker r11, androidx.work.impl.constraints.trackers.ConstraintTracker r12, androidx.work.impl.constraints.trackers.ConstraintTracker r13, int r14, kotlin.jvm.internal.DefaultConstructorMarker r15) {
+        /*
+            r7 = this;
+            r0 = r14 & 4
+            java.lang.String r1 = "context.applicationContext"
+            if (r0 == 0) goto L14
+            androidx.work.impl.constraints.trackers.BatteryChargingTracker r0 = new androidx.work.impl.constraints.trackers.BatteryChargingTracker
+            android.content.Context r3 = r8.getApplicationContext()
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r3, r1)
+            r0.<init>(r3, r9)
+            r3 = r0
+            goto L15
+        L14:
+            r3 = r10
+        L15:
+            r0 = r14 & 8
+            if (r0 == 0) goto L27
+            androidx.work.impl.constraints.trackers.BatteryNotLowTracker r0 = new androidx.work.impl.constraints.trackers.BatteryNotLowTracker
+            android.content.Context r4 = r8.getApplicationContext()
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r4, r1)
+            r0.<init>(r4, r9)
+            r4 = r0
+            goto L28
+        L27:
+            r4 = r11
+        L28:
+            r0 = r14 & 16
+            if (r0 == 0) goto L39
+            android.content.Context r0 = r8.getApplicationContext()
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r0, r1)
+            androidx.work.impl.constraints.trackers.ConstraintTracker r0 = androidx.work.impl.constraints.trackers.NetworkStateTrackerKt.NetworkStateTracker(r0, r9)
+            r5 = r0
+            goto L3a
+        L39:
+            r5 = r12
+        L3a:
+            r0 = r14 & 32
+            if (r0 == 0) goto L4c
+            androidx.work.impl.constraints.trackers.StorageNotLowTracker r0 = new androidx.work.impl.constraints.trackers.StorageNotLowTracker
+            android.content.Context r6 = r8.getApplicationContext()
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r6, r1)
+            r0.<init>(r6, r9)
+            r6 = r0
+            goto L4d
+        L4c:
+            r6 = r13
+        L4d:
+            r0 = r7
+            r1 = r8
+            r2 = r9
+            r0.<init>(r1, r2, r3, r4, r5, r6)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.work.impl.constraints.trackers.Trackers.<init>(android.content.Context, androidx.work.impl.utils.taskexecutor.TaskExecutor, androidx.work.impl.constraints.trackers.ConstraintTracker, androidx.work.impl.constraints.trackers.BatteryNotLowTracker, androidx.work.impl.constraints.trackers.ConstraintTracker, androidx.work.impl.constraints.trackers.ConstraintTracker, int, kotlin.jvm.internal.DefaultConstructorMarker):void");
+    }
+}

decompiled-community/sources/androidx/work/impl/constraints/trackers/package-info.java

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