Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/androidx/navigation/fragment/DialogFragmentNavigator.java

@@ -0,0 +1,155 @@
+package androidx.navigation.fragment;
+
+import C.w;
+import android.content.Context;
+import android.util.Log;
+import androidx.fragment.app.AbstractC0158l0;
+import androidx.fragment.app.C0142d0;
+import androidx.fragment.app.DialogInterfaceOnCancelListenerC0174y;
+import androidx.fragment.app.q0;
+import androidx.lifecycle.C;
+import androidx.navigation.fragment.DialogFragmentNavigator;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import kotlin.Metadata;
+import kotlin.collections.CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.TypeIntrinsics;
+import o0.C0537n;
+import o0.C0539p;
+import o0.C0540q;
+import o0.E;
+import o0.K;
+import o0.U;
+import o0.V;
+import q0.C0555b;
+
+@Metadata(d1 = {"\u0000\u000e\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0000\b\u0007\u0018\u00002\b\u0012\u0004\u0012\u00020\u00020\u0001:\u0001\u0002¨\u0006\u0003"}, d2 = {"Landroidx/navigation/fragment/DialogFragmentNavigator;", "Lo0/V;", "Lq0/b;", "navigation-fragment_release"}, k = 1, mv = {1, 6, 0}, xi = 48)
+@U("dialog")
+/* loaded from: classes.dex */
+public final class DialogFragmentNavigator extends V {
+
+    /* renamed from: c, reason: collision with root package name */
+    public final Context f3446c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final AbstractC0158l0 f3447d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final LinkedHashSet f3448e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final C0539p f3449f;
+
+    public DialogFragmentNavigator(Context context, AbstractC0158l0 fragmentManager) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(fragmentManager, "fragmentManager");
+        this.f3446c = context;
+        this.f3447d = fragmentManager;
+        this.f3448e = new LinkedHashSet();
+        this.f3449f = new C0539p(this, 1);
+    }
+
+    @Override // o0.V
+    public final E a() {
+        Intrinsics.checkNotNullParameter(this, "fragmentNavigator");
+        return new E(this);
+    }
+
+    @Override // o0.V
+    public final void d(List entries, K k4) {
+        Intrinsics.checkNotNullParameter(entries, "entries");
+        AbstractC0158l0 abstractC0158l0 = this.f3447d;
+        if (abstractC0158l0.Q()) {
+            Log.i("DialogFragmentNavigator", "Ignoring navigate() call: FragmentManager has already saved its state");
+            return;
+        }
+        Iterator it = entries.iterator();
+        while (it.hasNext()) {
+            C0537n c0537n = (C0537n) it.next();
+            C0555b c0555b = (C0555b) c0537n.f8006b;
+            String str = c0555b.f8147k;
+            if (str == null) {
+                throw new IllegalStateException("DialogFragment class was not set");
+            }
+            char charAt = str.charAt(0);
+            Context context = this.f3446c;
+            if (charAt == '.') {
+                str = context.getPackageName() + str;
+            }
+            C0142d0 J = abstractC0158l0.J();
+            context.getClassLoader();
+            androidx.fragment.app.K a2 = J.a(str);
+            Intrinsics.checkNotNullExpressionValue(a2, "fragmentManager.fragment…ader, className\n        )");
+            if (!DialogInterfaceOnCancelListenerC0174y.class.isAssignableFrom(a2.getClass())) {
+                StringBuilder sb = new StringBuilder("Dialog destination ");
+                String str2 = c0555b.f8147k;
+                if (str2 == null) {
+                    throw new IllegalStateException("DialogFragment class was not set");
+                }
+                throw new IllegalArgumentException(w.r(sb, str2, " is not an instance of DialogFragment").toString());
+            }
+            DialogInterfaceOnCancelListenerC0174y dialogInterfaceOnCancelListenerC0174y = (DialogInterfaceOnCancelListenerC0174y) a2;
+            dialogInterfaceOnCancelListenerC0174y.setArguments(c0537n.f8007c);
+            dialogInterfaceOnCancelListenerC0174y.getLifecycle().a(this.f3449f);
+            dialogInterfaceOnCancelListenerC0174y.show(abstractC0158l0, c0537n.f8010f);
+            b().e(c0537n);
+        }
+    }
+
+    @Override // o0.V
+    public final void e(C0540q state) {
+        C lifecycle;
+        Intrinsics.checkNotNullParameter(state, "state");
+        super.e(state);
+        Iterator it = ((List) state.f8026e.getValue()).iterator();
+        while (true) {
+            boolean hasNext = it.hasNext();
+            AbstractC0158l0 abstractC0158l0 = this.f3447d;
+            if (!hasNext) {
+                abstractC0158l0.p.add(new q0() { // from class: q0.a
+                    @Override // androidx.fragment.app.q0
+                    public final void a(AbstractC0158l0 abstractC0158l02, androidx.fragment.app.K childFragment) {
+                        DialogFragmentNavigator this$0 = DialogFragmentNavigator.this;
+                        Intrinsics.checkNotNullParameter(this$0, "this$0");
+                        Intrinsics.checkNotNullParameter(abstractC0158l02, "<anonymous parameter 0>");
+                        Intrinsics.checkNotNullParameter(childFragment, "childFragment");
+                        LinkedHashSet linkedHashSet = this$0.f3448e;
+                        if (TypeIntrinsics.asMutableCollection(linkedHashSet).remove(childFragment.getTag())) {
+                            childFragment.getLifecycle().a(this$0.f3449f);
+                        }
+                    }
+                });
+                return;
+            }
+            C0537n c0537n = (C0537n) it.next();
+            DialogInterfaceOnCancelListenerC0174y dialogInterfaceOnCancelListenerC0174y = (DialogInterfaceOnCancelListenerC0174y) abstractC0158l0.F(c0537n.f8010f);
+            if (dialogInterfaceOnCancelListenerC0174y == null || (lifecycle = dialogInterfaceOnCancelListenerC0174y.getLifecycle()) == null) {
+                this.f3448e.add(c0537n.f8010f);
+            } else {
+                lifecycle.a(this.f3449f);
+            }
+        }
+    }
+
+    @Override // o0.V
+    public final void i(C0537n popUpTo, boolean z3) {
+        Intrinsics.checkNotNullParameter(popUpTo, "popUpTo");
+        AbstractC0158l0 abstractC0158l0 = this.f3447d;
+        if (abstractC0158l0.Q()) {
+            Log.i("DialogFragmentNavigator", "Ignoring popBackStack() call: FragmentManager has already saved its state");
+            return;
+        }
+        List list = (List) b().f8026e.getValue();
+        Iterator it = CollectionsKt.reversed(list.subList(list.indexOf(popUpTo), list.size())).iterator();
+        while (it.hasNext()) {
+            androidx.fragment.app.K F3 = abstractC0158l0.F(((C0537n) it.next()).f8010f);
+            if (F3 != null) {
+                F3.getLifecycle().c(this.f3449f);
+                ((DialogInterfaceOnCancelListenerC0174y) F3).dismiss();
+            }
+        }
+        b().c(popUpTo, z3);
+    }
+}

