Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/lifecycle/Lifecycle.java

@@ -0,0 +1,226 @@
+package androidx.lifecycle;
+
+import androidx.annotation.MainThread;
+import androidx.annotation.RestrictTo;
+import java.util.concurrent.atomic.AtomicReference;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public abstract class Lifecycle {
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    private AtomicReference<Object> internalScopeRef = new AtomicReference<>();
+
+    @MainThread
+    public abstract void addObserver(LifecycleObserver lifecycleObserver);
+
+    @MainThread
+    public abstract State getCurrentState();
+
+    public final AtomicReference<Object> getInternalScopeRef() {
+        return this.internalScopeRef;
+    }
+
+    @MainThread
+    public abstract void removeObserver(LifecycleObserver lifecycleObserver);
+
+    public final void setInternalScopeRef(AtomicReference<Object> atomicReference) {
+        Intrinsics.checkNotNullParameter(atomicReference, "<set-?>");
+        this.internalScopeRef = atomicReference;
+    }
+
+    public enum Event {
+        ON_CREATE,
+        ON_START,
+        ON_RESUME,
+        ON_PAUSE,
+        ON_STOP,
+        ON_DESTROY,
+        ON_ANY;
+
+        public static final Companion Companion = new Companion(null);
+
+        public /* synthetic */ class WhenMappings {
+            public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+            static {
+                int[] iArr = new int[Event.values().length];
+                try {
+                    iArr[Event.ON_CREATE.ordinal()] = 1;
+                } catch (NoSuchFieldError unused) {
+                }
+                try {
+                    iArr[Event.ON_STOP.ordinal()] = 2;
+                } catch (NoSuchFieldError unused2) {
+                }
+                try {
+                    iArr[Event.ON_START.ordinal()] = 3;
+                } catch (NoSuchFieldError unused3) {
+                }
+                try {
+                    iArr[Event.ON_PAUSE.ordinal()] = 4;
+                } catch (NoSuchFieldError unused4) {
+                }
+                try {
+                    iArr[Event.ON_RESUME.ordinal()] = 5;
+                } catch (NoSuchFieldError unused5) {
+                }
+                try {
+                    iArr[Event.ON_DESTROY.ordinal()] = 6;
+                } catch (NoSuchFieldError unused6) {
+                }
+                try {
+                    iArr[Event.ON_ANY.ordinal()] = 7;
+                } catch (NoSuchFieldError unused7) {
+                }
+                $EnumSwitchMapping$0 = iArr;
+            }
+        }
+
+        public static final Event downFrom(State state) {
+            return Companion.downFrom(state);
+        }
+
+        public static final Event downTo(State state) {
+            return Companion.downTo(state);
+        }
+
+        public static final Event upFrom(State state) {
+            return Companion.upFrom(state);
+        }
+
+        public static final Event upTo(State state) {
+            return Companion.upTo(state);
+        }
+
+        public final State getTargetState() {
+            switch (WhenMappings.$EnumSwitchMapping$0[ordinal()]) {
+                case 1:
+                case 2:
+                    return State.CREATED;
+                case 3:
+                case 4:
+                    return State.STARTED;
+                case 5:
+                    return State.RESUMED;
+                case 6:
+                    return State.DESTROYED;
+                default:
+                    throw new IllegalArgumentException(this + " has no target state");
+            }
+        }
+
+        public static final class Companion {
+
+            public /* synthetic */ class WhenMappings {
+                public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+                static {
+                    int[] iArr = new int[State.values().length];
+                    try {
+                        iArr[State.CREATED.ordinal()] = 1;
+                    } catch (NoSuchFieldError unused) {
+                    }
+                    try {
+                        iArr[State.STARTED.ordinal()] = 2;
+                    } catch (NoSuchFieldError unused2) {
+                    }
+                    try {
+                        iArr[State.RESUMED.ordinal()] = 3;
+                    } catch (NoSuchFieldError unused3) {
+                    }
+                    try {
+                        iArr[State.DESTROYED.ordinal()] = 4;
+                    } catch (NoSuchFieldError unused4) {
+                    }
+                    try {
+                        iArr[State.INITIALIZED.ordinal()] = 5;
+                    } catch (NoSuchFieldError unused5) {
+                    }
+                    $EnumSwitchMapping$0 = iArr;
+                }
+            }
+
+            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+                this();
+            }
+
+            private Companion() {
+            }
+
+            public final Event downFrom(State state) {
+                Intrinsics.checkNotNullParameter(state, "state");
+                int i = WhenMappings.$EnumSwitchMapping$0[state.ordinal()];
+                if (i == 1) {
+                    return Event.ON_DESTROY;
+                }
+                if (i == 2) {
+                    return Event.ON_STOP;
+                }
+                if (i != 3) {
+                    return null;
+                }
+                return Event.ON_PAUSE;
+            }
+
+            public final Event downTo(State state) {
+                Intrinsics.checkNotNullParameter(state, "state");
+                int i = WhenMappings.$EnumSwitchMapping$0[state.ordinal()];
+                if (i == 1) {
+                    return Event.ON_STOP;
+                }
+                if (i == 2) {
+                    return Event.ON_PAUSE;
+                }
+                if (i != 4) {
+                    return null;
+                }
+                return Event.ON_DESTROY;
+            }
+
+            public final Event upFrom(State state) {
+                Intrinsics.checkNotNullParameter(state, "state");
+                int i = WhenMappings.$EnumSwitchMapping$0[state.ordinal()];
+                if (i == 1) {
+                    return Event.ON_START;
+                }
+                if (i == 2) {
+                    return Event.ON_RESUME;
+                }
+                if (i != 5) {
+                    return null;
+                }
+                return Event.ON_CREATE;
+            }
+
+            public final Event upTo(State state) {
+                Intrinsics.checkNotNullParameter(state, "state");
+                int i = WhenMappings.$EnumSwitchMapping$0[state.ordinal()];
+                if (i == 1) {
+                    return Event.ON_CREATE;
+                }
+                if (i == 2) {
+                    return Event.ON_START;
+                }
+                if (i != 3) {
+                    return null;
+                }
+                return Event.ON_RESUME;
+            }
+        }
+    }
+
+    public enum State {
+        DESTROYED,
+        INITIALIZED,
+        CREATED,
+        STARTED,
+        RESUMED;
+
+        public final boolean isAtLeast(State state) {
+            Intrinsics.checkNotNullParameter(state, "state");
+            return compareTo(state) >= 0;
+        }
+    }
+}