Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/b/B.java

@@ -0,0 +1,166 @@
+package b;
+
+import android.os.Build;
+import android.window.OnBackInvokedCallback;
+import android.window.OnBackInvokedDispatcher;
+import androidx.lifecycle.J;
+import java.util.Iterator;
+import java.util.ListIterator;
+import kotlin.collections.ArrayDeque;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class B {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Runnable f4096a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final ArrayDeque f4097b = new ArrayDeque();
+
+    /* renamed from: c, reason: collision with root package name */
+    public r f4098c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final OnBackInvokedCallback f4099d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public OnBackInvokedDispatcher f4100e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public boolean f4101f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public boolean f4102g;
+
+    public B(Runnable runnable) {
+        this.f4096a = runnable;
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 33) {
+            this.f4099d = i >= 34 ? x.f4145a.a(new s(this, 0), new s(this, 1), new t(this, 0), new t(this, 1)) : v.f4140a.a(new t(this, 2));
+        }
+    }
+
+    public final void a(J owner, r onBackPressedCallback) {
+        Intrinsics.checkNotNullParameter(owner, "owner");
+        Intrinsics.checkNotNullParameter(onBackPressedCallback, "onBackPressedCallback");
+        androidx.lifecycle.C lifecycle = owner.getLifecycle();
+        if (lifecycle.b() == androidx.lifecycle.B.f3280a) {
+            return;
+        }
+        onBackPressedCallback.addCancellable(new y(this, lifecycle, onBackPressedCallback));
+        f();
+        onBackPressedCallback.setEnabledChangedCallback$activity_release(new C0251A(0, this, B.class, "updateEnabledCallbacks", "updateEnabledCallbacks()V", 0, 0));
+    }
+
+    public final z b(r onBackPressedCallback) {
+        Intrinsics.checkNotNullParameter(onBackPressedCallback, "onBackPressedCallback");
+        this.f4097b.add(onBackPressedCallback);
+        z zVar = new z(this, onBackPressedCallback);
+        onBackPressedCallback.addCancellable(zVar);
+        f();
+        onBackPressedCallback.setEnabledChangedCallback$activity_release(new C0251A(0, this, B.class, "updateEnabledCallbacks", "updateEnabledCallbacks()V", 0, 1));
+        return zVar;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r2v2 */
+    /* JADX WARN: Type inference failed for: r2v3 */
+    /* JADX WARN: Type inference failed for: r2v4, types: [java.lang.Object] */
+    public final void c() {
+        r rVar;
+        r rVar2 = this.f4098c;
+        if (rVar2 == null) {
+            ArrayDeque arrayDeque = this.f4097b;
+            ListIterator listIterator = arrayDeque.listIterator(arrayDeque.size());
+            while (true) {
+                if (!listIterator.hasPrevious()) {
+                    rVar = 0;
+                    break;
+                } else {
+                    rVar = listIterator.previous();
+                    if (((r) rVar).isEnabled()) {
+                        break;
+                    }
+                }
+            }
+            rVar2 = rVar;
+        }
+        this.f4098c = null;
+        if (rVar2 != null) {
+            rVar2.handleOnBackCancelled();
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r2v2 */
+    /* JADX WARN: Type inference failed for: r2v3 */
+    /* JADX WARN: Type inference failed for: r2v4, types: [java.lang.Object] */
+    public final void d() {
+        r rVar;
+        r rVar2 = this.f4098c;
+        if (rVar2 == null) {
+            ArrayDeque arrayDeque = this.f4097b;
+            ListIterator listIterator = arrayDeque.listIterator(arrayDeque.size());
+            while (true) {
+                if (!listIterator.hasPrevious()) {
+                    rVar = 0;
+                    break;
+                } else {
+                    rVar = listIterator.previous();
+                    if (((r) rVar).isEnabled()) {
+                        break;
+                    }
+                }
+            }
+            rVar2 = rVar;
+        }
+        this.f4098c = null;
+        if (rVar2 != null) {
+            rVar2.handleOnBackPressed();
+        } else {
+            this.f4096a.run();
+        }
+    }
+
+    public final void e(boolean z3) {
+        OnBackInvokedDispatcher onBackInvokedDispatcher = this.f4100e;
+        OnBackInvokedCallback onBackInvokedCallback = this.f4099d;
+        if (onBackInvokedDispatcher == null || onBackInvokedCallback == null) {
+            return;
+        }
+        v vVar = v.f4140a;
+        if (z3 && !this.f4101f) {
+            vVar.b(onBackInvokedDispatcher, 0, onBackInvokedCallback);
+            this.f4101f = true;
+        } else {
+            if (z3 || !this.f4101f) {
+                return;
+            }
+            vVar.c(onBackInvokedDispatcher, onBackInvokedCallback);
+            this.f4101f = false;
+        }
+    }
+
+    public final void f() {
+        boolean z3 = this.f4102g;
+        boolean z4 = false;
+        ArrayDeque arrayDeque = this.f4097b;
+        if (arrayDeque == null || !arrayDeque.isEmpty()) {
+            Iterator<E> it = arrayDeque.iterator();
+            while (true) {
+                if (!it.hasNext()) {
+                    break;
+                } else if (((r) it.next()).isEnabled()) {
+                    z4 = true;
+                    break;
+                }
+            }
+        }
+        this.f4102g = z4;
+        if (z4 == z3 || Build.VERSION.SDK_INT < 33) {
+            return;
+        }
+        e(z4);
+    }
+}

apk_decompiled/sources/b/C.java

@@ -0,0 +1,37 @@
+package b;
+
+import o0.AbstractC0544v;
+
+/* loaded from: classes.dex */
+public final class C extends r {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f4103a = 0;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Object f4104b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C(AbstractC0544v abstractC0544v) {
+        super(false);
+        this.f4104b = abstractC0544v;
+    }
+
+    @Override // b.r
+    public final void handleOnBackPressed() {
+        switch (this.f4103a) {
+            case 0:
+                ((com.adif.elcanomovil.uiTrain.main.e) this.f4104b).invoke(this);
+                return;
+            default:
+                ((AbstractC0544v) this.f4104b).q();
+                return;
+        }
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C(com.adif.elcanomovil.uiTrain.main.e eVar) {
+        super(true);
+        this.f4104b = eVar;
+    }
+}

apk_decompiled/sources/b/C0251A.java

@@ -0,0 +1,31 @@
+package b;
+
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+
+/* renamed from: b.A, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final /* synthetic */ class C0251A extends FunctionReferenceImpl implements Function0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f4095a;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public /* synthetic */ C0251A(int i, Object obj, Class cls, String str, String str2, int i4, int i5) {
+        super(i, obj, cls, str, str2, i4);
+        this.f4095a = i5;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public final Object invoke() {
+        switch (this.f4095a) {
+            case 0:
+                ((B) this.receiver).f();
+                return Unit.INSTANCE;
+            default:
+                ((B) this.receiver).f();
+                return Unit.INSTANCE;
+        }
+    }
+}

apk_decompiled/sources/b/C0252a.java

@@ -0,0 +1,36 @@
+package b;
+
+import android.window.BackEvent;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: b.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0252a {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final C0252a f4105a = new Object();
+
+    public final BackEvent a(float f2, float f4, float f5, int i) {
+        return new BackEvent(f2, f4, f5, i);
+    }
+
+    public final float b(BackEvent backEvent) {
+        Intrinsics.checkNotNullParameter(backEvent, "backEvent");
+        return backEvent.getProgress();
+    }
+
+    public final int c(BackEvent backEvent) {
+        Intrinsics.checkNotNullParameter(backEvent, "backEvent");
+        return backEvent.getSwipeEdge();
+    }
+
+    public final float d(BackEvent backEvent) {
+        Intrinsics.checkNotNullParameter(backEvent, "backEvent");
+        return backEvent.getTouchX();
+    }
+
+    public final float e(BackEvent backEvent) {
+        Intrinsics.checkNotNullParameter(backEvent, "backEvent");
+        return backEvent.getTouchY();
+    }
+}

apk_decompiled/sources/b/C0253b.java

@@ -0,0 +1,45 @@
+package b;
+
+import android.window.BackEvent;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: b.b, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0253b {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final float f4106a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final float f4107b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final float f4108c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final int f4109d;
+
+    public C0253b(BackEvent backEvent) {
+        Intrinsics.checkNotNullParameter(backEvent, "backEvent");
+        C0252a c0252a = C0252a.f4105a;
+        float d4 = c0252a.d(backEvent);
+        float e4 = c0252a.e(backEvent);
+        float b4 = c0252a.b(backEvent);
+        int c4 = c0252a.c(backEvent);
+        this.f4106a = d4;
+        this.f4107b = e4;
+        this.f4108c = b4;
+        this.f4109d = c4;
+    }
+
+    public final String toString() {
+        StringBuilder sb = new StringBuilder("BackEventCompat{touchX=");
+        sb.append(this.f4106a);
+        sb.append(", touchY=");
+        sb.append(this.f4107b);
+        sb.append(", progress=");
+        sb.append(this.f4108c);
+        sb.append(", swipeEdge=");
+        return C.w.p(sb, this.f4109d, '}');
+    }
+}

apk_decompiled/sources/b/D.java

@@ -0,0 +1,8 @@
+package b;
+
+import androidx.lifecycle.J;
+
+/* loaded from: classes.dex */
+public interface D extends J {
+    B getOnBackPressedDispatcher();
+}

apk_decompiled/sources/b/InterfaceC0254c.java

@@ -0,0 +1,7 @@
+package b;
+
+/* renamed from: b.c, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public interface InterfaceC0254c {
+    void cancel();
+}

apk_decompiled/sources/b/RunnableC0255d.java

@@ -0,0 +1,47 @@
+package b;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: b.d, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final /* synthetic */ class RunnableC0255d implements Runnable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f4110a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ o f4111b;
+
+    public /* synthetic */ RunnableC0255d(o oVar, int i) {
+        this.f4110a = i;
+        this.f4111b = oVar;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        switch (this.f4110a) {
+            case 0:
+                o this$0 = this.f4111b;
+                Intrinsics.checkNotNullParameter(this$0, "this$0");
+                this$0.invalidateMenu();
+                return;
+            default:
+                o this$02 = this.f4111b;
+                Intrinsics.checkNotNullParameter(this$02, "this$0");
+                try {
+                    o.access$onBackPressed$s1027565324(this$02);
+                    return;
+                } catch (IllegalStateException e4) {
+                    if (!Intrinsics.areEqual(e4.getMessage(), "Can not perform this action after onSaveInstanceState")) {
+                        throw e4;
+                    }
+                    return;
+                } catch (NullPointerException e5) {
+                    if (!Intrinsics.areEqual(e5.getMessage(), "Attempt to invoke virtual method 'android.os.Handler android.app.FragmentHostCallback.getHandler()' on a null object reference")) {
+                        throw e5;
+                    }
+                    return;
+                }
+        }
+    }
+}

apk_decompiled/sources/b/g.java

@@ -0,0 +1,19 @@
+package b;
+
+import android.app.Activity;
+import android.window.OnBackInvokedDispatcher;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class g {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final g f4115a = new Object();
+
+    public final OnBackInvokedDispatcher a(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        OnBackInvokedDispatcher onBackInvokedDispatcher = activity.getOnBackInvokedDispatcher();
+        Intrinsics.checkNotNullExpressionValue(onBackInvokedDispatcher, "activity.getOnBackInvokedDispatcher()");
+        return onBackInvokedDispatcher;
+    }
+}

apk_decompiled/sources/b/h.java

@@ -0,0 +1,5 @@
+package b;
+
+/* loaded from: classes.dex */
+public final class h {
+}

apk_decompiled/sources/b/i.java

@@ -0,0 +1,13 @@
+package b;
+
+import androidx.lifecycle.C0;
+
+/* loaded from: classes.dex */
+public final class i {
+
+    /* renamed from: a, reason: collision with root package name */
+    public Object f4116a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public C0 f4117b;
+}

apk_decompiled/sources/b/j.java

@@ -0,0 +1,7 @@
+package b;
+
+import java.util.concurrent.Executor;
+
+/* loaded from: classes.dex */
+public interface j extends Executor {
+}

apk_decompiled/sources/b/k.java

@@ -0,0 +1,71 @@
+package b;
+
+import android.os.Looper;
+import android.os.SystemClock;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class k implements j, ViewTreeObserver.OnDrawListener, Runnable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final long f4118a = SystemClock.uptimeMillis() + 10000;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Runnable f4119b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f4120c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ o f4121d;
+
+    public k(o oVar) {
+        this.f4121d = oVar;
+    }
+
+    @Override // java.util.concurrent.Executor
+    public final void execute(Runnable runnable) {
+        Intrinsics.checkNotNullParameter(runnable, "runnable");
+        this.f4119b = runnable;
+        View decorView = this.f4121d.getWindow().getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView, "window.decorView");
+        if (!this.f4120c) {
+            decorView.postOnAnimation(new F2.f(this, 5));
+        } else if (Intrinsics.areEqual(Looper.myLooper(), Looper.getMainLooper())) {
+            decorView.invalidate();
+        } else {
+            decorView.postInvalidate();
+        }
+    }
+
+    @Override // android.view.ViewTreeObserver.OnDrawListener
+    public final void onDraw() {
+        boolean z3;
+        Runnable runnable = this.f4119b;
+        if (runnable == null) {
+            if (SystemClock.uptimeMillis() > this.f4118a) {
+                this.f4120c = false;
+                this.f4121d.getWindow().getDecorView().post(this);
+                return;
+            }
+            return;
+        }
+        runnable.run();
+        this.f4119b = null;
+        q fullyDrawnReporter = this.f4121d.getFullyDrawnReporter();
+        synchronized (fullyDrawnReporter.f4131a) {
+            z3 = fullyDrawnReporter.f4132b;
+        }
+        if (z3) {
+            this.f4120c = false;
+            this.f4121d.getWindow().getDecorView().post(this);
+        }
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        this.f4121d.getWindow().getDecorView().getViewTreeObserver().removeOnDrawListener(this);
+    }
+}