apk_decompiled/sources/androidx/navigation/fragment/FragmentNavigator.java

@@ -0,0 +1,204 @@
+package androidx.navigation.fragment;
+
+import a.AbstractC0106b;
+import android.content.Context;
+import android.os.Bundle;
+import android.util.Log;
+import androidx.fragment.app.AbstractC0158l0;
+import androidx.fragment.app.C0135a;
+import androidx.fragment.app.C0142d0;
+import androidx.fragment.app.C0152i0;
+import androidx.fragment.app.C0156k0;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import kotlin.Metadata;
+import kotlin.TuplesKt;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.CollectionsKt__MutableCollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import o0.C0537n;
+import o0.E;
+import o0.K;
+import o0.U;
+import o0.V;
+import q0.C0556c;
+
+@Metadata(d1 = {"\u0000\u000e\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0000\b\u0017\u0018\u00002\b\u0012\u0004\u0012\u00020\u00020\u0001:\u0001\u0002¨\u0006\u0003"}, d2 = {"Landroidx/navigation/fragment/FragmentNavigator;", "Lo0/V;", "Lq0/c;", "navigation-fragment_release"}, k = 1, mv = {1, 6, 0}, xi = 48)
+@U("fragment")
+/* loaded from: classes.dex */
+public class FragmentNavigator extends V {
+
+    /* renamed from: c, reason: collision with root package name */
+    public final Context f3450c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final AbstractC0158l0 f3451d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final int f3452e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final LinkedHashSet f3453f;
+
+    public FragmentNavigator(Context context, AbstractC0158l0 fragmentManager, int i) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(fragmentManager, "fragmentManager");
+        this.f3450c = context;
+        this.f3451d = fragmentManager;
+        this.f3452e = i;
+        this.f3453f = new LinkedHashSet();
+    }
+
+    @Override // o0.V
+    public final E a() {
+        Intrinsics.checkNotNullParameter(this, "fragmentNavigator");
+        return new E(this);
+    }
+
+    @Override // o0.V
+    public final void d(List entries, K k4) {
+        Intrinsics.checkNotNullParameter(entries, "entries");
+        AbstractC0158l0 abstractC0158l0 = this.f3451d;
+        if (abstractC0158l0.Q()) {
+            Log.i("FragmentNavigator", "Ignoring navigate() call: FragmentManager has already saved its state");
+            return;
+        }
+        Iterator it = entries.iterator();
+        while (it.hasNext()) {
+            C0537n c0537n = (C0537n) it.next();
+            boolean isEmpty = ((List) b().f8026e.getValue()).isEmpty();
+            if (k4 == null || isEmpty || !k4.f7938b || !this.f3453f.remove(c0537n.f8010f)) {
+                C0135a k5 = k(c0537n, k4);
+                if (!isEmpty) {
+                    if (!k5.h) {
+                        throw new IllegalStateException("This FragmentTransaction is not allowed to be added to the back stack.");
+                    }
+                    k5.f3263g = true;
+                    k5.i = c0537n.f8010f;
+                }
+                k5.e(false);
+                b().e(c0537n);
+            } else {
+                abstractC0158l0.y(new C0156k0(abstractC0158l0, c0537n.f8010f, 0), false);
+                b().e(c0537n);
+            }
+        }
+    }
+
+    @Override // o0.V
+    public final void f(C0537n backStackEntry) {
+        Intrinsics.checkNotNullParameter(backStackEntry, "backStackEntry");
+        AbstractC0158l0 abstractC0158l0 = this.f3451d;
+        if (abstractC0158l0.Q()) {
+            Log.i("FragmentNavigator", "Ignoring onLaunchSingleTop() call: FragmentManager has already saved its state");
+            return;
+        }
+        C0135a k4 = k(backStackEntry, null);
+        if (((List) b().f8026e.getValue()).size() > 1) {
+            String str = backStackEntry.f8010f;
+            abstractC0158l0.y(new C0152i0(abstractC0158l0, str, -1), false);
+            if (!k4.h) {
+                throw new IllegalStateException("This FragmentTransaction is not allowed to be added to the back stack.");
+            }
+            k4.f3263g = true;
+            k4.i = str;
+        }
+        k4.e(false);
+        b().b(backStackEntry);
+    }
+
+    @Override // o0.V
+    public final void g(Bundle savedState) {
+        Intrinsics.checkNotNullParameter(savedState, "savedState");
+        ArrayList<String> stringArrayList = savedState.getStringArrayList("androidx-nav-fragment:navigator:savedIds");
+        if (stringArrayList != null) {
+            LinkedHashSet linkedHashSet = this.f3453f;
+            linkedHashSet.clear();
+            CollectionsKt__MutableCollectionsKt.addAll(linkedHashSet, stringArrayList);
+        }
+    }
+
+    @Override // o0.V
+    public final Bundle h() {
+        LinkedHashSet linkedHashSet = this.f3453f;
+        if (linkedHashSet.isEmpty()) {
+            return null;
+        }
+        return AbstractC0106b.b(TuplesKt.to("androidx-nav-fragment:navigator:savedIds", new ArrayList(linkedHashSet)));
+    }
+
+    @Override // o0.V
+    public final void i(C0537n popUpTo, boolean z3) {
+        Intrinsics.checkNotNullParameter(popUpTo, "popUpTo");
+        AbstractC0158l0 abstractC0158l0 = this.f3451d;
+        if (abstractC0158l0.Q()) {
+            Log.i("FragmentNavigator", "Ignoring popBackStack() call: FragmentManager has already saved its state");
+            return;
+        }
+        if (z3) {
+            List list = (List) b().f8026e.getValue();
+            C0537n c0537n = (C0537n) CollectionsKt.first(list);
+            for (C0537n c0537n2 : CollectionsKt.reversed(list.subList(list.indexOf(popUpTo), list.size()))) {
+                if (Intrinsics.areEqual(c0537n2, c0537n)) {
+                    Log.i("FragmentNavigator", "FragmentManager cannot save the state of the initial destination " + c0537n2);
+                } else {
+                    abstractC0158l0.y(new C0156k0(abstractC0158l0, c0537n2.f8010f, 1), false);
+                    this.f3453f.add(c0537n2.f8010f);
+                }
+            }
+        } else {
+            abstractC0158l0.y(new C0152i0(abstractC0158l0, popUpTo.f8010f, -1), false);
+        }
+        b().c(popUpTo, z3);
+    }
+
+    public final C0135a k(C0537n c0537n, K k4) {
+        String str = ((C0556c) c0537n.f8006b).f8148k;
+        if (str == null) {
+            throw new IllegalStateException("Fragment class was not set");
+        }
+        char charAt = str.charAt(0);
+        Context context = this.f3450c;
+        if (charAt == '.') {
+            str = context.getPackageName() + str;
+        }
+        AbstractC0158l0 abstractC0158l0 = this.f3451d;
+        C0142d0 J = abstractC0158l0.J();
+        context.getClassLoader();
+        androidx.fragment.app.K a2 = J.a(str);
+        Intrinsics.checkNotNullExpressionValue(a2, "fragmentManager.fragment…t.classLoader, className)");
+        a2.setArguments(c0537n.f8007c);
+        C0135a c0135a = new C0135a(abstractC0158l0);
+        Intrinsics.checkNotNullExpressionValue(c0135a, "fragmentManager.beginTransaction()");
+        int i = k4 != null ? k4.f7942f : -1;
+        int i4 = k4 != null ? k4.f7943g : -1;
+        int i5 = k4 != null ? k4.h : -1;
+        int i6 = k4 != null ? k4.i : -1;
+        if (i != -1 || i4 != -1 || i5 != -1 || i6 != -1) {
+            if (i == -1) {
+                i = 0;
+            }
+            if (i4 == -1) {
+                i4 = 0;
+            }
+            if (i5 == -1) {
+                i5 = 0;
+            }
+            int i7 = i6 != -1 ? i6 : 0;
+            c0135a.f3258b = i;
+            c0135a.f3259c = i4;
+            c0135a.f3260d = i5;
+            c0135a.f3261e = i7;
+        }
+        int i8 = this.f3452e;
+        if (i8 == 0) {
+            throw new IllegalArgumentException("Must use non-zero containerViewId");
+        }
+        c0135a.c(i8, a2, null, 2);
+        c0135a.i(a2);
+        c0135a.p = true;
+        return c0135a;
+    }
+}

