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/activity/OnBackPressedDispatcher.java

@@ -0,0 +1,289 @@
+package androidx.activity;
+
+import android.os.Build;
+import android.window.OnBackInvokedCallback;
+import android.window.OnBackInvokedDispatcher;
+import androidx.activity.OnBackPressedDispatcher;
+import androidx.annotation.DoNotInline;
+import androidx.annotation.MainThread;
+import androidx.annotation.RequiresApi;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleEventObserver;
+import androidx.lifecycle.LifecycleOwner;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.ListIterator;
+import kotlin.Unit;
+import kotlin.collections.ArrayDeque;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nOnBackPressedDispatcher.kt\nKotlin\n*S Kotlin\n*F\n+ 1 OnBackPressedDispatcher.kt\nandroidx/activity/OnBackPressedDispatcher\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,317:1\n1747#2,3:318\n533#2,6:321\n*S KotlinDebug\n*F\n+ 1 OnBackPressedDispatcher.kt\nandroidx/activity/OnBackPressedDispatcher\n*L\n194#1:318,3\n209#1:321,6\n*E\n"})
+/* loaded from: classes.dex */
+public final class OnBackPressedDispatcher {
+    private boolean backInvokedCallbackRegistered;
+    private Function0 enabledChangedCallback;
+    private final Runnable fallbackOnBackPressed;
+    private OnBackInvokedDispatcher invokedDispatcher;
+    private OnBackInvokedCallback onBackInvokedCallback;
+    private final ArrayDeque onBackPressedCallbacks;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public OnBackPressedDispatcher() {
+        this(null, 1, 0 == true ? 1 : 0);
+    }
+
+    public OnBackPressedDispatcher(Runnable runnable) {
+        this.fallbackOnBackPressed = runnable;
+        this.onBackPressedCallbacks = new ArrayDeque();
+        if (Build.VERSION.SDK_INT >= 33) {
+            this.enabledChangedCallback = new Function0() { // from class: androidx.activity.OnBackPressedDispatcher.1
+                {
+                    super(0);
+                }
+
+                @Override // kotlin.jvm.functions.Function0
+                public /* bridge */ /* synthetic */ Object invoke() {
+                    m4invoke();
+                    return Unit.INSTANCE;
+                }
+
+                /* renamed from: invoke, reason: collision with other method in class */
+                public final void m4invoke() {
+                    OnBackPressedDispatcher.this.updateBackInvokedCallbackState$activity_release();
+                }
+            };
+            this.onBackInvokedCallback = Api33Impl.INSTANCE.createOnBackInvokedCallback(new Function0() { // from class: androidx.activity.OnBackPressedDispatcher.2
+                {
+                    super(0);
+                }
+
+                @Override // kotlin.jvm.functions.Function0
+                public /* bridge */ /* synthetic */ Object invoke() {
+                    m5invoke();
+                    return Unit.INSTANCE;
+                }
+
+                /* renamed from: invoke, reason: collision with other method in class */
+                public final void m5invoke() {
+                    OnBackPressedDispatcher.this.onBackPressed();
+                }
+            });
+        }
+    }
+
+    public /* synthetic */ OnBackPressedDispatcher(Runnable runnable, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this((i & 1) != 0 ? null : runnable);
+    }
+
+    @RequiresApi(33)
+    public final void setOnBackInvokedDispatcher(OnBackInvokedDispatcher invoker) {
+        Intrinsics.checkNotNullParameter(invoker, "invoker");
+        this.invokedDispatcher = invoker;
+        updateBackInvokedCallbackState$activity_release();
+    }
+
+    @RequiresApi(33)
+    public final void updateBackInvokedCallbackState$activity_release() {
+        boolean hasEnabledCallbacks = hasEnabledCallbacks();
+        OnBackInvokedDispatcher onBackInvokedDispatcher = this.invokedDispatcher;
+        OnBackInvokedCallback onBackInvokedCallback = this.onBackInvokedCallback;
+        if (onBackInvokedDispatcher == null || onBackInvokedCallback == null) {
+            return;
+        }
+        if (hasEnabledCallbacks && !this.backInvokedCallbackRegistered) {
+            Api33Impl.INSTANCE.registerOnBackInvokedCallback(onBackInvokedDispatcher, 0, onBackInvokedCallback);
+            this.backInvokedCallbackRegistered = true;
+        } else {
+            if (hasEnabledCallbacks || !this.backInvokedCallbackRegistered) {
+                return;
+            }
+            Api33Impl.INSTANCE.unregisterOnBackInvokedCallback(onBackInvokedDispatcher, onBackInvokedCallback);
+            this.backInvokedCallbackRegistered = false;
+        }
+    }
+
+    @MainThread
+    public final void addCallback(OnBackPressedCallback onBackPressedCallback) {
+        Intrinsics.checkNotNullParameter(onBackPressedCallback, "onBackPressedCallback");
+        addCancellableCallback$activity_release(onBackPressedCallback);
+    }
+
+    @MainThread
+    public final Cancellable addCancellableCallback$activity_release(OnBackPressedCallback onBackPressedCallback) {
+        Intrinsics.checkNotNullParameter(onBackPressedCallback, "onBackPressedCallback");
+        this.onBackPressedCallbacks.add(onBackPressedCallback);
+        OnBackPressedCancellable onBackPressedCancellable = new OnBackPressedCancellable(this, onBackPressedCallback);
+        onBackPressedCallback.addCancellable(onBackPressedCancellable);
+        if (Build.VERSION.SDK_INT >= 33) {
+            updateBackInvokedCallbackState$activity_release();
+            onBackPressedCallback.setEnabledChangedCallback$activity_release(this.enabledChangedCallback);
+        }
+        return onBackPressedCancellable;
+    }
+
+    @MainThread
+    public final void addCallback(LifecycleOwner owner, OnBackPressedCallback onBackPressedCallback) {
+        Intrinsics.checkNotNullParameter(owner, "owner");
+        Intrinsics.checkNotNullParameter(onBackPressedCallback, "onBackPressedCallback");
+        Lifecycle lifecycle = owner.getLifecycle();
+        if (lifecycle.getCurrentState() == Lifecycle.State.DESTROYED) {
+            return;
+        }
+        onBackPressedCallback.addCancellable(new LifecycleOnBackPressedCancellable(this, lifecycle, onBackPressedCallback));
+        if (Build.VERSION.SDK_INT >= 33) {
+            updateBackInvokedCallbackState$activity_release();
+            onBackPressedCallback.setEnabledChangedCallback$activity_release(this.enabledChangedCallback);
+        }
+    }
+
+    public final class OnBackPressedCancellable implements Cancellable {
+        private final OnBackPressedCallback onBackPressedCallback;
+        final /* synthetic */ OnBackPressedDispatcher this$0;
+
+        public OnBackPressedCancellable(OnBackPressedDispatcher onBackPressedDispatcher, OnBackPressedCallback onBackPressedCallback) {
+            Intrinsics.checkNotNullParameter(onBackPressedCallback, "onBackPressedCallback");
+            this.this$0 = onBackPressedDispatcher;
+            this.onBackPressedCallback = onBackPressedCallback;
+        }
+
+        @Override // androidx.activity.Cancellable
+        public void cancel() {
+            this.this$0.onBackPressedCallbacks.remove(this.onBackPressedCallback);
+            this.onBackPressedCallback.removeCancellable(this);
+            if (Build.VERSION.SDK_INT >= 33) {
+                this.onBackPressedCallback.setEnabledChangedCallback$activity_release(null);
+                this.this$0.updateBackInvokedCallbackState$activity_release();
+            }
+        }
+    }
+
+    public final class LifecycleOnBackPressedCancellable implements LifecycleEventObserver, Cancellable {
+        private Cancellable currentCancellable;
+        private final Lifecycle lifecycle;
+        private final OnBackPressedCallback onBackPressedCallback;
+        final /* synthetic */ OnBackPressedDispatcher this$0;
+
+        public LifecycleOnBackPressedCancellable(OnBackPressedDispatcher onBackPressedDispatcher, Lifecycle lifecycle, OnBackPressedCallback onBackPressedCallback) {
+            Intrinsics.checkNotNullParameter(lifecycle, "lifecycle");
+            Intrinsics.checkNotNullParameter(onBackPressedCallback, "onBackPressedCallback");
+            this.this$0 = onBackPressedDispatcher;
+            this.lifecycle = lifecycle;
+            this.onBackPressedCallback = onBackPressedCallback;
+            lifecycle.addObserver(this);
+        }
+
+        @Override // androidx.lifecycle.LifecycleEventObserver
+        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
+            Intrinsics.checkNotNullParameter(source, "source");
+            Intrinsics.checkNotNullParameter(event, "event");
+            if (event == Lifecycle.Event.ON_START) {
+                this.currentCancellable = this.this$0.addCancellableCallback$activity_release(this.onBackPressedCallback);
+                return;
+            }
+            if (event != Lifecycle.Event.ON_STOP) {
+                if (event == Lifecycle.Event.ON_DESTROY) {
+                    cancel();
+                }
+            } else {
+                Cancellable cancellable = this.currentCancellable;
+                if (cancellable != null) {
+                    cancellable.cancel();
+                }
+            }
+        }
+
+        @Override // androidx.activity.Cancellable
+        public void cancel() {
+            this.lifecycle.removeObserver(this);
+            this.onBackPressedCallback.removeCancellable(this);
+            Cancellable cancellable = this.currentCancellable;
+            if (cancellable != null) {
+                cancellable.cancel();
+            }
+            this.currentCancellable = null;
+        }
+    }
+
+    @RequiresApi(33)
+    public static final class Api33Impl {
+        public static final Api33Impl INSTANCE = new Api33Impl();
+
+        private Api33Impl() {
+        }
+
+        @DoNotInline
+        public final void registerOnBackInvokedCallback(Object dispatcher, int i, Object callback) {
+            Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+            Intrinsics.checkNotNullParameter(callback, "callback");
+            ((OnBackInvokedDispatcher) dispatcher).registerOnBackInvokedCallback(i, (OnBackInvokedCallback) callback);
+        }
+
+        @DoNotInline
+        public final void unregisterOnBackInvokedCallback(Object dispatcher, Object callback) {
+            Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+            Intrinsics.checkNotNullParameter(callback, "callback");
+            ((OnBackInvokedDispatcher) dispatcher).unregisterOnBackInvokedCallback((OnBackInvokedCallback) callback);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static final void createOnBackInvokedCallback$lambda$0(Function0 onBackInvoked) {
+            Intrinsics.checkNotNullParameter(onBackInvoked, "$onBackInvoked");
+            onBackInvoked.invoke();
+        }
+
+        @DoNotInline
+        public final OnBackInvokedCallback createOnBackInvokedCallback(final Function0 onBackInvoked) {
+            Intrinsics.checkNotNullParameter(onBackInvoked, "onBackInvoked");
+            return new OnBackInvokedCallback() { // from class: androidx.activity.OnBackPressedDispatcher$Api33Impl$$ExternalSyntheticLambda0
+                public final void onBackInvoked() {
+                    OnBackPressedDispatcher.Api33Impl.createOnBackInvokedCallback$lambda$0(Function0.this);
+                }
+            };
+        }
+    }
+
+    @MainThread
+    public final void onBackPressed() {
+        Object obj;
+        ArrayDeque arrayDeque = this.onBackPressedCallbacks;
+        ListIterator<E> listIterator = arrayDeque.listIterator(arrayDeque.size());
+        while (true) {
+            if (!listIterator.hasPrevious()) {
+                obj = null;
+                break;
+            } else {
+                obj = listIterator.previous();
+                if (((OnBackPressedCallback) obj).isEnabled()) {
+                    break;
+                }
+            }
+        }
+        OnBackPressedCallback onBackPressedCallback = (OnBackPressedCallback) obj;
+        if (onBackPressedCallback != null) {
+            onBackPressedCallback.handleOnBackPressed();
+            return;
+        }
+        Runnable runnable = this.fallbackOnBackPressed;
+        if (runnable != null) {
+            runnable.run();
+        }
+    }
+
+    @MainThread
+    public final boolean hasEnabledCallbacks() {
+        ArrayDeque arrayDeque = this.onBackPressedCallbacks;
+        if ((arrayDeque instanceof Collection) && arrayDeque.isEmpty()) {
+            return false;
+        }
+        Iterator<E> it = arrayDeque.iterator();
+        while (it.hasNext()) {
+            if (((OnBackPressedCallback) it.next()).isEnabled()) {
+                return true;
+            }
+        }
+        return false;
+    }
+}