apk_decompiled/sources/b/l.java

@@ -0,0 +1,71 @@
+package b;
+
+import android.content.Intent;
+import android.content.IntentSender;
+import d.C0296e;
+import d.InterfaceC0293b;
+import java.io.Serializable;
+import kotlin.jvm.internal.Intrinsics;
+import s0.C0582a;
+
+/* loaded from: classes.dex */
+public final /* synthetic */ class l implements Runnable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f4122a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Object f4123b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ int f4124c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ Object f4125d;
+
+    public /* synthetic */ l(Object obj, int i, int i4, Object obj2) {
+        this.f4122a = i4;
+        this.f4123b = obj;
+        this.f4124c = i;
+        this.f4125d = obj2;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        switch (this.f4122a) {
+            case 0:
+                m this$0 = (m) this.f4123b;
+                Intrinsics.checkNotNullParameter(this$0, "this$0");
+                A.a aVar = (A.a) this.f4125d;
+                String str = (String) this$0.f6104a.get(Integer.valueOf(this.f4124c));
+                if (str == null) {
+                    return;
+                }
+                C0296e c0296e = (C0296e) this$0.f6108e.get(str);
+                InterfaceC0293b interfaceC0293b = c0296e != null ? c0296e.f6095a : null;
+                Object obj = aVar.f7b;
+                if (interfaceC0293b == null) {
+                    this$0.f6110g.remove(str);
+                    this$0.f6109f.put(str, obj);
+                    return;
+                }
+                InterfaceC0293b interfaceC0293b2 = c0296e.f6095a;
+                Intrinsics.checkNotNull(interfaceC0293b2, "null cannot be cast to non-null type androidx.activity.result.ActivityResultCallback<O of androidx.activity.result.ActivityResultRegistry.dispatchResult>");
+                if (this$0.f6107d.remove(str)) {
+                    interfaceC0293b2.a(obj);
+                    return;
+                }
+                return;
+            case 1:
+                m this$02 = (m) this.f4123b;
+                Intrinsics.checkNotNullParameter(this$02, "this$0");
+                IntentSender.SendIntentException e4 = (IntentSender.SendIntentException) this.f4125d;
+                Intrinsics.checkNotNullParameter(e4, "$e");
+                this$02.a(this.f4124c, 0, new Intent().setAction("androidx.activity.result.contract.action.INTENT_SENDER_REQUEST").putExtra("androidx.activity.result.contract.extra.SEND_INTENT_EXCEPTION", e4));
+                return;
+            default:
+                ((C0582a) this.f4123b).f8360b.a(this.f4124c, (Serializable) this.f4125d);
+                return;
+        }
+    }
+}

apk_decompiled/sources/b/m.java

