Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

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);
+    }
+}