apk_decompiled/sources/androidx/navigation/fragment/NavHostFragment.java

@@ -0,0 +1,438 @@
+package androidx.navigation.fragment;
+
+import C.w;
+import a.AbstractC0106b;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.res.TypedArray;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.fragment.app.AbstractC0158l0;
+import androidx.fragment.app.C0135a;
+import androidx.fragment.app.FragmentContainerView;
+import androidx.fragment.app.K;
+import androidx.lifecycle.C;
+import androidx.lifecycle.C0;
+import b.B;
+import b.D;
+import com.adif.elcanomovil.R;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import kotlin.Metadata;
+import kotlin.Unit;
+import kotlin.collections.ArrayDeque;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.MapsKt;
+import kotlin.jvm.internal.ArrayIteratorKt;
+import kotlin.jvm.internal.Intrinsics;
+import m3.l;
+import o0.AbstractC0544v;
+import o0.C0537n;
+import o0.C0538o;
+import o0.C0539p;
+import o0.I;
+import o0.J;
+import o0.V;
+import o0.W;
+import o0.Y;
+import q0.AbstractC0557d;
+
+@Metadata(d1 = {"\u0000\u0010\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\b\u0003\b\u0016\u0018\u00002\u00020\u00012\u00020\u0002B\u0007¢\u0006\u0004\b\u0003\u0010\u0004¨\u0006\u0005"}, d2 = {"Landroidx/navigation/fragment/NavHostFragment;", "Landroidx/fragment/app/K;", "", "<init>", "()V", "navigation-fragment_release"}, k = 1, mv = {1, 6, 0}, xi = 48)
+/* loaded from: classes.dex */
+public class NavHostFragment extends K {
+
+    /* renamed from: a, reason: collision with root package name */
+    public I f3454a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Boolean f3455b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public View f3456c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public int f3457d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public boolean f3458e;
+
+    public final I f() {
+        I i = this.f3454a;
+        if (i != null) {
+            return i;
+        }
+        throw new IllegalStateException("NavController is not available before onCreate()");
+    }
+
+    @Override // androidx.fragment.app.K
+    public final void onAttach(Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        super.onAttach(context);
+        if (this.f3458e) {
+            AbstractC0158l0 parentFragmentManager = getParentFragmentManager();
+            parentFragmentManager.getClass();
+            C0135a c0135a = new C0135a(parentFragmentManager);
+            c0135a.i(this);
+            c0135a.e(false);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v0, types: [android.content.Context, java.lang.Object] */
+    /* JADX WARN: Type inference failed for: r0v1 */
+    /* JADX WARN: Type inference failed for: r0v11, types: [android.content.Context, java.lang.Object] */
+    /* JADX WARN: Type inference failed for: r2v0, types: [o0.v, java.lang.Object, o0.I] */
+    @Override // androidx.fragment.app.K
+    public final void onCreate(Bundle bundle) {
+        Bundle bundle2;
+        C lifecycle;
+        ?? context = requireContext();
+        Intrinsics.checkNotNullExpressionValue(context, "requireContext()");
+        Intrinsics.checkNotNullParameter(context, "context");
+        ?? abstractC0544v = new AbstractC0544v(context);
+        this.f3454a = abstractC0544v;
+        Intrinsics.checkNotNull(abstractC0544v);
+        Intrinsics.checkNotNullParameter(this, "owner");
+        Intrinsics.checkNotNullParameter(this, "owner");
+        if (!Intrinsics.areEqual(this, abstractC0544v.f8059n)) {
+            NavHostFragment navHostFragment = abstractC0544v.f8059n;
+            C0539p c0539p = abstractC0544v.f8063s;
+            if (navHostFragment != null && (lifecycle = navHostFragment.getLifecycle()) != null) {
+                lifecycle.c(c0539p);
+            }
+            abstractC0544v.f8059n = this;
+            getLifecycle().a(c0539p);
+        }
+        while (true) {
+            if (!(context instanceof ContextWrapper)) {
+                break;
+            }
+            if (context instanceof D) {
+                I i = this.f3454a;
+                Intrinsics.checkNotNull(i);
+                B dispatcher = ((D) context).getOnBackPressedDispatcher();
+                Intrinsics.checkNotNullExpressionValue(dispatcher, "context as OnBackPressed…).onBackPressedDispatcher");
+                i.getClass();
+                Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+                Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+                if (!Intrinsics.areEqual(dispatcher, i.f8060o)) {
+                    NavHostFragment navHostFragment2 = i.f8059n;
+                    if (navHostFragment2 == null) {
+                        throw new IllegalStateException("You must call setLifecycleOwner() before calling setOnBackPressedDispatcher()");
+                    }
+                    b.C c4 = i.f8064t;
+                    c4.remove();
+                    i.f8060o = dispatcher;
+                    dispatcher.a(navHostFragment2, c4);
+                    C lifecycle2 = navHostFragment2.getLifecycle();
+                    C0539p c0539p2 = i.f8063s;
+                    lifecycle2.c(c0539p2);
+                    lifecycle2.a(c0539p2);
+                }
+            } else {
+                context = ((ContextWrapper) context).getBaseContext();
+                Intrinsics.checkNotNullExpressionValue(context, "context.baseContext");
+            }
+        }
+        I i4 = this.f3454a;
+        Intrinsics.checkNotNull(i4);
+        Boolean bool = this.f3455b;
+        i4.f8065u = bool != null && bool.booleanValue();
+        i4.z();
+        this.f3455b = null;
+        I i5 = this.f3454a;
+        Intrinsics.checkNotNull(i5);
+        C0 viewModelStore = getViewModelStore();
+        Intrinsics.checkNotNullExpressionValue(viewModelStore, "viewModelStore");
+        i5.getClass();
+        Intrinsics.checkNotNullParameter(viewModelStore, "viewModelStore");
+        Intrinsics.checkNotNullParameter(viewModelStore, "viewModelStore");
+        if (!Intrinsics.areEqual(i5.p, l.w(viewModelStore))) {
+            if (!i5.f8054g.isEmpty()) {
+                throw new IllegalStateException("ViewModelStore should be set before setGraph call");
+            }
+            i5.p = l.w(viewModelStore);
+        }
+        I navController = this.f3454a;
+        Intrinsics.checkNotNull(navController);
+        Intrinsics.checkNotNullParameter(navController, "navHostController");
+        Intrinsics.checkNotNullParameter(navController, "navController");
+        W w3 = navController.f8066v;
+        Context requireContext = requireContext();
+        Intrinsics.checkNotNullExpressionValue(requireContext, "requireContext()");
+        AbstractC0158l0 childFragmentManager = getChildFragmentManager();
+        Intrinsics.checkNotNullExpressionValue(childFragmentManager, "childFragmentManager");
+        w3.a(new DialogFragmentNavigator(requireContext, childFragmentManager));
+        Context requireContext2 = requireContext();
+        Intrinsics.checkNotNullExpressionValue(requireContext2, "requireContext()");
+        AbstractC0158l0 childFragmentManager2 = getChildFragmentManager();
+        Intrinsics.checkNotNullExpressionValue(childFragmentManager2, "childFragmentManager");
+        int id = getId();
+        if (id == 0 || id == -1) {
+            id = R.id.nav_host_fragment_container;
+        }
+        navController.f8066v.a(new FragmentNavigator(requireContext2, childFragmentManager2, id));
+        if (bundle != null) {
+            bundle2 = bundle.getBundle("android-support-nav:fragment:navControllerState");
+            if (bundle.getBoolean("android-support-nav:fragment:defaultHost", false)) {
+                this.f3458e = true;
+                AbstractC0158l0 parentFragmentManager = getParentFragmentManager();
+                parentFragmentManager.getClass();
+                C0135a c0135a = new C0135a(parentFragmentManager);
+                c0135a.i(this);
+                c0135a.e(false);
+            }
+            this.f3457d = bundle.getInt("android-support-nav:fragment:graphId");
+        } else {
+            bundle2 = null;
+        }
+        if (bundle2 != null) {
+            I i6 = this.f3454a;
+            Intrinsics.checkNotNull(i6);
+            bundle2.setClassLoader(i6.f8048a.getClassLoader());
+            i6.f8051d = bundle2.getBundle("android-support-nav:controller:navigatorState");
+            i6.f8052e = bundle2.getParcelableArray("android-support-nav:controller:backStack");
+            LinkedHashMap linkedHashMap = i6.f8058m;
+            linkedHashMap.clear();
+            int[] intArray = bundle2.getIntArray("android-support-nav:controller:backStackDestIds");
+            ArrayList<String> stringArrayList = bundle2.getStringArrayList("android-support-nav:controller:backStackIds");
+            if (intArray != null && stringArrayList != null) {
+                int length = intArray.length;
+                int i7 = 0;
+                int i8 = 0;
+                while (i7 < length) {
+                    i6.f8057l.put(Integer.valueOf(intArray[i7]), stringArrayList.get(i8));
+                    i7++;
+                    i8++;
+                }
+            }
+            ArrayList<String> stringArrayList2 = bundle2.getStringArrayList("android-support-nav:controller:backStackStates");
+            if (stringArrayList2 != null) {
+                for (String id2 : stringArrayList2) {
+                    Parcelable[] parcelableArray = bundle2.getParcelableArray("android-support-nav:controller:backStackStates:" + id2);
+                    if (parcelableArray != null) {
+                        Intrinsics.checkNotNullExpressionValue(id2, "id");
+                        ArrayDeque arrayDeque = new ArrayDeque(parcelableArray.length);
+                        Iterator it = ArrayIteratorKt.iterator(parcelableArray);
+                        while (it.hasNext()) {
+                            Parcelable parcelable = (Parcelable) it.next();
+                            if (parcelable == null) {
+                                throw new NullPointerException("null cannot be cast to non-null type androidx.navigation.NavBackStackEntryState");
+                            }
+                            arrayDeque.add((C0538o) parcelable);
+                        }
+                        linkedHashMap.put(id2, arrayDeque);
+                    }
+                }
+            }
+            i6.f8053f = bundle2.getBoolean("android-support-nav:controller:deepLinkHandled");
+        }
+        if (this.f3457d != 0) {
+            I i9 = this.f3454a;
+            Intrinsics.checkNotNull(i9);
+            i9.w(((J) i9.f8045C.getValue()).b(this.f3457d), null);
+        } else {
+            Bundle arguments = getArguments();
+            int i10 = arguments != null ? arguments.getInt("android-support-nav:fragment:graphId") : 0;
+            Bundle bundle3 = arguments != null ? arguments.getBundle("android-support-nav:fragment:startDestinationArgs") : null;
+            if (i10 != 0) {
+                I i11 = this.f3454a;
+                Intrinsics.checkNotNull(i11);
+                i11.w(((J) i11.f8045C.getValue()).b(i10), bundle3);
+            }
+        }
+        super.onCreate(bundle);
+    }
+
+    @Override // androidx.fragment.app.K
+    public final View onCreateView(LayoutInflater inflater, ViewGroup viewGroup, Bundle bundle) {
+        Intrinsics.checkNotNullParameter(inflater, "inflater");
+        Context context = inflater.getContext();
+        Intrinsics.checkNotNullExpressionValue(context, "inflater.context");
+        FragmentContainerView fragmentContainerView = new FragmentContainerView(context);
+        int id = getId();
+        if (id == 0 || id == -1) {
+            id = R.id.nav_host_fragment_container;
+        }
+        fragmentContainerView.setId(id);
+        return fragmentContainerView;
+    }
+
+    @Override // androidx.fragment.app.K
+    public final void onDestroyView() {
+        super.onDestroyView();
+        View view = this.f3456c;
+        if (view != null && AbstractC0106b.g(view) == this.f3454a) {
+            Intrinsics.checkNotNullParameter(view, "view");
+            view.setTag(R.id.nav_controller_view_tag, null);
+        }
+        this.f3456c = null;
+    }
+
+    @Override // androidx.fragment.app.K
+    public final void onInflate(Context context, AttributeSet attrs, Bundle bundle) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(attrs, "attrs");
+        super.onInflate(context, attrs, bundle);
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attrs, Y.f7970b);
+        Intrinsics.checkNotNullExpressionValue(obtainStyledAttributes, "context.obtainStyledAttr…yleable.NavHost\n        )");
+        int resourceId = obtainStyledAttributes.getResourceId(0, 0);
+        if (resourceId != 0) {
+            this.f3457d = resourceId;
+        }
+        Unit unit = Unit.INSTANCE;
+        obtainStyledAttributes.recycle();
+        TypedArray obtainStyledAttributes2 = context.obtainStyledAttributes(attrs, AbstractC0557d.f8151c);
+        Intrinsics.checkNotNullExpressionValue(obtainStyledAttributes2, "context.obtainStyledAttr…tyleable.NavHostFragment)");
+        if (obtainStyledAttributes2.getBoolean(0, false)) {
+            this.f3458e = true;
+        }
+        obtainStyledAttributes2.recycle();
+    }
+
+    @Override // androidx.fragment.app.K
+    public final void onPrimaryNavigationFragmentChanged(boolean z3) {
+        I i = this.f3454a;
+        if (i == null) {
+            this.f3455b = Boolean.valueOf(z3);
+        } else {
+            i.f8065u = z3;
+            i.z();
+        }
+    }
+
+    @Override // androidx.fragment.app.K
+    public final void onSaveInstanceState(Bundle outState) {
+        Bundle bundle;
+        Intrinsics.checkNotNullParameter(outState, "outState");
+        super.onSaveInstanceState(outState);
+        I i = this.f3454a;
+        Intrinsics.checkNotNull(i);
+        i.getClass();
+        ArrayList<String> arrayList = new ArrayList<>();
+        Bundle bundle2 = new Bundle();
+        for (Map.Entry entry : MapsKt.toMap(i.f8066v.f7967a).entrySet()) {
+            String str = (String) entry.getKey();
+            Bundle h = ((V) entry.getValue()).h();
+            if (h != null) {
+                arrayList.add(str);
+                bundle2.putBundle(str, h);
+            }
+        }
+        if (arrayList.isEmpty()) {
+            bundle = null;
+        } else {
+            bundle = new Bundle();
+            bundle2.putStringArrayList("android-support-nav:controller:navigatorState:names", arrayList);
+            bundle.putBundle("android-support-nav:controller:navigatorState", bundle2);
+        }
+        ArrayDeque arrayDeque = i.f8054g;
+        if (!arrayDeque.isEmpty()) {
+            if (bundle == null) {
+                bundle = new Bundle();
+            }
+            Parcelable[] parcelableArr = new Parcelable[arrayDeque.size()];
+            Iterator<E> it = arrayDeque.iterator();
+            int i4 = 0;
+            while (it.hasNext()) {
+                parcelableArr[i4] = new C0538o((C0537n) it.next());
+                i4++;
+            }
+            bundle.putParcelableArray("android-support-nav:controller:backStack", parcelableArr);
+        }
+        LinkedHashMap linkedHashMap = i.f8057l;
+        if (!linkedHashMap.isEmpty()) {
+            if (bundle == null) {
+                bundle = new Bundle();
+            }
+            int[] iArr = new int[linkedHashMap.size()];
+            ArrayList<String> arrayList2 = new ArrayList<>();
+            int i5 = 0;
+            for (Map.Entry entry2 : linkedHashMap.entrySet()) {
+                int intValue = ((Number) entry2.getKey()).intValue();
+                String str2 = (String) entry2.getValue();
+                iArr[i5] = intValue;
+                arrayList2.add(str2);
+                i5++;
+            }
+            bundle.putIntArray("android-support-nav:controller:backStackDestIds", iArr);
+            bundle.putStringArrayList("android-support-nav:controller:backStackIds", arrayList2);
+        }
+        LinkedHashMap linkedHashMap2 = i.f8058m;
+        if (!linkedHashMap2.isEmpty()) {
+            if (bundle == null) {
+                bundle = new Bundle();
+            }
+            ArrayList<String> arrayList3 = new ArrayList<>();
+            for (Map.Entry entry3 : linkedHashMap2.entrySet()) {
+                String str3 = (String) entry3.getKey();
+                ArrayDeque arrayDeque2 = (ArrayDeque) entry3.getValue();
+                arrayList3.add(str3);
+                Parcelable[] parcelableArr2 = new Parcelable[arrayDeque2.size()];
+                Iterator<E> it2 = arrayDeque2.iterator();
+                int i6 = 0;
+                while (it2.hasNext()) {
+                    Object next = it2.next();
+                    int i7 = i6 + 1;
+                    if (i6 < 0) {
+                        CollectionsKt.throwIndexOverflow();
+                    }
+                    parcelableArr2[i6] = (C0538o) next;
+                    i6 = i7;
+                }
+                bundle.putParcelableArray(w.z("android-support-nav:controller:backStackStates:", str3), parcelableArr2);
+            }
+            bundle.putStringArrayList("android-support-nav:controller:backStackStates", arrayList3);
+        }
+        if (i.f8053f) {
+            if (bundle == null) {
+                bundle = new Bundle();
+            }
+            bundle.putBoolean("android-support-nav:controller:deepLinkHandled", i.f8053f);
+        }
+        if (bundle != null) {
+            outState.putBundle("android-support-nav:fragment:navControllerState", bundle);
+        }
+        if (this.f3458e) {
+            outState.putBoolean("android-support-nav:fragment:defaultHost", true);
+        }
+        int i8 = this.f3457d;
+        if (i8 != 0) {
+            outState.putInt("android-support-nav:fragment:graphId", i8);
+        }
+    }
+
+    @Override // androidx.fragment.app.K
+    public final void onViewCreated(View view, Bundle bundle) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        super.onViewCreated(view, bundle);
+        if (!(view instanceof ViewGroup)) {
+            throw new IllegalStateException(("created host view " + view + " is not a ViewGroup").toString());
+        }
+        I i = this.f3454a;
+        Intrinsics.checkNotNullParameter(view, "view");
+        view.setTag(R.id.nav_controller_view_tag, i);
+        if (view.getParent() != null) {
+            Object parent = view.getParent();
+            if (parent == null) {
+                throw new NullPointerException("null cannot be cast to non-null type android.view.View");
+            }
+            View view2 = (View) parent;
+            this.f3456c = view2;
+            Intrinsics.checkNotNull(view2);
+            if (view2.getId() == getId()) {
+                View view3 = this.f3456c;
+                Intrinsics.checkNotNull(view3);
+                I i4 = this.f3454a;
+                Intrinsics.checkNotNullParameter(view3, "view");
+                view3.setTag(R.id.nav_controller_view_tag, i4);
+            }
+        }
+    }
+}