@@ -0,0 +1,107 @@
+package b;
+
+import C.AbstractC0038b;
+import C.InterfaceC0042f;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.text.TextUtils;
+import d.AbstractC0300i;
+import d.C0302k;
+import e.AbstractC0311a;
+import java.util.Arrays;
+import java.util.HashSet;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class m extends AbstractC0300i {
+    public final /* synthetic */ o h;
+
+    public m(o oVar) {
+        this.h = oVar;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // d.AbstractC0300i
+    public final void b(int i, AbstractC0311a contract, Object obj) {
+        Bundle bundle;
+        int i4;
+        Intrinsics.checkNotNullParameter(contract, "contract");
+        o oVar = this.h;
+        A.a b4 = contract.b(oVar, obj);
+        if (b4 != null) {
+            new Handler(Looper.getMainLooper()).post(new l(this, i, 0, b4));
+            return;
+        }
+        Intent a2 = contract.a(oVar, obj);
+        if (a2.getExtras() != null) {
+            Bundle extras = a2.getExtras();
+            Intrinsics.checkNotNull(extras);
+            if (extras.getClassLoader() == null) {
+                a2.setExtrasClassLoader(oVar.getClassLoader());
+            }
+        }
+        if (a2.hasExtra("androidx.activity.result.contract.extra.ACTIVITY_OPTIONS_BUNDLE")) {
+            bundle = a2.getBundleExtra("androidx.activity.result.contract.extra.ACTIVITY_OPTIONS_BUNDLE");
+            a2.removeExtra("androidx.activity.result.contract.extra.ACTIVITY_OPTIONS_BUNDLE");
+        } else {
+            bundle = null;
+        }
+        Bundle bundle2 = bundle;
+        if (Intrinsics.areEqual("androidx.activity.result.contract.action.REQUEST_PERMISSIONS", a2.getAction())) {
+            String[] stringArrayExtra = a2.getStringArrayExtra("androidx.activity.result.contract.extra.PERMISSIONS");
+            if (stringArrayExtra == null) {
+                stringArrayExtra = new String[0];
+            }
+            HashSet hashSet = new HashSet();
+            for (int i5 = 0; i5 < stringArrayExtra.length; i5++) {
+                if (TextUtils.isEmpty(stringArrayExtra[i5])) {
+                    throw new IllegalArgumentException(C.w.r(new StringBuilder("Permission request for permissions "), Arrays.toString(stringArrayExtra), " must not contain null or empty values"));
+                }
+                if (Build.VERSION.SDK_INT < 33 && TextUtils.equals(stringArrayExtra[i5], "android.permission.POST_NOTIFICATIONS")) {
+                    hashSet.add(Integer.valueOf(i5));
+                }
+            }
+            int size = hashSet.size();
+            String[] strArr = size > 0 ? new String[stringArrayExtra.length - size] : stringArrayExtra;
+            if (size > 0) {
+                if (size == stringArrayExtra.length) {
+                    return;
+                }
+                int i6 = 0;
+                for (int i7 = 0; i7 < stringArrayExtra.length; i7++) {
+                    if (!hashSet.contains(Integer.valueOf(i7))) {
+                        strArr[i6] = stringArrayExtra[i7];
+                        i6++;
+                    }
+                }
+            }
+            if (oVar instanceof InterfaceC0042f) {
+                ((InterfaceC0042f) oVar).validateRequestPermissionsRequestCode(i);
+            }
+            AbstractC0038b.b(oVar, stringArrayExtra, i);
+            return;
+        }
+        if (!Intrinsics.areEqual("androidx.activity.result.contract.action.INTENT_SENDER_REQUEST", a2.getAction())) {
+            oVar.startActivityForResult(a2, i, bundle2);
+            return;
+        }
+        C0302k c0302k = (C0302k) a2.getParcelableExtra("androidx.activity.result.contract.extra.INTENT_SENDER_REQUEST");
+        try {
+            Intrinsics.checkNotNull(c0302k);
+            i4 = i;
+            try {
+                oVar.startIntentSenderForResult(c0302k.f6111a, i4, c0302k.f6112b, c0302k.f6113c, c0302k.f6114d, 0, bundle2);
+            } catch (IntentSender.SendIntentException e4) {
+                e = e4;
+                new Handler(Looper.getMainLooper()).post(new l(this, i4, 1, e));
+            }
+        } catch (IntentSender.SendIntentException e5) {
+            e = e5;
+            i4 = i;
+        }
+    }
+}

apk_decompiled/sources/b/n.java

@@ -0,0 +1,56 @@
+package b;
+
+import O.C0072m;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import androidx.lifecycle.t0;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class n extends Lambda implements Function0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f4126a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ o f4127b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public /* synthetic */ n(o oVar, int i) {
+        super(0);
+        this.f4126a = i;
+        this.f4127b = oVar;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public final Object invoke() {
+        j jVar;
+        switch (this.f4126a) {
+            case 0:
+                o oVar = this.f4127b;
+                return new t0(oVar.getApplication(), oVar, oVar.getIntent() != null ? oVar.getIntent().getExtras() : null);
+            case 1:
+                this.f4127b.reportFullyDrawn();
+                return Unit.INSTANCE;
+            case 2:
+                o oVar2 = this.f4127b;
+                jVar = oVar2.reportFullyDrawnExecutor;
+                return new q(jVar, new n(oVar2, 1));
+            default:
+                o oVar3 = this.f4127b;
+                B b4 = new B(new RunnableC0255d(oVar3, 1));
+                if (Build.VERSION.SDK_INT >= 33) {
+                    if (Intrinsics.areEqual(Looper.myLooper(), Looper.getMainLooper())) {
+                        oVar3.getLifecycle().a(new C0072m(1, b4, oVar3));
+                    } else {
+                        new Handler(Looper.getMainLooper()).post(new F.n(2, oVar3, b4));
+                    }
+                }
+                return b4;
+        }
+    }
+}

apk_decompiled/sources/b/o.java

@@ -0,0 +1,841 @@
+package b;
+
+import C.AbstractActivityC0048l;
+import C.H;
+import C.I;
+import O.C0072m;
+import O.C0073n;
+import O.C0074o;
+import O.InterfaceC0070k;
+import O.InterfaceC0076q;
+import a.AbstractC0105a;
+import a.AbstractC0106b;
+import android.annotation.SuppressLint;
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.os.Trace;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.Window;
+import androidx.fragment.app.C0140c0;
+import androidx.lifecycle.C0;
+import androidx.lifecycle.C0203y;
+import androidx.lifecycle.D0;
+import androidx.lifecycle.InterfaceC0200v;
+import androidx.lifecycle.J;
+import androidx.lifecycle.L;
+import androidx.lifecycle.i0;
+import androidx.lifecycle.k0;
+import androidx.lifecycle.l0;
+import androidx.lifecycle.q0;
+import androidx.lifecycle.x0;
+import androidx.lifecycle.y0;
+import c.C0273a;
+import c.InterfaceC0274b;
+import com.adif.elcanomovil.R;
+import d.AbstractC0294c;
+import d.AbstractC0300i;
+import d.InterfaceC0293b;
+import d.InterfaceC0301j;
+import e.AbstractC0311a;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import kotlin.Deprecated;
+import kotlin.Lazy;
+import kotlin.LazyKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.TypeIntrinsics;
+import v0.C0636a;
+import v0.C0639d;
+import v0.C0640e;
+
+/* loaded from: classes.dex */
+public abstract class o extends AbstractActivityC0048l implements D0, InterfaceC0200v, v0.f, D, InterfaceC0301j, D.l, D.m, H, I, InterfaceC0070k {
+    private static final String ACTIVITY_RESULT_TAG = "android:support:activity-result";
+    private static final h Companion = new Object();
+    private C0 _viewModelStore;
+    private final AbstractC0300i activityResultRegistry;
+    private int contentLayoutId;
+    private final C0273a contextAwareHelper;
+    private final Lazy defaultViewModelProviderFactory$delegate;
+    private boolean dispatchingOnMultiWindowModeChanged;
+    private boolean dispatchingOnPictureInPictureModeChanged;
+    private final Lazy fullyDrawnReporter$delegate;
+    private final C0074o menuHostHelper;
+    private final AtomicInteger nextLocalRequestCode;
+    private final Lazy onBackPressedDispatcher$delegate;
+    private final CopyOnWriteArrayList<N.a> onConfigurationChangedListeners;
+    private final CopyOnWriteArrayList<N.a> onMultiWindowModeChangedListeners;
+    private final CopyOnWriteArrayList<N.a> onNewIntentListeners;
+    private final CopyOnWriteArrayList<N.a> onPictureInPictureModeChangedListeners;
+    private final CopyOnWriteArrayList<N.a> onTrimMemoryListeners;
+    private final CopyOnWriteArrayList<Runnable> onUserLeaveHintListeners;
+    private final j reportFullyDrawnExecutor;
+    private final C0640e savedStateRegistryController;
+
+    public o() {
+        this.contextAwareHelper = new C0273a();
+        this.menuHostHelper = new C0074o(new RunnableC0255d(this, 0));
+        Intrinsics.checkNotNullParameter(this, "owner");
+        C0640e c0640e = new C0640e(this);
+        this.savedStateRegistryController = c0640e;
+        this.reportFullyDrawnExecutor = new k(this);
+        this.fullyDrawnReporter$delegate = LazyKt.lazy(new n(this, 2));
+        this.nextLocalRequestCode = new AtomicInteger();
+        this.activityResultRegistry = new m(this);
+        this.onConfigurationChangedListeners = new CopyOnWriteArrayList<>();
+        this.onTrimMemoryListeners = new CopyOnWriteArrayList<>();
+        this.onNewIntentListeners = new CopyOnWriteArrayList<>();
+        this.onMultiWindowModeChangedListeners = new CopyOnWriteArrayList<>();
+        this.onPictureInPictureModeChangedListeners = new CopyOnWriteArrayList<>();
+        this.onUserLeaveHintListeners = new CopyOnWriteArrayList<>();
+        if (getLifecycle() != null) {
+            final int i = 0;
+            getLifecycle().a(new androidx.lifecycle.H(this) { // from class: b.e
+
+                /* renamed from: b, reason: collision with root package name */
+                public final /* synthetic */ o f4113b;
+
+                {
+                    this.f4113b = owner;
+                }
+
+                @Override // androidx.lifecycle.H
+                public final void onStateChanged(J j4, androidx.lifecycle.A event) {
+                    Window window;
+                    View peekDecorView;
+                    switch (i) {
+                        case 0:
+                            o this$0 = this.f4113b;
+                            Intrinsics.checkNotNullParameter(this$0, "this$0");
+                            Intrinsics.checkNotNullParameter(j4, "<anonymous parameter 0>");
+                            Intrinsics.checkNotNullParameter(event, "event");
+                            if (event != androidx.lifecycle.A.ON_STOP || (window = this$0.getWindow()) == null || (peekDecorView = window.peekDecorView()) == null) {
+                                return;
+                            }
+                            peekDecorView.cancelPendingInputEvents();
+                            return;
+                        default:
+                            o.b(this.f4113b, j4, event);
+                            return;
+                    }
+                }
+            });
+            final int i4 = 1;
+            getLifecycle().a(new androidx.lifecycle.H(this) { // from class: b.e
+
+                /* renamed from: b, reason: collision with root package name */
+                public final /* synthetic */ o f4113b;
+
+                {
+                    this.f4113b = owner;
+                }
+
+                @Override // androidx.lifecycle.H
+                public final void onStateChanged(J j4, androidx.lifecycle.A event) {
+                    Window window;
+                    View peekDecorView;
+                    switch (i4) {
+                        case 0:
+                            o this$0 = this.f4113b;
+                            Intrinsics.checkNotNullParameter(this$0, "this$0");
+                            Intrinsics.checkNotNullParameter(j4, "<anonymous parameter 0>");
+                            Intrinsics.checkNotNullParameter(event, "event");
+                            if (event != androidx.lifecycle.A.ON_STOP || (window = this$0.getWindow()) == null || (peekDecorView = window.peekDecorView()) == null) {
+                                return;
+                            }
+                            peekDecorView.cancelPendingInputEvents();
+                            return;
+                        default:
+                            o.b(this.f4113b, j4, event);
+                            return;
+                    }
+                }
+            });
+            getLifecycle().a(new C0636a(this));
+            c0640e.a();
+            q0.f(this);
+            getSavedStateRegistry().c(ACTIVITY_RESULT_TAG, new l0(this, 1));
+            addOnContextAvailableListener(new InterfaceC0274b() { // from class: b.f
+                @Override // c.InterfaceC0274b
+                public final void a(o oVar) {
+                    o.a(o.this, oVar);
+                }
+            });
+            this.defaultViewModelProviderFactory$delegate = LazyKt.lazy(new n(this, 0));
+            this.onBackPressedDispatcher$delegate = LazyKt.lazy(new n(this, 3));
+            return;
+        }
+        throw new IllegalStateException("getLifecycle() returned null in ComponentActivity's constructor. Please make sure you are lazily constructing your Lifecycle in the first call to getLifecycle() rather than relying on field initialization.");
+    }
+
+    public static void a(o this$0, o it) {
+        Intrinsics.checkNotNullParameter(this$0, "this$0");
+        Intrinsics.checkNotNullParameter(it, "it");
+        Bundle a2 = this$0.getSavedStateRegistry().a(ACTIVITY_RESULT_TAG);
+        if (a2 != null) {
+            AbstractC0300i abstractC0300i = this$0.activityResultRegistry;
+            abstractC0300i.getClass();
+            ArrayList<Integer> integerArrayList = a2.getIntegerArrayList("KEY_COMPONENT_ACTIVITY_REGISTERED_RCS");
+            ArrayList<String> stringArrayList = a2.getStringArrayList("KEY_COMPONENT_ACTIVITY_REGISTERED_KEYS");
+            if (stringArrayList == null || integerArrayList == null) {
+                return;
+            }
+            ArrayList<String> stringArrayList2 = a2.getStringArrayList("KEY_COMPONENT_ACTIVITY_LAUNCHED_KEYS");
+            if (stringArrayList2 != null) {
+                abstractC0300i.f6107d.addAll(stringArrayList2);
+            }
+            Bundle bundle = a2.getBundle("KEY_COMPONENT_ACTIVITY_PENDING_RESULT");
+            Bundle bundle2 = abstractC0300i.f6110g;
+            if (bundle != null) {
+                bundle2.putAll(bundle);
+            }
+            int size = stringArrayList.size();
+            for (int i = 0; i < size; i++) {
+                String str = stringArrayList.get(i);
+                LinkedHashMap linkedHashMap = abstractC0300i.f6105b;
+                boolean containsKey = linkedHashMap.containsKey(str);
+                LinkedHashMap linkedHashMap2 = abstractC0300i.f6104a;
+                if (containsKey) {
+                    Integer num = (Integer) linkedHashMap.remove(str);
+                    if (!bundle2.containsKey(str)) {
+                        TypeIntrinsics.asMutableMap(linkedHashMap2).remove(num);
+                    }
+                }
+                Integer num2 = integerArrayList.get(i);
+                Intrinsics.checkNotNullExpressionValue(num2, "rcs[i]");
+                int intValue = num2.intValue();
+                String str2 = stringArrayList.get(i);
+                Intrinsics.checkNotNullExpressionValue(str2, "keys[i]");
+                String str3 = str2;
+                linkedHashMap2.put(Integer.valueOf(intValue), str3);
+                linkedHashMap.put(str3, Integer.valueOf(intValue));
+            }
+        }
+    }
+
+    public static final void access$ensureViewModelStore(o oVar) {
+        if (oVar._viewModelStore == null) {
+            i iVar = (i) oVar.getLastNonConfigurationInstance();
+            if (iVar != null) {
+                oVar._viewModelStore = iVar.f4117b;
+            }
+            if (oVar._viewModelStore == null) {
+                oVar._viewModelStore = new C0();
+            }
+        }
+    }
+
+    public static void b(o this$0, J j4, androidx.lifecycle.A event) {
+        Intrinsics.checkNotNullParameter(this$0, "this$0");
+        Intrinsics.checkNotNullParameter(j4, "<anonymous parameter 0>");
+        Intrinsics.checkNotNullParameter(event, "event");
+        if (event == androidx.lifecycle.A.ON_DESTROY) {
+            this$0.contextAwareHelper.f4198b = null;
+            if (!this$0.isChangingConfigurations()) {
+                this$0.getViewModelStore().a();
+            }
+            k kVar = (k) this$0.reportFullyDrawnExecutor;
+            o oVar = kVar.f4121d;
+            oVar.getWindow().getDecorView().removeCallbacks(kVar);
+            oVar.getWindow().getDecorView().getViewTreeObserver().removeOnDrawListener(kVar);
+        }
+    }
+
+    public static Bundle c(o this$0) {
+        Intrinsics.checkNotNullParameter(this$0, "this$0");
+        Bundle outState = new Bundle();
+        AbstractC0300i abstractC0300i = this$0.activityResultRegistry;
+        abstractC0300i.getClass();
+        Intrinsics.checkNotNullParameter(outState, "outState");
+        LinkedHashMap linkedHashMap = abstractC0300i.f6105b;
+        outState.putIntegerArrayList("KEY_COMPONENT_ACTIVITY_REGISTERED_RCS", new ArrayList<>(linkedHashMap.values()));
+        outState.putStringArrayList("KEY_COMPONENT_ACTIVITY_REGISTERED_KEYS", new ArrayList<>(linkedHashMap.keySet()));
+        outState.putStringArrayList("KEY_COMPONENT_ACTIVITY_LAUNCHED_KEYS", new ArrayList<>(abstractC0300i.f6107d));
+        outState.putBundle("KEY_COMPONENT_ACTIVITY_PENDING_RESULT", new Bundle(abstractC0300i.f6110g));
+        return outState;
+    }
+
+    public static /* synthetic */ void getOnBackPressedDispatcher$annotations() {
+    }
+
+    @Override // O.InterfaceC0070k
+    public void addMenuProvider(InterfaceC0076q provider) {
+        Intrinsics.checkNotNullParameter(provider, "provider");
+        C0074o c0074o = this.menuHostHelper;
+        c0074o.f1276b.add(provider);
+        c0074o.f1275a.run();
+    }
+
+    @Override // D.l
+    public final void addOnConfigurationChangedListener(N.a listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onConfigurationChangedListeners.add(listener);
+    }
+
+    public final void addOnContextAvailableListener(InterfaceC0274b listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        C0273a c0273a = this.contextAwareHelper;
+        c0273a.getClass();
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        o oVar = c0273a.f4198b;
+        if (oVar != null) {
+            listener.a(oVar);
+        }
+        c0273a.f4197a.add(listener);
+    }
+
+    @Override // C.H
+    public final void addOnMultiWindowModeChangedListener(N.a listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onMultiWindowModeChangedListeners.add(listener);
+    }
+
+    public final void addOnNewIntentListener(N.a listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onNewIntentListeners.add(listener);
+    }
+
+    @Override // C.I
+    public final void addOnPictureInPictureModeChangedListener(N.a listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onPictureInPictureModeChangedListeners.add(listener);
+    }
+
+    @Override // D.m
+    public final void addOnTrimMemoryListener(N.a listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onTrimMemoryListeners.add(listener);
+    }
+
+    public final void addOnUserLeaveHintListener(Runnable listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onUserLeaveHintListeners.add(listener);
+    }
+
+    @Override // d.InterfaceC0301j
+    public final AbstractC0300i getActivityResultRegistry() {
+        return this.activityResultRegistry;
+    }
+
+    @Override // androidx.lifecycle.InterfaceC0200v
+    public l0.c getDefaultViewModelCreationExtras() {
+        l0.d dVar = new l0.d(0);
+        if (getApplication() != null) {
+            E2.e eVar = x0.f3440d;
+            Application application = getApplication();
+            Intrinsics.checkNotNullExpressionValue(application, "application");
+            dVar.b(eVar, application);
+        }
+        dVar.b(q0.f3417a, this);
+        dVar.b(q0.f3418b, this);
+        Intent intent = getIntent();
+        Bundle extras = intent != null ? intent.getExtras() : null;
+        if (extras != null) {
+            dVar.b(q0.f3419c, extras);
+        }
+        return dVar;
+    }
+
+    @Override // androidx.lifecycle.InterfaceC0200v
+    public y0 getDefaultViewModelProviderFactory() {
+        return (y0) this.defaultViewModelProviderFactory$delegate.getValue();
+    }
+
+    public q getFullyDrawnReporter() {
+        return (q) this.fullyDrawnReporter$delegate.getValue();
+    }
+
+    @Deprecated(message = "Use a {@link androidx.lifecycle.ViewModel} to store non config state.")
+    public Object getLastCustomNonConfigurationInstance() {
+        i iVar = (i) getLastNonConfigurationInstance();
+        if (iVar != null) {
+            return iVar.f4116a;
+        }
+        return null;
+    }
+
+    @Override // C.AbstractActivityC0048l, androidx.lifecycle.J
+    public androidx.lifecycle.C getLifecycle() {
+        return super.getLifecycle();
+    }
+
+    @Override // b.D
+    public final B getOnBackPressedDispatcher() {
+        return (B) this.onBackPressedDispatcher$delegate.getValue();
+    }
+
+    @Override // v0.f
+    public final C0639d getSavedStateRegistry() {
+        return this.savedStateRegistryController.f8636b;
+    }
+
+    @Override // androidx.lifecycle.D0
+    public C0 getViewModelStore() {
+        if (getApplication() == null) {
+            throw new IllegalStateException("Your activity is not yet attached to the Application instance. You can't request ViewModel before onCreate call.");
+        }
+        if (this._viewModelStore == null) {
+            i iVar = (i) getLastNonConfigurationInstance();
+            if (iVar != null) {
+                this._viewModelStore = iVar.f4117b;
+            }
+            if (this._viewModelStore == null) {
+                this._viewModelStore = new C0();
+            }
+        }
+        C0 c02 = this._viewModelStore;
+        Intrinsics.checkNotNull(c02);
+        return c02;
+    }
+
+    public void initializeViewTreeOwners() {
+        View decorView = getWindow().getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView, "window.decorView");
+        q0.m(decorView, this);
+        View decorView2 = getWindow().getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView2, "window.decorView");
+        Intrinsics.checkNotNullParameter(decorView2, "<this>");
+        decorView2.setTag(R.id.view_tree_view_model_store_owner, this);
+        View decorView3 = getWindow().getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView3, "window.decorView");
+        m3.d.D(decorView3, this);
+        View decorView4 = getWindow().getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView4, "window.decorView");
+        AbstractC0106b.H(decorView4, this);
+        View decorView5 = getWindow().getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView5, "window.decorView");
+        Intrinsics.checkNotNullParameter(decorView5, "<this>");
+        Intrinsics.checkNotNullParameter(this, "fullyDrawnReporterOwner");
+        decorView5.setTag(R.id.report_drawn, this);
+    }
+
+    public void invalidateMenu() {
+        invalidateOptionsMenu();
+    }
+
+    @Override // android.app.Activity
+    public void onActivityResult(int i, int i4, Intent intent) {
+        if (this.activityResultRegistry.a(i, i4, intent)) {
+            return;
+        }
+        super.onActivityResult(i, i4, intent);
+    }
+
+    @Override // android.app.Activity
+    @Deprecated(message = "This method has been deprecated in favor of using the\n      {@link OnBackPressedDispatcher} via {@link #getOnBackPressedDispatcher()}.\n      The OnBackPressedDispatcher controls how back button events are dispatched\n      to one or more {@link OnBackPressedCallback} objects.")
+    public void onBackPressed() {
+        getOnBackPressedDispatcher().d();
+    }
+
+    @Override // android.app.Activity, android.content.ComponentCallbacks
+    public void onConfigurationChanged(Configuration newConfig) {
+        Intrinsics.checkNotNullParameter(newConfig, "newConfig");
+        super.onConfigurationChanged(newConfig);
+        Iterator<N.a> it = this.onConfigurationChangedListeners.iterator();
+        while (it.hasNext()) {
+            it.next().a(newConfig);
+        }
+    }
+
+    @Override // C.AbstractActivityC0048l, android.app.Activity
+    public void onCreate(Bundle bundle) {
+        this.savedStateRegistryController.b(bundle);
+        C0273a c0273a = this.contextAwareHelper;
+        c0273a.getClass();
+        Intrinsics.checkNotNullParameter(this, "context");
+        c0273a.f4198b = this;
+        Iterator it = c0273a.f4197a.iterator();
+        while (it.hasNext()) {
+            ((InterfaceC0274b) it.next()).a(this);
+        }
+        super.onCreate(bundle);
+        int i = k0.f3396a;
+        i0.b(this);
+        int i4 = this.contentLayoutId;
+        if (i4 != 0) {
+            setContentView(i4);
+        }
+    }
+
+    @Override // android.app.Activity, android.view.Window.Callback
+    public boolean onCreatePanelMenu(int i, Menu menu) {
+        Intrinsics.checkNotNullParameter(menu, "menu");
+        if (i != 0) {
+            return true;
+        }
+        super.onCreatePanelMenu(i, menu);
+        C0074o c0074o = this.menuHostHelper;
+        MenuInflater menuInflater = getMenuInflater();
+        Iterator it = c0074o.f1276b.iterator();
+        while (it.hasNext()) {
+            ((C0140c0) ((InterfaceC0076q) it.next())).f3105a.k(menu, menuInflater);
+        }
+        return true;
+    }
+
+    @Override // android.app.Activity, android.view.Window.Callback
+    public boolean onMenuItemSelected(int i, MenuItem item) {
+        Intrinsics.checkNotNullParameter(item, "item");
+        if (super.onMenuItemSelected(i, item)) {
+            return true;
+        }
+        if (i == 0) {
+            return this.menuHostHelper.a(item);
+        }
+        return false;
+    }
+
+    @Override // android.app.Activity
+    @Deprecated(message = "Deprecated in android.app.Activity")
+    public void onMultiWindowModeChanged(boolean z3) {
+        if (this.dispatchingOnMultiWindowModeChanged) {
+            return;
+        }
+        Iterator<N.a> it = this.onMultiWindowModeChangedListeners.iterator();
+        while (it.hasNext()) {
+            it.next().a(new C.n(z3));
+        }
+    }
+
+    @Override // android.app.Activity
+    public void onNewIntent(Intent intent) {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        super.onNewIntent(intent);
+        Iterator<N.a> it = this.onNewIntentListeners.iterator();
+        while (it.hasNext()) {
+            it.next().a(intent);
+        }
+    }
+
+    @Override // android.app.Activity, android.view.Window.Callback
+    public void onPanelClosed(int i, Menu menu) {
+        Intrinsics.checkNotNullParameter(menu, "menu");
+        Iterator it = this.menuHostHelper.f1276b.iterator();
+        while (it.hasNext()) {
+            ((C0140c0) ((InterfaceC0076q) it.next())).f3105a.q(menu);
+        }
+        super.onPanelClosed(i, menu);
+    }
+
+    @Override // android.app.Activity
+    @Deprecated(message = "Deprecated in android.app.Activity")
+    public void onPictureInPictureModeChanged(boolean z3) {
+        if (this.dispatchingOnPictureInPictureModeChanged) {
+            return;
+        }
+        Iterator<N.a> it = this.onPictureInPictureModeChangedListeners.iterator();
+        while (it.hasNext()) {
+            it.next().a(new C.J(z3));
+        }
+    }
+
+    @Override // android.app.Activity, android.view.Window.Callback
+    public boolean onPreparePanel(int i, View view, Menu menu) {
+        Intrinsics.checkNotNullParameter(menu, "menu");
+        if (i != 0) {
+            return true;
+        }
+        super.onPreparePanel(i, view, menu);
+        Iterator it = this.menuHostHelper.f1276b.iterator();
+        while (it.hasNext()) {
+            ((C0140c0) ((InterfaceC0076q) it.next())).f3105a.t(menu);
+        }
+        return true;
+    }
+
+    @Override // android.app.Activity
+    public void onRequestPermissionsResult(int i, String[] permissions, int[] grantResults) {
+        Intrinsics.checkNotNullParameter(permissions, "permissions");
+        Intrinsics.checkNotNullParameter(grantResults, "grantResults");
+        if (this.activityResultRegistry.a(i, -1, new Intent().putExtra("androidx.activity.result.contract.extra.PERMISSIONS", permissions).putExtra("androidx.activity.result.contract.extra.PERMISSION_GRANT_RESULTS", grantResults))) {
+            return;
+        }
+        super.onRequestPermissionsResult(i, permissions, grantResults);
+    }
+
+    @Deprecated(message = "Use a {@link androidx.lifecycle.ViewModel} to store non config state.")
+    public Object onRetainCustomNonConfigurationInstance() {
+        return null;
+    }
+
+    /* JADX WARN: Type inference failed for: r2v1, types: [java.lang.Object, b.i] */
+    @Override // android.app.Activity
+    public final Object onRetainNonConfigurationInstance() {
+        i iVar;
+        Object onRetainCustomNonConfigurationInstance = onRetainCustomNonConfigurationInstance();
+        C0 c02 = this._viewModelStore;
+        if (c02 == null && (iVar = (i) getLastNonConfigurationInstance()) != null) {
+            c02 = iVar.f4117b;
+        }
+        if (c02 == null && onRetainCustomNonConfigurationInstance == null) {
+            return null;
+        }
+        ?? obj = new Object();
+        obj.f4116a = onRetainCustomNonConfigurationInstance;
+        obj.f4117b = c02;
+        return obj;
+    }
+
+    @Override // C.AbstractActivityC0048l, android.app.Activity
+    public void onSaveInstanceState(Bundle outState) {
+        Intrinsics.checkNotNullParameter(outState, "outState");
+        if (getLifecycle() instanceof L) {
+            androidx.lifecycle.C lifecycle = getLifecycle();
+            Intrinsics.checkNotNull(lifecycle, "null cannot be cast to non-null type androidx.lifecycle.LifecycleRegistry");
+            ((L) lifecycle).h(androidx.lifecycle.B.f3282c);
+        }
+        super.onSaveInstanceState(outState);
+        this.savedStateRegistryController.c(outState);
+    }
+
+    @Override // android.app.Activity, android.content.ComponentCallbacks2
+    public void onTrimMemory(int i) {
+        super.onTrimMemory(i);
+        Iterator<N.a> it = this.onTrimMemoryListeners.iterator();
+        while (it.hasNext()) {
+            it.next().a(Integer.valueOf(i));
+        }
+    }
+
+    @Override // android.app.Activity
+    public void onUserLeaveHint() {
+        super.onUserLeaveHint();
+        Iterator<Runnable> it = this.onUserLeaveHintListeners.iterator();
+        while (it.hasNext()) {
+            it.next().run();
+        }
+    }
+
+    public Context peekAvailableContext() {
+        return this.contextAwareHelper.f4198b;
+    }
+
+    public final <I, O> AbstractC0294c registerForActivityResult(AbstractC0311a contract, AbstractC0300i registry, InterfaceC0293b callback) {
+        Intrinsics.checkNotNullParameter(contract, "contract");
+        Intrinsics.checkNotNullParameter(registry, "registry");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        return registry.c("activity_rq#" + this.nextLocalRequestCode.getAndIncrement(), this, contract, callback);
+    }
+
+    @Override // O.InterfaceC0070k
+    public void removeMenuProvider(InterfaceC0076q provider) {
+        Intrinsics.checkNotNullParameter(provider, "provider");
+        this.menuHostHelper.b(provider);
+    }
+
+    @Override // D.l
+    public final void removeOnConfigurationChangedListener(N.a listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onConfigurationChangedListeners.remove(listener);
+    }
+
+    public final void removeOnContextAvailableListener(InterfaceC0274b listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        C0273a c0273a = this.contextAwareHelper;
+        c0273a.getClass();
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        c0273a.f4197a.remove(listener);
+    }
+
+    @Override // C.H
+    public final void removeOnMultiWindowModeChangedListener(N.a listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onMultiWindowModeChangedListeners.remove(listener);
+    }
+
+    public final void removeOnNewIntentListener(N.a listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onNewIntentListeners.remove(listener);
+    }
+
+    @Override // C.I
+    public final void removeOnPictureInPictureModeChangedListener(N.a listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onPictureInPictureModeChangedListeners.remove(listener);
+    }
+
+    @Override // D.m
+    public final void removeOnTrimMemoryListener(N.a listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onTrimMemoryListeners.remove(listener);
+    }
+
+    public final void removeOnUserLeaveHintListener(Runnable listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.onUserLeaveHintListeners.remove(listener);
+    }
+
+    @Override // android.app.Activity
+    public void reportFullyDrawn() {
+        try {
+            if (AbstractC0105a.F()) {
+                Trace.beginSection("reportFullyDrawn() for ComponentActivity");
+            }
+            super.reportFullyDrawn();
+            getFullyDrawnReporter().a();
+        } finally {
+            Trace.endSection();
+        }
+    }
+
+    @Override // android.app.Activity
+    public abstract void setContentView(int i);
+
+    @Override // android.app.Activity
+    public void setContentView(View view) {
+        initializeViewTreeOwners();
+        j jVar = this.reportFullyDrawnExecutor;
+        View view2 = getWindow().getDecorView();
+        Intrinsics.checkNotNullExpressionValue(view2, "window.decorView");
+        k kVar = (k) jVar;
+        kVar.getClass();
+        Intrinsics.checkNotNullParameter(view2, "view");
+        if (!kVar.f4120c) {
+            kVar.f4120c = true;
+            view2.getViewTreeObserver().addOnDrawListener(kVar);
+        }
+        super.setContentView(view);
+    }
+
+    @Override // android.app.Activity
+    @Deprecated(message = "This method has been deprecated in favor of using the Activity Result API\n      which brings increased type safety via an {@link ActivityResultContract} and the prebuilt\n      contracts for common intents available in\n      {@link androidx.activity.result.contract.ActivityResultContracts}, provides hooks for\n      testing, and allow receiving results in separate, testable classes independent from your\n      activity. Use\n      {@link #registerForActivityResult(ActivityResultContract, ActivityResultCallback)}\n      passing in a {@link StartActivityForResult} object for the {@link ActivityResultContract}.")
+    public void startActivityForResult(Intent intent, int i) {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        super.startActivityForResult(intent, i);
+    }
+
+    @Override // android.app.Activity
+    @Deprecated(message = "This method has been deprecated in favor of using the Activity Result API\n      which brings increased type safety via an {@link ActivityResultContract} and the prebuilt\n      contracts for common intents available in\n      {@link androidx.activity.result.contract.ActivityResultContracts}, provides hooks for\n      testing, and allow receiving results in separate, testable classes independent from your\n      activity. Use\n      {@link #registerForActivityResult(ActivityResultContract, ActivityResultCallback)}\n      passing in a {@link StartIntentSenderForResult} object for the\n      {@link ActivityResultContract}.")
+    public void startIntentSenderForResult(IntentSender intent, int i, Intent intent2, int i4, int i5, int i6) throws IntentSender.SendIntentException {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        super.startIntentSenderForResult(intent, i, intent2, i4, i5, i6);
+    }
+
+    @Override // android.app.Activity
+    @Deprecated(message = "This method has been deprecated in favor of using the Activity Result API\n      which brings increased type safety via an {@link ActivityResultContract} and the prebuilt\n      contracts for common intents available in\n      {@link androidx.activity.result.contract.ActivityResultContracts}, provides hooks for\n      testing, and allow receiving results in separate, testable classes independent from your\n      activity. Use\n      {@link #registerForActivityResult(ActivityResultContract, ActivityResultCallback)}\n      passing in a {@link StartActivityForResult} object for the {@link ActivityResultContract}.")
+    public void startActivityForResult(Intent intent, int i, Bundle bundle) {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        super.startActivityForResult(intent, i, bundle);
+    }
+
+    @Override // android.app.Activity
+    @Deprecated(message = "This method has been deprecated in favor of using the Activity Result API\n      which brings increased type safety via an {@link ActivityResultContract} and the prebuilt\n      contracts for common intents available in\n      {@link androidx.activity.result.contract.ActivityResultContracts}, provides hooks for\n      testing, and allow receiving results in separate, testable classes independent from your\n      activity. Use\n      {@link #registerForActivityResult(ActivityResultContract, ActivityResultCallback)}\n      passing in a {@link StartIntentSenderForResult} object for the\n      {@link ActivityResultContract}.")
+    public void startIntentSenderForResult(IntentSender intent, int i, Intent intent2, int i4, int i5, int i6, Bundle bundle) throws IntentSender.SendIntentException {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        super.startIntentSenderForResult(intent, i, intent2, i4, i5, i6, bundle);
+    }
+
+    public final <I, O> AbstractC0294c registerForActivityResult(AbstractC0311a contract, InterfaceC0293b callback) {
+        Intrinsics.checkNotNullParameter(contract, "contract");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        return registerForActivityResult(contract, this.activityResultRegistry, callback);
+    }
+
+    @Override // android.app.Activity
+    public void onMultiWindowModeChanged(boolean z3, Configuration newConfig) {
+        Intrinsics.checkNotNullParameter(newConfig, "newConfig");
+        this.dispatchingOnMultiWindowModeChanged = true;
+        try {
+            super.onMultiWindowModeChanged(z3, newConfig);
+            this.dispatchingOnMultiWindowModeChanged = false;
+            Iterator<N.a> it = this.onMultiWindowModeChangedListeners.iterator();
+            while (it.hasNext()) {
+                N.a next = it.next();
+                Intrinsics.checkNotNullParameter(newConfig, "newConfig");
+                next.a(new C.n(z3));
+            }
+        } catch (Throwable th) {
+            this.dispatchingOnMultiWindowModeChanged = false;
+            throw th;
+        }
+    }
+
+    @Override // android.app.Activity
+    public void onPictureInPictureModeChanged(boolean z3, Configuration newConfig) {
+        Intrinsics.checkNotNullParameter(newConfig, "newConfig");
+        this.dispatchingOnPictureInPictureModeChanged = true;
+        try {
+            super.onPictureInPictureModeChanged(z3, newConfig);
+            this.dispatchingOnPictureInPictureModeChanged = false;
+            Iterator<N.a> it = this.onPictureInPictureModeChangedListeners.iterator();
+            while (it.hasNext()) {
+                N.a next = it.next();
+                Intrinsics.checkNotNullParameter(newConfig, "newConfig");
+                next.a(new C.J(z3));
+            }
+        } catch (Throwable th) {
+            this.dispatchingOnPictureInPictureModeChanged = false;
+            throw th;
+        }
+    }
+
+    public void addMenuProvider(InterfaceC0076q provider, J owner) {
+        Intrinsics.checkNotNullParameter(provider, "provider");
+        Intrinsics.checkNotNullParameter(owner, "owner");
+        C0074o c0074o = this.menuHostHelper;
+        c0074o.f1276b.add(provider);
+        c0074o.f1275a.run();
+        androidx.lifecycle.C lifecycle = owner.getLifecycle();
+        HashMap hashMap = c0074o.f1277c;
+        C0073n c0073n = (C0073n) hashMap.remove(provider);
+        if (c0073n != null) {
+            c0073n.f1273a.c(c0073n.f1274b);
+            c0073n.f1274b = null;
+        }
+        hashMap.put(provider, new C0073n(lifecycle, new C0072m(0, c0074o, provider)));
+    }
+
+    @SuppressLint({"LambdaLast"})
+    public void addMenuProvider(final InterfaceC0076q provider, J owner, final androidx.lifecycle.B state) {
+        Intrinsics.checkNotNullParameter(provider, "provider");
+        Intrinsics.checkNotNullParameter(owner, "owner");
+        Intrinsics.checkNotNullParameter(state, "state");
+        final C0074o c0074o = this.menuHostHelper;
+        c0074o.getClass();
+        androidx.lifecycle.C lifecycle = owner.getLifecycle();
+        HashMap hashMap = c0074o.f1277c;
+        C0073n c0073n = (C0073n) hashMap.remove(provider);
+        if (c0073n != null) {
+            c0073n.f1273a.c(c0073n.f1274b);
+            c0073n.f1274b = null;
+        }
+        hashMap.put(provider, new C0073n(lifecycle, new androidx.lifecycle.H() { // from class: O.l
+            @Override // androidx.lifecycle.H
+            public final void onStateChanged(androidx.lifecycle.J j4, androidx.lifecycle.A a2) {
+                C0074o c0074o2 = C0074o.this;
+                c0074o2.getClass();
+                androidx.lifecycle.A.Companion.getClass();
+                androidx.lifecycle.B b4 = state;
+                androidx.lifecycle.A c4 = C0203y.c(b4);
+                Runnable runnable = c0074o2.f1275a;
+                CopyOnWriteArrayList copyOnWriteArrayList = c0074o2.f1276b;
+                InterfaceC0076q interfaceC0076q = provider;
+                if (a2 == c4) {
+                    copyOnWriteArrayList.add(interfaceC0076q);
+                    runnable.run();
+                } else if (a2 == androidx.lifecycle.A.ON_DESTROY) {
+                    c0074o2.b(interfaceC0076q);
+                } else if (a2 == C0203y.a(b4)) {
+                    copyOnWriteArrayList.remove(interfaceC0076q);
+                    runnable.run();
+                }
+            }
+        }));
+    }
+
+    public o(int i) {
+        this();
+        this.contentLayoutId = i;
+    }
+}

apk_decompiled/sources/b/p.java

@@ -0,0 +1,168 @@
+package b;
+
+import a.AbstractC0106b;
+import android.app.Dialog;
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.window.OnBackInvokedDispatcher;
+import androidx.lifecycle.J;
+import androidx.lifecycle.L;
+import androidx.lifecycle.q0;
+import kotlin.jvm.internal.Intrinsics;
+import v0.C0639d;
+import v0.C0640e;
+
+/* loaded from: classes.dex */
+public class p extends Dialog implements J, D, v0.f {
+
+    /* renamed from: a, reason: collision with root package name */
+    public L f4128a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final C0640e f4129b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final B f4130c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public p(Context context, int i) {
+        super(context, i);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(this, "owner");
+        this.f4129b = new C0640e(this);
+        this.f4130c = new B(new F2.f(this, 6));
+    }
+
+    public static void a(p this$0) {
+        Intrinsics.checkNotNullParameter(this$0, "this$0");
+        super.onBackPressed();
+    }
+
+    @Override // android.app.Dialog
+    public void addContentView(View view, ViewGroup.LayoutParams layoutParams) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        b();
+        super.addContentView(view, layoutParams);
+    }
+
+    public final void b() {
+        Window window = getWindow();
+        Intrinsics.checkNotNull(window);
+        View decorView = window.getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView, "window!!.decorView");
+        q0.m(decorView, this);
+        Window window2 = getWindow();
+        Intrinsics.checkNotNull(window2);
+        View decorView2 = window2.getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView2, "window!!.decorView");
+        AbstractC0106b.H(decorView2, this);
+        Window window3 = getWindow();
+        Intrinsics.checkNotNull(window3);
+        View decorView3 = window3.getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView3, "window!!.decorView");
+        m3.d.D(decorView3, this);
+    }
+
+    @Override // androidx.lifecycle.J
+    public final androidx.lifecycle.C getLifecycle() {
+        L l4 = this.f4128a;
+        if (l4 != null) {
+            return l4;
+        }
+        L l5 = new L(this);
+        this.f4128a = l5;
+        return l5;
+    }
+
+    @Override // b.D
+    public final B getOnBackPressedDispatcher() {
+        return this.f4130c;
+    }
+
+    @Override // v0.f
+    public final C0639d getSavedStateRegistry() {
+        return this.f4129b.f8636b;
+    }
+
+    @Override // android.app.Dialog
+    public final void onBackPressed() {
+        this.f4130c.d();
+    }
+
+    @Override // android.app.Dialog
+    public void onCreate(Bundle bundle) {
+        OnBackInvokedDispatcher invoker;
+        super.onCreate(bundle);
+        if (Build.VERSION.SDK_INT >= 33) {
+            invoker = getOnBackInvokedDispatcher();
+            Intrinsics.checkNotNullExpressionValue(invoker, "onBackInvokedDispatcher");
+            B b4 = this.f4130c;
+            b4.getClass();
+            Intrinsics.checkNotNullParameter(invoker, "invoker");
+            b4.f4100e = invoker;
+            b4.e(b4.f4102g);
+        }
+        this.f4129b.b(bundle);
+        L l4 = this.f4128a;
+        if (l4 == null) {
+            l4 = new L(this);
+            this.f4128a = l4;
+        }
+        l4.f(androidx.lifecycle.A.ON_CREATE);
+    }
+
+    @Override // android.app.Dialog
+    public final Bundle onSaveInstanceState() {
+        Bundle onSaveInstanceState = super.onSaveInstanceState();
+        Intrinsics.checkNotNullExpressionValue(onSaveInstanceState, "super.onSaveInstanceState()");
+        this.f4129b.c(onSaveInstanceState);
+        return onSaveInstanceState;
+    }
+
+    @Override // android.app.Dialog
+    public void onStart() {
+        super.onStart();
+        L l4 = this.f4128a;
+        if (l4 == null) {
+            l4 = new L(this);
+            this.f4128a = l4;
+        }
+        l4.f(androidx.lifecycle.A.ON_RESUME);
+    }
+
+    @Override // android.app.Dialog
+    public void onStop() {
+        L l4 = this.f4128a;
+        if (l4 == null) {
+            l4 = new L(this);
+            this.f4128a = l4;
+        }
+        l4.f(androidx.lifecycle.A.ON_DESTROY);
+        this.f4128a = null;
+        super.onStop();
+    }
+
+    @Override // android.app.Dialog
+    public void setContentView(int i) {
+        b();
+        super.setContentView(i);
+    }
+
+    @Override // android.app.Dialog
+    public void setContentView(View view) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        b();
+        super.setContentView(view);
+    }
+
+    @Override // android.app.Dialog
+    public void setContentView(View view, ViewGroup.LayoutParams layoutParams) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        b();
+        super.setContentView(view, layoutParams);
+    }
+}

apk_decompiled/sources/b/q.java

@@ -0,0 +1,43 @@
+package b;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class q {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Object f4131a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public boolean f4132b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final ArrayList f4133c;
+
+    public q(j executor, n reportFullyDrawn) {
+        Intrinsics.checkNotNullParameter(executor, "executor");
+        Intrinsics.checkNotNullParameter(reportFullyDrawn, "reportFullyDrawn");
+        this.f4131a = new Object();
+        this.f4133c = new ArrayList();
+    }
+
+    public final void a() {
+        synchronized (this.f4131a) {
+            try {
+                this.f4132b = true;
+                Iterator it = this.f4133c.iterator();
+                while (it.hasNext()) {
+                    ((Function0) it.next()).invoke();
+                }
+                this.f4133c.clear();
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

apk_decompiled/sources/b/r.java

@@ -0,0 +1,71 @@
+package b;
+
+import java.util.Iterator;
+import java.util.concurrent.CopyOnWriteArrayList;
+import kotlin.Unit;
+import kotlin.jvm.JvmName;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public abstract class r {
+    private final CopyOnWriteArrayList<InterfaceC0254c> cancellables = new CopyOnWriteArrayList<>();
+    private Function0<Unit> enabledChangedCallback;
+    private boolean isEnabled;
+
+    public r(boolean z3) {
+        this.isEnabled = z3;
+    }
+
+    @JvmName(name = "addCancellable")
+    public final void addCancellable(InterfaceC0254c cancellable) {
+        Intrinsics.checkNotNullParameter(cancellable, "cancellable");
+        this.cancellables.add(cancellable);
+    }
+
+    public final Function0<Unit> getEnabledChangedCallback$activity_release() {
+        return this.enabledChangedCallback;
+    }
+
+    public void handleOnBackCancelled() {
+    }
+
+    public abstract void handleOnBackPressed();
+
+    public void handleOnBackProgressed(C0253b backEvent) {
+        Intrinsics.checkNotNullParameter(backEvent, "backEvent");
+    }
+
+    public void handleOnBackStarted(C0253b backEvent) {
+        Intrinsics.checkNotNullParameter(backEvent, "backEvent");
+    }
+
+    public final boolean isEnabled() {
+        return this.isEnabled;
+    }
+
+    public final void remove() {
+        Iterator<T> it = this.cancellables.iterator();
+        while (it.hasNext()) {
+            ((InterfaceC0254c) it.next()).cancel();
+        }
+    }
+
+    @JvmName(name = "removeCancellable")
+    public final void removeCancellable(InterfaceC0254c cancellable) {
+        Intrinsics.checkNotNullParameter(cancellable, "cancellable");
+        this.cancellables.remove(cancellable);
+    }
+
+    public final void setEnabled(boolean z3) {
+        this.isEnabled = z3;
+        Function0<Unit> function0 = this.enabledChangedCallback;
+        if (function0 != null) {
+            function0.invoke();
+        }
+    }
+
+    public final void setEnabledChangedCallback$activity_release(Function0<Unit> function0) {
+        this.enabledChangedCallback = function0;
+    }
+}

apk_decompiled/sources/b/s.java

@@ -0,0 +1,80 @@
+package b;
+
+import java.util.ListIterator;
+import kotlin.Unit;
+import kotlin.collections.ArrayDeque;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class s extends Lambda implements Function1 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f4134a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ B f4135b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public /* synthetic */ s(B b4, int i) {
+        super(1);
+        this.f4134a = i;
+        this.f4135b = b4;
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public final Object invoke(Object obj) {
+        Object obj2;
+        Object obj3;
+        switch (this.f4134a) {
+            case 0:
+                C0253b backEvent = (C0253b) obj;
+                Intrinsics.checkNotNullParameter(backEvent, "backEvent");
+                B b4 = this.f4135b;
+                ArrayDeque arrayDeque = b4.f4097b;
+                ListIterator<E> listIterator = arrayDeque.listIterator(arrayDeque.size());
+                while (true) {
+                    if (listIterator.hasPrevious()) {
+                        obj2 = listIterator.previous();
+                        if (((r) obj2).isEnabled()) {
+                        }
+                    } else {
+                        obj2 = null;
+                    }
+                }
+                r rVar = (r) obj2;
+                if (b4.f4098c != null) {
+                    b4.c();
+                }
+                b4.f4098c = rVar;
+                if (rVar != null) {
+                    rVar.handleOnBackStarted(backEvent);
+                }
+                return Unit.INSTANCE;
+            default:
+                C0253b backEvent2 = (C0253b) obj;
+                Intrinsics.checkNotNullParameter(backEvent2, "backEvent");
+                B b5 = this.f4135b;
+                r rVar2 = b5.f4098c;
+                if (rVar2 == null) {
+                    ArrayDeque arrayDeque2 = b5.f4097b;
+                    ListIterator<E> listIterator2 = arrayDeque2.listIterator(arrayDeque2.size());
+                    while (true) {
+                        if (listIterator2.hasPrevious()) {
+                            obj3 = listIterator2.previous();
+                            if (((r) obj3).isEnabled()) {
+                            }
+                        } else {
+                            obj3 = null;
+                        }
+                    }
+                    rVar2 = (r) obj3;
+                }
+                if (rVar2 != null) {
+                    rVar2.handleOnBackProgressed(backEvent2);
+                }
+                return Unit.INSTANCE;
+        }
+    }
+}

apk_decompiled/sources/b/t.java

@@ -0,0 +1,37 @@
+package b;
+
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+
+/* loaded from: classes.dex */
+public final class t extends Lambda implements Function0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f4136a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ B f4137b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public /* synthetic */ t(B b4, int i) {
+        super(0);
+        this.f4136a = i;
+        this.f4137b = b4;
+    }
+
+    @Override // kotlin.jvm.functions.Function0
+    public final Object invoke() {
+        switch (this.f4136a) {
+            case 0:
+                this.f4137b.d();
+                return Unit.INSTANCE;
+            case 1:
+                this.f4137b.c();
+                return Unit.INSTANCE;
+            default:
+                this.f4137b.d();
+                return Unit.INSTANCE;
+        }
+    }
+}

apk_decompiled/sources/b/u.java

@@ -0,0 +1,43 @@
+package b;
+
+import android.window.OnBackInvokedCallback;
+import g.LayoutInflaterFactory2C0351E;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import y2.InterfaceC0663b;
+
+/* loaded from: classes.dex */
+public final /* synthetic */ class u implements OnBackInvokedCallback {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f4138a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Object f4139b;
+
+    public /* synthetic */ u(Object obj, int i) {
+        this.f4138a = i;
+        this.f4139b = obj;
+    }
+
+    public final void onBackInvoked() {
+        int i = this.f4138a;
+        Object obj = this.f4139b;
+        switch (i) {
+            case 0:
+                Function0 onBackInvoked = (Function0) obj;
+                Intrinsics.checkNotNullParameter(onBackInvoked, "$onBackInvoked");
+                onBackInvoked.invoke();
+                return;
+            case 1:
+                ((LayoutInflaterFactory2C0351E) obj).E();
+                return;
+            case 2:
+                ((Runnable) obj).run();
+                return;
+            default:
+                ((InterfaceC0663b) obj).a();
+                return;
+        }
+    }
+}

apk_decompiled/sources/b/v.java

@@ -0,0 +1,31 @@
+package b;
+
+import android.window.OnBackInvokedCallback;
+import android.window.OnBackInvokedDispatcher;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class v {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final v f4140a = new Object();
+
+    public final OnBackInvokedCallback a(Function0<Unit> onBackInvoked) {
+        Intrinsics.checkNotNullParameter(onBackInvoked, "onBackInvoked");
+        return new u(onBackInvoked, 0);
+    }
+
+    public final void b(Object dispatcher, int i, Object callback) {
+        Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        ((OnBackInvokedDispatcher) dispatcher).registerOnBackInvokedCallback(i, (OnBackInvokedCallback) callback);
+    }
+
+    public final void c(Object dispatcher, Object callback) {
+        Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        ((OnBackInvokedDispatcher) dispatcher).unregisterOnBackInvokedCallback((OnBackInvokedCallback) callback);
+    }
+}

apk_decompiled/sources/b/w.java

@@ -0,0 +1,48 @@
+package b;
+
+import android.window.BackEvent;
+import android.window.OnBackAnimationCallback;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class w implements OnBackAnimationCallback {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ Function1 f4141a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Function1 f4142b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ Function0 f4143c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ Function0 f4144d;
+
+    public w(Function1 function1, Function1 function12, Function0 function0, Function0 function02) {
+        this.f4141a = function1;
+        this.f4142b = function12;
+        this.f4143c = function0;
+        this.f4144d = function02;
+    }
+
+    public final void onBackCancelled() {
+        this.f4144d.invoke();
+    }
+
+    public final void onBackInvoked() {
+        this.f4143c.invoke();
+    }
+
+    public final void onBackProgressed(BackEvent backEvent) {
+        Intrinsics.checkNotNullParameter(backEvent, "backEvent");
+        this.f4142b.invoke(new C0253b(backEvent));
+    }
+
+    public final void onBackStarted(BackEvent backEvent) {
+        Intrinsics.checkNotNullParameter(backEvent, "backEvent");
+        this.f4141a.invoke(new C0253b(backEvent));
+    }
+}

apk_decompiled/sources/b/x.java

@@ -0,0 +1,22 @@
+package b;
+
+import android.window.OnBackInvokedCallback;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class x {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final x f4145a = new Object();
+
+    public final OnBackInvokedCallback a(Function1<? super C0253b, Unit> onBackStarted, Function1<? super C0253b, Unit> onBackProgressed, Function0<Unit> onBackInvoked, Function0<Unit> onBackCancelled) {
+        Intrinsics.checkNotNullParameter(onBackStarted, "onBackStarted");
+        Intrinsics.checkNotNullParameter(onBackProgressed, "onBackProgressed");
+        Intrinsics.checkNotNullParameter(onBackInvoked, "onBackInvoked");
+        Intrinsics.checkNotNullParameter(onBackCancelled, "onBackCancelled");
+        return new w(onBackStarted, onBackProgressed, onBackInvoked, onBackCancelled);
+    }
+}

apk_decompiled/sources/b/y.java

@@ -0,0 +1,61 @@
+package b;
+
+import androidx.lifecycle.H;
+import androidx.lifecycle.J;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class y implements H, InterfaceC0254c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final androidx.lifecycle.C f4146a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final r f4147b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public z f4148c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ B f4149d;
+
+    public y(B b4, androidx.lifecycle.C lifecycle, r onBackPressedCallback) {
+        Intrinsics.checkNotNullParameter(lifecycle, "lifecycle");
+        Intrinsics.checkNotNullParameter(onBackPressedCallback, "onBackPressedCallback");
+        this.f4149d = b4;
+        this.f4146a = lifecycle;
+        this.f4147b = onBackPressedCallback;
+        lifecycle.a(this);
+    }
+
+    @Override // b.InterfaceC0254c
+    public final void cancel() {
+        this.f4146a.c(this);
+        this.f4147b.removeCancellable(this);
+        z zVar = this.f4148c;
+        if (zVar != null) {
+            zVar.cancel();
+        }
+        this.f4148c = null;
+    }
+
+    @Override // androidx.lifecycle.H
+    public final void onStateChanged(J source, androidx.lifecycle.A event) {
+        Intrinsics.checkNotNullParameter(source, "source");
+        Intrinsics.checkNotNullParameter(event, "event");
+        if (event == androidx.lifecycle.A.ON_START) {
+            this.f4148c = this.f4149d.b(this.f4147b);
+            return;
+        }
+        if (event != androidx.lifecycle.A.ON_STOP) {
+            if (event == androidx.lifecycle.A.ON_DESTROY) {
+                cancel();
+            }
+        } else {
+            z zVar = this.f4148c;
+            if (zVar != null) {
+                zVar.cancel();
+            }
+        }
+    }
+}

apk_decompiled/sources/b/z.java

@@ -0,0 +1,40 @@
+package b;
+
+import kotlin.Unit;
+import kotlin.collections.ArrayDeque;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class z implements InterfaceC0254c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final r f4150a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ B f4151b;
+
+    public z(B b4, r onBackPressedCallback) {
+        Intrinsics.checkNotNullParameter(onBackPressedCallback, "onBackPressedCallback");
+        this.f4151b = b4;
+        this.f4150a = onBackPressedCallback;
+    }
+
+    @Override // b.InterfaceC0254c
+    public final void cancel() {
+        B b4 = this.f4151b;
+        ArrayDeque arrayDeque = b4.f4097b;
+        r rVar = this.f4150a;
+        arrayDeque.remove(rVar);
+        if (Intrinsics.areEqual(b4.f4098c, rVar)) {
+            rVar.handleOnBackCancelled();
+            b4.f4098c = null;
+        }
+        rVar.removeCancellable(this);
+        Function0<Unit> enabledChangedCallback$activity_release = rVar.getEnabledChangedCallback$activity_release();
+        if (enabledChangedCallback$activity_release != null) {
+            enabledChangedCallback$activity_release.invoke();
+        }
+        rVar.setEnabledChangedCallback$activity_release(null);
+    }
+}