Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/androidx/viewpager2/adapter/a.java

@@ -0,0 +1,19 @@
+package androidx.viewpager2.adapter;
+
+/* loaded from: classes.dex */
+public final class a implements Runnable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ f f4068a;
+
+    public a(f fVar) {
+        this.f4068a = fVar;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        f fVar = this.f4068a;
+        fVar.mIsInGracePeriod = false;
+        fVar.gcFragments();
+    }
+}

apk_decompiled/sources/androidx/viewpager2/adapter/b.java

@@ -0,0 +1,20 @@
+package androidx.viewpager2.adapter;
+
+import C.w;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/* loaded from: classes.dex */
+public final class b {
+
+    /* renamed from: a, reason: collision with root package name */
+    public CopyOnWriteArrayList f4069a;
+
+    public static void a(List list) {
+        Iterator it = list.iterator();
+        if (it.hasNext()) {
+            throw w.g(it);
+        }
+    }
+}

apk_decompiled/sources/androidx/viewpager2/adapter/c.java

@@ -0,0 +1,21 @@
+package androidx.viewpager2.adapter;
+
+import androidx.lifecycle.A;
+import androidx.lifecycle.H;
+import androidx.lifecycle.J;
+
+/* loaded from: classes.dex */
+public final class c implements H {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ d f4070a;
+
+    public c(d dVar) {
+        this.f4070a = dVar;
+    }
+
+    @Override // androidx.lifecycle.H
+    public final void onStateChanged(J j4, A a2) {
+        this.f4070a.b(false);
+    }
+}

apk_decompiled/sources/androidx/viewpager2/adapter/d.java

@@ -0,0 +1,113 @@
+package androidx.viewpager2.adapter;
+
+import C.w;
+import H2.m;
+import android.view.ViewParent;
+import androidx.fragment.app.AbstractC0158l0;
+import androidx.fragment.app.C0135a;
+import androidx.fragment.app.K;
+import androidx.lifecycle.B;
+import androidx.recyclerview.widget.RecyclerView;
+import androidx.viewpager2.widget.ViewPager2;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class d {
+
+    /* renamed from: a, reason: collision with root package name */
+    public H0.b f4071a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public m f4072b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public c f4073c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public ViewPager2 f4074d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public long f4075e = -1;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ f f4076f;
+
+    public d(f fVar) {
+        this.f4076f = fVar;
+    }
+
+    public static ViewPager2 a(RecyclerView recyclerView) {
+        ViewParent parent = recyclerView.getParent();
+        if (parent instanceof ViewPager2) {
+            return (ViewPager2) parent;
+        }
+        throw new IllegalStateException("Expected ViewPager2 instance. Got: " + parent);
+    }
+
+    public final void b(boolean z3) {
+        int currentItem;
+        K k4;
+        f fVar = this.f4076f;
+        if (fVar.shouldDelayFragmentTransactions() || this.f4074d.getScrollState() != 0 || fVar.mFragments.g() == 0 || fVar.getItemCount() == 0 || (currentItem = this.f4074d.getCurrentItem()) >= fVar.getItemCount()) {
+            return;
+        }
+        long itemId = fVar.getItemId(currentItem);
+        if ((itemId != this.f4075e || z3) && (k4 = (K) fVar.mFragments.b(itemId)) != null && k4.isAdded()) {
+            this.f4075e = itemId;
+            AbstractC0158l0 abstractC0158l0 = fVar.mFragmentManager;
+            abstractC0158l0.getClass();
+            C0135a c0135a = new C0135a(abstractC0158l0);
+            ArrayList arrayList = new ArrayList();
+            K k5 = null;
+            for (int i = 0; i < fVar.mFragments.g(); i++) {
+                long d4 = fVar.mFragments.d(i);
+                K k6 = (K) fVar.mFragments.h(i);
+                if (k6.isAdded()) {
+                    if (d4 != this.f4075e) {
+                        c0135a.h(k6, B.f3283d);
+                        b bVar = fVar.mFragmentEventDispatcher;
+                        bVar.getClass();
+                        ArrayList arrayList2 = new ArrayList();
+                        Iterator it = bVar.f4069a.iterator();
+                        if (it.hasNext()) {
+                            throw w.g(it);
+                        }
+                        arrayList.add(arrayList2);
+                    } else {
+                        k5 = k6;
+                    }
+                    k6.setMenuVisibility(d4 == this.f4075e);
+                }
+            }
+            if (k5 != null) {
+                c0135a.h(k5, B.f3284e);
+                b bVar2 = fVar.mFragmentEventDispatcher;
+                bVar2.getClass();
+                ArrayList arrayList3 = new ArrayList();
+                Iterator it2 = bVar2.f4069a.iterator();
+                if (it2.hasNext()) {
+                    throw w.g(it2);
+                }
+                arrayList.add(arrayList3);
+            }
+            if (c0135a.f3257a.isEmpty()) {
+                return;
+            }
+            if (c0135a.f3263g) {
+                throw new IllegalStateException("This transaction is already being added to the back stack");
+            }
+            c0135a.h = false;
+            c0135a.f3084q.B(c0135a, false);
+            Collections.reverse(arrayList);
+            Iterator it3 = arrayList.iterator();
+            while (it3.hasNext()) {
+                List list = (List) it3.next();
+                fVar.mFragmentEventDispatcher.getClass();
+                b.a(list);
+            }
+        }
+    }
+}

apk_decompiled/sources/androidx/viewpager2/adapter/e.java

@@ -0,0 +1,5 @@
+package androidx.viewpager2.adapter;
+
+/* loaded from: classes.dex */
+public abstract class e {
+}

apk_decompiled/sources/androidx/viewpager2/adapter/f.java

@@ -0,0 +1,511 @@
+package androidx.viewpager2.adapter;
+
+import C.w;
+import H2.m;
+import O.X;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.widget.FrameLayout;
+import androidx.fragment.app.AbstractC0158l0;
+import androidx.fragment.app.C0135a;
+import androidx.fragment.app.J;
+import androidx.fragment.app.K;
+import androidx.fragment.app.Q;
+import androidx.fragment.app.Y;
+import androidx.lifecycle.B;
+import androidx.lifecycle.C;
+import androidx.lifecycle.C0194o;
+import androidx.recyclerview.widget.AbstractC0220h0;
+import androidx.recyclerview.widget.I0;
+import androidx.recyclerview.widget.RecyclerView;
+import androidx.viewpager2.widget.ViewPager2;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.WeakHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import kotlin.jvm.internal.Intrinsics;
+import s.C0581a;
+
+/* loaded from: classes.dex */
+public abstract class f extends AbstractC0220h0 {
+    private static final long GRACE_WINDOW_TIME_MS = 10000;
+    private static final String KEY_PREFIX_FRAGMENT = "f#";
+    private static final String KEY_PREFIX_STATE = "s#";
+    b mFragmentEventDispatcher;
+    final AbstractC0158l0 mFragmentManager;
+    private d mFragmentMaxLifecycleEnforcer;
+    final s.g mFragments;
+    private boolean mHasStaleFragments;
+    boolean mIsInGracePeriod;
+    private final s.g mItemIdToViewHolder;
+    final C mLifecycle;
+    private final s.g mSavedStates;
+
+    /* JADX WARN: Type inference failed for: r1v3, types: [java.lang.Object, androidx.viewpager2.adapter.b] */
+    public f(K k4) {
+        AbstractC0158l0 childFragmentManager = k4.getChildFragmentManager();
+        C lifecycle = k4.getLifecycle();
+        this.mFragments = new s.g();
+        this.mSavedStates = new s.g();
+        this.mItemIdToViewHolder = new s.g();
+        ?? obj = new Object();
+        obj.f4069a = new CopyOnWriteArrayList();
+        this.mFragmentEventDispatcher = obj;
+        this.mIsInGracePeriod = false;
+        this.mHasStaleFragments = false;
+        this.mFragmentManager = childFragmentManager;
+        this.mLifecycle = lifecycle;
+        super.setHasStableIds(true);
+    }
+
+    public final Long a(int i) {
+        Long l4 = null;
+        for (int i4 = 0; i4 < this.mItemIdToViewHolder.g(); i4++) {
+            if (((Integer) this.mItemIdToViewHolder.h(i4)).intValue() == i) {
+                if (l4 != null) {
+                    throw new IllegalStateException("Design assumption violated: a ViewHolder can only be bound to one item at a time.");
+                }
+                l4 = Long.valueOf(this.mItemIdToViewHolder.d(i4));
+            }
+        }
+        return l4;
+    }
+
+    public void addViewToContainer(View view, FrameLayout frameLayout) {
+        if (frameLayout.getChildCount() > 1) {
+            throw new IllegalStateException("Design assumption violated.");
+        }
+        if (view.getParent() == frameLayout) {
+            return;
+        }
+        if (frameLayout.getChildCount() > 0) {
+            frameLayout.removeAllViews();
+        }
+        if (view.getParent() != null) {
+            ((ViewGroup) view.getParent()).removeView(view);
+        }
+        frameLayout.addView(view);
+    }
+
+    public final void b(long j4) {
+        ViewParent parent;
+        K k4 = (K) this.mFragments.b(j4);
+        if (k4 == null) {
+            return;
+        }
+        if (k4.getView() != null && (parent = k4.getView().getParent()) != null) {
+            ((FrameLayout) parent).removeAllViews();
+        }
+        if (!containsItem(j4)) {
+            this.mSavedStates.f(j4);
+        }
+        if (!k4.isAdded()) {
+            this.mFragments.f(j4);
+            return;
+        }
+        if (shouldDelayFragmentTransactions()) {
+            this.mHasStaleFragments = true;
+            return;
+        }
+        if (k4.isAdded() && containsItem(j4)) {
+            b bVar = this.mFragmentEventDispatcher;
+            bVar.getClass();
+            ArrayList arrayList = new ArrayList();
+            Iterator it = bVar.f4069a.iterator();
+            if (it.hasNext()) {
+                throw w.g(it);
+            }
+            J b02 = this.mFragmentManager.b0(k4);
+            this.mFragmentEventDispatcher.getClass();
+            b.a(arrayList);
+            this.mSavedStates.e(j4, b02);
+        }
+        b bVar2 = this.mFragmentEventDispatcher;
+        bVar2.getClass();
+        ArrayList arrayList2 = new ArrayList();
+        Iterator it2 = bVar2.f4069a.iterator();
+        if (it2.hasNext()) {
+            throw w.g(it2);
+        }
+        try {
+            AbstractC0158l0 abstractC0158l0 = this.mFragmentManager;
+            abstractC0158l0.getClass();
+            C0135a c0135a = new C0135a(abstractC0158l0);
+            c0135a.g(k4);
+            if (c0135a.f3263g) {
+                throw new IllegalStateException("This transaction is already being added to the back stack");
+            }
+            c0135a.h = false;
+            c0135a.f3084q.B(c0135a, false);
+            this.mFragments.f(j4);
+        } finally {
+            this.mFragmentEventDispatcher.getClass();
+            b.a(arrayList2);
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r1v0, types: [java.lang.Object, R0.h] */
+    public final void c(K k4, FrameLayout frameLayout) {
+        AbstractC0158l0 abstractC0158l0 = this.mFragmentManager;
+        ?? cb = new Object();
+        cb.f1415c = this;
+        cb.f1413a = k4;
+        cb.f1414b = frameLayout;
+        Q q4 = abstractC0158l0.f3170o;
+        q4.getClass();
+        Intrinsics.checkNotNullParameter(cb, "cb");
+        ((CopyOnWriteArrayList) q4.f3067b).add(new Y(cb));
+    }
+
+    public boolean containsItem(long j4) {
+        return j4 >= 0 && j4 < ((long) getItemCount());
+    }
+
+    public abstract K createFragment(int i);
+
+    public void gcFragments() {
+        K k4;
+        View view;
+        if (!this.mHasStaleFragments || shouldDelayFragmentTransactions()) {
+            return;
+        }
+        s.f fVar = new s.f(0);
+        for (int i = 0; i < this.mFragments.g(); i++) {
+            long d4 = this.mFragments.d(i);
+            if (!containsItem(d4)) {
+                fVar.add(Long.valueOf(d4));
+                this.mItemIdToViewHolder.f(d4);
+            }
+        }
+        if (!this.mIsInGracePeriod) {
+            this.mHasStaleFragments = false;
+            for (int i4 = 0; i4 < this.mFragments.g(); i4++) {
+                long d5 = this.mFragments.d(i4);
+                if (this.mItemIdToViewHolder.c(d5) < 0 && ((k4 = (K) this.mFragments.b(d5)) == null || (view = k4.getView()) == null || view.getParent() == null)) {
+                    fVar.add(Long.valueOf(d5));
+                }
+            }
+        }
+        C0581a c0581a = new C0581a(fVar);
+        while (c0581a.hasNext()) {
+            b(((Long) c0581a.next()).longValue());
+        }
+    }
+
+    @Override // androidx.recyclerview.widget.AbstractC0220h0
+    public long getItemId(int i) {
+        return i;
+    }
+
+    @Override // androidx.recyclerview.widget.AbstractC0220h0
+    public void onAttachedToRecyclerView(RecyclerView recyclerView) {
+        if (this.mFragmentMaxLifecycleEnforcer != null) {
+            throw new IllegalArgumentException();
+        }
+        d dVar = new d(this);
+        this.mFragmentMaxLifecycleEnforcer = dVar;
+        ViewPager2 a2 = d.a(recyclerView);
+        dVar.f4074d = a2;
+        H0.b bVar = new H0.b(dVar);
+        dVar.f4071a = bVar;
+        ((ArrayList) a2.f4080c.f632b).add(bVar);
+        m mVar = new m(dVar, 2);
+        dVar.f4072b = mVar;
+        registerAdapterDataObserver(mVar);
+        c cVar = new c(dVar);
+        dVar.f4073c = cVar;
+        this.mLifecycle.a(cVar);
+    }
+
+    @Override // androidx.recyclerview.widget.AbstractC0220h0
+    public void onDetachedFromRecyclerView(RecyclerView recyclerView) {
+        d dVar = this.mFragmentMaxLifecycleEnforcer;
+        dVar.getClass();
+        ViewPager2 a2 = d.a(recyclerView);
+        ((ArrayList) a2.f4080c.f632b).remove(dVar.f4071a);
+        m mVar = dVar.f4072b;
+        f fVar = dVar.f4076f;
+        fVar.unregisterAdapterDataObserver(mVar);
+        fVar.mLifecycle.c(dVar.f4073c);
+        dVar.f4074d = null;
+        this.mFragmentMaxLifecycleEnforcer = null;
+    }
+
+    @Override // androidx.recyclerview.widget.AbstractC0220h0
+    public final boolean onFailedToRecycleView(g gVar) {
+        return true;
+    }
+
+    @Override // androidx.recyclerview.widget.AbstractC0220h0
+    public final void onViewRecycled(g gVar) {
+        Long a2 = a(((FrameLayout) gVar.itemView).getId());
+        if (a2 != null) {
+            b(a2.longValue());
+            this.mItemIdToViewHolder.f(a2.longValue());
+        }
+    }
+
+    public void placeFragmentInViewHolder(g gVar) {
+        K k4 = (K) this.mFragments.b(gVar.getItemId());
+        if (k4 == null) {
+            throw new IllegalStateException("Design assumption violated.");
+        }
+        FrameLayout frameLayout = (FrameLayout) gVar.itemView;
+        View view = k4.getView();
+        if (!k4.isAdded() && view != null) {
+            throw new IllegalStateException("Design assumption violated.");
+        }
+        if (k4.isAdded() && view == null) {
+            c(k4, frameLayout);
+            return;
+        }
+        if (k4.isAdded() && view.getParent() != null) {
+            if (view.getParent() != frameLayout) {
+                addViewToContainer(view, frameLayout);
+                return;
+            }
+            return;
+        }
+        if (k4.isAdded()) {
+            addViewToContainer(view, frameLayout);
+            return;
+        }
+        if (shouldDelayFragmentTransactions()) {
+            if (this.mFragmentManager.J) {
+                return;
+            }
+            this.mLifecycle.a(new C0194o(this, gVar));
+            return;
+        }
+        c(k4, frameLayout);
+        b bVar = this.mFragmentEventDispatcher;
+        bVar.getClass();
+        ArrayList arrayList = new ArrayList();
+        Iterator it = bVar.f4069a.iterator();
+        if (it.hasNext()) {
+            throw w.g(it);
+        }
+        try {
+            k4.setMenuVisibility(false);
+            AbstractC0158l0 abstractC0158l0 = this.mFragmentManager;
+            abstractC0158l0.getClass();
+            C0135a c0135a = new C0135a(abstractC0158l0);
+            c0135a.c(0, k4, "f" + gVar.getItemId(), 1);
+            c0135a.h(k4, B.f3283d);
+            if (c0135a.f3263g) {
+                throw new IllegalStateException("This transaction is already being added to the back stack");
+            }
+            c0135a.h = false;
+            c0135a.f3084q.B(c0135a, false);
+            this.mFragmentMaxLifecycleEnforcer.b(false);
+        } finally {
+            this.mFragmentEventDispatcher.getClass();
+            b.a(arrayList);
+        }
+    }
+
+    public void registerFragmentTransactionCallback(e eVar) {
+        this.mFragmentEventDispatcher.f4069a.add(eVar);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:30:0x00c2, code lost:
+    
+        throw new java.lang.IllegalArgumentException("Unexpected key in savedState: ".concat(r1));
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void restoreState(android.os.Parcelable r9) {
+        /*
+            r8 = this;
+            s.g r0 = r8.mSavedStates
+            int r0 = r0.g()
+            if (r0 != 0) goto Lf2
+            s.g r0 = r8.mFragments
+            int r0 = r0.g()
+            if (r0 != 0) goto Lf2
+            android.os.Bundle r9 = (android.os.Bundle) r9
+            java.lang.ClassLoader r0 = r9.getClassLoader()
+            if (r0 != 0) goto L23
+            java.lang.Class r0 = r8.getClass()
+            java.lang.ClassLoader r0 = r0.getClassLoader()
+            r9.setClassLoader(r0)
+        L23:
+            java.util.Set r0 = r9.keySet()
+            java.util.Iterator r0 = r0.iterator()
+        L2b:
+            boolean r1 = r0.hasNext()
+            r2 = 1
+            if (r1 == 0) goto Lc3
+            java.lang.Object r1 = r0.next()
+            java.lang.String r1 = (java.lang.String) r1
+            java.lang.String r3 = "f#"
+            boolean r3 = r1.startsWith(r3)
+            r4 = 2
+            if (r3 == 0) goto L48
+            int r3 = r1.length()
+            if (r3 <= r4) goto L48
+            goto L49
+        L48:
+            r2 = 0
+        L49:
+            if (r2 == 0) goto L8e
+            java.lang.String r2 = r1.substring(r4)
+            long r2 = java.lang.Long.parseLong(r2)
+            androidx.fragment.app.l0 r4 = r8.mFragmentManager
+            r4.getClass()
+            java.lang.String r5 = r9.getString(r1)
+            r6 = 0
+            if (r5 != 0) goto L60
+            goto L69
+        L60:
+            androidx.fragment.app.u0 r7 = r4.f3160c
+            androidx.fragment.app.K r7 = r7.b(r5)
+            if (r7 == 0) goto L6f
+            r6 = r7
+        L69:
+            s.g r1 = r8.mFragments
+            r1.e(r2, r6)
+            goto L2b
+        L6f:
+            java.lang.IllegalStateException r8 = new java.lang.IllegalStateException
+            java.lang.StringBuilder r9 = new java.lang.StringBuilder
+            java.lang.String r0 = "Fragment no longer exists for key "
+            r9.<init>(r0)
+            r9.append(r1)
+            java.lang.String r0 = ": unique id "
+            r9.append(r0)
+            r9.append(r5)
+            java.lang.String r9 = r9.toString()
+            r8.<init>(r9)
+            r4.j0(r8)
+            throw r6
+        L8e:
+            java.lang.String r2 = "s#"
+            boolean r2 = r1.startsWith(r2)
+            if (r2 == 0) goto Lb7
+            int r2 = r1.length()
+            if (r2 <= r4) goto Lb7
+            java.lang.String r2 = r1.substring(r4)
+            long r2 = java.lang.Long.parseLong(r2)
+            android.os.Parcelable r1 = r9.getParcelable(r1)
+            androidx.fragment.app.J r1 = (androidx.fragment.app.J) r1
+            boolean r4 = r8.containsItem(r2)
+            if (r4 == 0) goto L2b
+            s.g r4 = r8.mSavedStates
+            r4.e(r2, r1)
+            goto L2b
+        Lb7:
+            java.lang.IllegalArgumentException r8 = new java.lang.IllegalArgumentException
+            java.lang.String r9 = "Unexpected key in savedState: "
+            java.lang.String r9 = r9.concat(r1)
+            r8.<init>(r9)
+            throw r8
+        Lc3:
+            s.g r9 = r8.mFragments
+            int r9 = r9.g()
+            if (r9 != 0) goto Lcc
+            return
+        Lcc:
+            r8.mHasStaleFragments = r2
+            r8.mIsInGracePeriod = r2
+            r8.gcFragments()
+            android.os.Handler r9 = new android.os.Handler
+            android.os.Looper r0 = android.os.Looper.getMainLooper()
+            r9.<init>(r0)
+            androidx.viewpager2.adapter.a r0 = new androidx.viewpager2.adapter.a
+            r0.<init>(r8)
+            androidx.lifecycle.C r8 = r8.mLifecycle
+            androidx.lifecycle.o r1 = new androidx.lifecycle.o
+            r2 = 4
+            r1.<init>(r2, r9, r0)
+            r8.a(r1)
+            r1 = 10000(0x2710, double:4.9407E-320)
+            r9.postDelayed(r0, r1)
+            return
+        Lf2:
+            java.lang.IllegalStateException r8 = new java.lang.IllegalStateException
+            java.lang.String r9 = "Expected the adapter to be 'fresh' while restoring state."
+            r8.<init>(r9)
+            throw r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.viewpager2.adapter.f.restoreState(android.os.Parcelable):void");
+    }
+
+    public final Parcelable saveState() {
+        Bundle bundle = new Bundle(this.mSavedStates.g() + this.mFragments.g());
+        for (int i = 0; i < this.mFragments.g(); i++) {
+            long d4 = this.mFragments.d(i);
+            K k4 = (K) this.mFragments.b(d4);
+            if (k4 != null && k4.isAdded()) {
+                this.mFragmentManager.W(bundle, w.l(KEY_PREFIX_FRAGMENT, d4), k4);
+            }
+        }
+        for (int i4 = 0; i4 < this.mSavedStates.g(); i4++) {
+            long d5 = this.mSavedStates.d(i4);
+            if (containsItem(d5)) {
+                bundle.putParcelable(w.l(KEY_PREFIX_STATE, d5), (Parcelable) this.mSavedStates.b(d5));
+            }
+        }
+        return bundle;
+    }
+
+    @Override // androidx.recyclerview.widget.AbstractC0220h0
+    public final void setHasStableIds(boolean z3) {
+        throw new UnsupportedOperationException("Stable Ids are required for the adapter to function properly, and the adapter takes care of setting the flag.");
+    }
+
+    public boolean shouldDelayFragmentTransactions() {
+        return this.mFragmentManager.Q();
+    }
+
+    public void unregisterFragmentTransactionCallback(e eVar) {
+        this.mFragmentEventDispatcher.f4069a.remove(eVar);
+    }
+
+    @Override // androidx.recyclerview.widget.AbstractC0220h0
+    public final void onBindViewHolder(g gVar, int i) {
+        long itemId = gVar.getItemId();
+        int id = ((FrameLayout) gVar.itemView).getId();
+        Long a2 = a(id);
+        if (a2 != null && a2.longValue() != itemId) {
+            b(a2.longValue());
+            this.mItemIdToViewHolder.f(a2.longValue());
+        }
+        this.mItemIdToViewHolder.e(itemId, Integer.valueOf(id));
+        long itemId2 = getItemId(i);
+        if (this.mFragments.c(itemId2) < 0) {
+            K createFragment = createFragment(i);
+            createFragment.setInitialSavedState((J) this.mSavedStates.b(itemId2));
+            this.mFragments.e(itemId2, createFragment);
+        }
+        FrameLayout frameLayout = (FrameLayout) gVar.itemView;
+        WeakHashMap weakHashMap = X.f1226a;
+        if (frameLayout.isAttachedToWindow()) {
+            placeFragmentInViewHolder(gVar);
+        }
+        gcFragments();
+    }
+
+    /* JADX WARN: Type inference failed for: r1v6, types: [androidx.recyclerview.widget.I0, androidx.viewpager2.adapter.g] */
+    @Override // androidx.recyclerview.widget.AbstractC0220h0
+    public final g onCreateViewHolder(ViewGroup viewGroup, int i) {
+        int i4 = g.f4077a;
+        FrameLayout frameLayout = new FrameLayout(viewGroup.getContext());
+        frameLayout.setLayoutParams(new ViewGroup.LayoutParams(-1, -1));
+        WeakHashMap weakHashMap = X.f1226a;
+        frameLayout.setId(View.generateViewId());
+        frameLayout.setSaveEnabled(false);
+        return new I0(frameLayout);
+    }
+
+    @Override // androidx.recyclerview.widget.AbstractC0220h0
+    public final void onViewAttachedToWindow(g gVar) {
+        placeFragmentInViewHolder(gVar);
+        gcFragments();
+    }
+}

apk_decompiled/sources/androidx/viewpager2/adapter/g.java

@@ -0,0 +1,10 @@
+package androidx.viewpager2.adapter;
+
+import androidx.recyclerview.widget.I0;
+
+/* loaded from: classes.dex */
+public final class g extends I0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final /* synthetic */ int f4077a = 0;
+}

apk_decompiled/sources/androidx/viewpager2/widget/ViewPager2.java

@@ -0,0 +1,517 @@
+package androidx.viewpager2.widget;
+
+import A.a;
+import A.j;
+import H0.b;
+import H0.c;
+import H0.d;
+import H0.e;
+import H0.f;
+import H0.g;
+import H0.i;
+import H0.k;
+import H0.l;
+import H0.m;
+import H0.n;
+import H0.o;
+import H0.p;
+import O.S;
+import O.X;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Rect;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.util.AttributeSet;
+import android.util.SparseArray;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityNodeInfo;
+import androidx.recyclerview.widget.AbstractC0220h0;
+import androidx.recyclerview.widget.AbstractC0230m0;
+import androidx.recyclerview.widget.AbstractC0238q0;
+import java.util.ArrayList;
+import java.util.WeakHashMap;
+import kotlin.io.ConstantsKt;
+
+/* loaded from: classes.dex */
+public final class ViewPager2 extends ViewGroup {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Rect f4078a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Rect f4079b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final b f4080c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public int f4081d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public boolean f4082e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final f f4083f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final i f4084g;
+    public int h;
+    public Parcelable i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public final n f4085j;
+
+    /* renamed from: k, reason: collision with root package name */
+    public final m f4086k;
+
+    /* renamed from: l, reason: collision with root package name */
+    public final e f4087l;
+
+    /* renamed from: m, reason: collision with root package name */
+    public final b f4088m;
+
+    /* renamed from: n, reason: collision with root package name */
+    public final a f4089n;
+
+    /* renamed from: o, reason: collision with root package name */
+    public final c f4090o;
+    public AbstractC0230m0 p;
+
+    /* renamed from: q, reason: collision with root package name */
+    public boolean f4091q;
+
+    /* renamed from: r, reason: collision with root package name */
+    public boolean f4092r;
+
+    /* renamed from: s, reason: collision with root package name */
+    public int f4093s;
+
+    /* renamed from: t, reason: collision with root package name */
+    public final j f4094t;
+
+    /* JADX WARN: Type inference failed for: r12v21, types: [java.lang.Object, H0.c] */
+    /* JADX WARN: Type inference failed for: r4v0, types: [java.lang.Object, A.j] */
+    public ViewPager2(Context context, AttributeSet attributeSet) {
+        super(context, attributeSet);
+        this.f4078a = new Rect();
+        this.f4079b = new Rect();
+        b bVar = new b();
+        this.f4080c = bVar;
+        int i = 0;
+        this.f4082e = false;
+        this.f4083f = new f(this, i);
+        this.h = -1;
+        this.p = null;
+        this.f4091q = false;
+        int i4 = 1;
+        this.f4092r = true;
+        this.f4093s = -1;
+        ?? obj = new Object();
+        obj.f30d = this;
+        obj.f27a = new k(obj, i);
+        obj.f28b = new k(obj, i4);
+        this.f4094t = obj;
+        n nVar = new n(this, context);
+        this.f4085j = nVar;
+        WeakHashMap weakHashMap = X.f1226a;
+        nVar.setId(View.generateViewId());
+        this.f4085j.setDescendantFocusability(131072);
+        i iVar = new i(this);
+        this.f4084g = iVar;
+        this.f4085j.setLayoutManager(iVar);
+        this.f4085j.setScrollingTouchSlop(1);
+        int[] iArr = G0.a.f567a;
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, iArr);
+        S.d(this, context, iArr, attributeSet, obtainStyledAttributes, 0, 0);
+        try {
+            setOrientation(obtainStyledAttributes.getInt(0, 0));
+            obtainStyledAttributes.recycle();
+            this.f4085j.setLayoutParams(new ViewGroup.LayoutParams(-1, -1));
+            n nVar2 = this.f4085j;
+            Object obj2 = new Object();
+            if (nVar2.f3652C == null) {
+                nVar2.f3652C = new ArrayList();
+            }
+            nVar2.f3652C.add(obj2);
+            e eVar = new e(this);
+            this.f4087l = eVar;
+            this.f4089n = new a(eVar, 5);
+            m mVar = new m(this);
+            this.f4086k = mVar;
+            mVar.a(this.f4085j);
+            this.f4085j.k(this.f4087l);
+            b bVar2 = new b();
+            this.f4088m = bVar2;
+            this.f4087l.f636a = bVar2;
+            g gVar = new g(this, i);
+            g gVar2 = new g(this, i4);
+            ((ArrayList) bVar2.f632b).add(gVar);
+            ((ArrayList) this.f4088m.f632b).add(gVar2);
+            j jVar = this.f4094t;
+            n nVar3 = this.f4085j;
+            jVar.getClass();
+            nVar3.setImportantForAccessibility(2);
+            jVar.f29c = new f(jVar, i4);
+            ViewPager2 viewPager2 = (ViewPager2) jVar.f30d;
+            if (viewPager2.getImportantForAccessibility() == 0) {
+                viewPager2.setImportantForAccessibility(1);
+            }
+            ((ArrayList) this.f4088m.f632b).add(bVar);
+            ?? obj3 = new Object();
+            this.f4090o = obj3;
+            ((ArrayList) this.f4088m.f632b).add(obj3);
+            n nVar4 = this.f4085j;
+            attachViewToParent(nVar4, 0, nVar4.getLayoutParams());
+        } catch (Throwable th) {
+            obtainStyledAttributes.recycle();
+            throw th;
+        }
+    }
+
+    public final void a() {
+        AbstractC0220h0 adapter;
+        if (this.h == -1 || (adapter = getAdapter()) == null) {
+            return;
+        }
+        Parcelable parcelable = this.i;
+        if (parcelable != null) {
+            if (adapter instanceof androidx.viewpager2.adapter.f) {
+                ((androidx.viewpager2.adapter.f) adapter).restoreState(parcelable);
+            }
+            this.i = null;
+        }
+        int max = Math.max(0, Math.min(this.h, adapter.getItemCount() - 1));
+        this.f4081d = max;
+        this.h = -1;
+        this.f4085j.j0(max);
+        this.f4094t.q();
+    }
+
+    public final void b(int i) {
+        Object obj = this.f4089n.f7b;
+        c(i);
+    }
+
+    public final void c(int i) {
+        AbstractC0220h0 adapter = getAdapter();
+        if (adapter == null) {
+            if (this.h != -1) {
+                this.h = Math.max(i, 0);
+                return;
+            }
+            return;
+        }
+        if (adapter.getItemCount() <= 0) {
+            return;
+        }
+        int min = Math.min(Math.max(i, 0), adapter.getItemCount() - 1);
+        int i4 = this.f4081d;
+        if ((min == i4 && this.f4087l.f641f == 0) || min == i4) {
+            return;
+        }
+        double d4 = i4;
+        this.f4081d = min;
+        this.f4094t.q();
+        e eVar = this.f4087l;
+        if (eVar.f641f != 0) {
+            eVar.d();
+            d dVar = eVar.f642g;
+            d4 = dVar.f633a + dVar.f634b;
+        }
+        e eVar2 = this.f4087l;
+        eVar2.getClass();
+        eVar2.f640e = 2;
+        boolean z3 = eVar2.i != min;
+        eVar2.i = min;
+        eVar2.b(2);
+        if (z3) {
+            eVar2.a(min);
+        }
+        double d5 = min;
+        if (Math.abs(d5 - d4) <= 3.0d) {
+            this.f4085j.m0(min);
+            return;
+        }
+        this.f4085j.j0(d5 > d4 ? min - 3 : min + 3);
+        n nVar = this.f4085j;
+        nVar.post(new p(min, nVar));
+    }
+
+    @Override // android.view.View
+    public final boolean canScrollHorizontally(int i) {
+        return this.f4085j.canScrollHorizontally(i);
+    }
+
+    @Override // android.view.View
+    public final boolean canScrollVertically(int i) {
+        return this.f4085j.canScrollVertically(i);
+    }
+
+    public final void d() {
+        m mVar = this.f4086k;
+        if (mVar == null) {
+            throw new IllegalStateException("Design assumption violated.");
+        }
+        View e4 = mVar.e(this.f4084g);
+        if (e4 == null) {
+            return;
+        }
+        this.f4084g.getClass();
+        int L3 = AbstractC0238q0.L(e4);
+        if (L3 != this.f4081d && getScrollState() == 0) {
+            this.f4088m.c(L3);
+        }
+        this.f4082e = false;
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    public final void dispatchRestoreInstanceState(SparseArray sparseArray) {
+        Parcelable parcelable = (Parcelable) sparseArray.get(getId());
+        if (parcelable instanceof o) {
+            int i = ((o) parcelable).f655a;
+            sparseArray.put(this.f4085j.getId(), (Parcelable) sparseArray.get(i));
+            sparseArray.remove(i);
+        }
+        super.dispatchRestoreInstanceState(sparseArray);
+        a();
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    public CharSequence getAccessibilityClassName() {
+        this.f4094t.getClass();
+        this.f4094t.getClass();
+        return "androidx.viewpager.widget.ViewPager";
+    }
+
+    public AbstractC0220h0 getAdapter() {
+        return this.f4085j.getAdapter();
+    }
+
+    public int getCurrentItem() {
+        return this.f4081d;
+    }
+
+    public int getItemDecorationCount() {
+        return this.f4085j.getItemDecorationCount();
+    }
+
+    public int getOffscreenPageLimit() {
+        return this.f4093s;
+    }
+
+    public int getOrientation() {
+        return this.f4084g.p == 1 ? 1 : 0;
+    }
+
+    public int getPageSize() {
+        int height;
+        int paddingBottom;
+        n nVar = this.f4085j;
+        if (getOrientation() == 0) {
+            height = nVar.getWidth() - nVar.getPaddingLeft();
+            paddingBottom = nVar.getPaddingRight();
+        } else {
+            height = nVar.getHeight() - nVar.getPaddingTop();
+            paddingBottom = nVar.getPaddingBottom();
+        }
+        return height - paddingBottom;
+    }
+
+    public int getScrollState() {
+        return this.f4087l.f641f;
+    }
+
+    @Override // android.view.View
+    public final void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo accessibilityNodeInfo) {
+        int i;
+        int i4;
+        int itemCount;
+        super.onInitializeAccessibilityNodeInfo(accessibilityNodeInfo);
+        ViewPager2 viewPager2 = (ViewPager2) this.f4094t.f30d;
+        if (viewPager2.getAdapter() == null) {
+            i = 0;
+            i4 = 0;
+        } else if (viewPager2.getOrientation() == 1) {
+            i = viewPager2.getAdapter().getItemCount();
+            i4 = 1;
+        } else {
+            i4 = viewPager2.getAdapter().getItemCount();
+            i = 1;
+        }
+        accessibilityNodeInfo.setCollectionInfo((AccessibilityNodeInfo.CollectionInfo) a.s(i, i4, 0).f7b);
+        AbstractC0220h0 adapter = viewPager2.getAdapter();
+        if (adapter == null || (itemCount = adapter.getItemCount()) == 0 || !viewPager2.f4092r) {
+            return;
+        }
+        if (viewPager2.f4081d > 0) {
+            accessibilityNodeInfo.addAction(8192);
+        }
+        if (viewPager2.f4081d < itemCount - 1) {
+            accessibilityNodeInfo.addAction(ConstantsKt.DEFAULT_BLOCK_SIZE);
+        }
+        accessibilityNodeInfo.setScrollable(true);
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    public final void onLayout(boolean z3, int i, int i4, int i5, int i6) {
+        int measuredWidth = this.f4085j.getMeasuredWidth();
+        int measuredHeight = this.f4085j.getMeasuredHeight();
+        int paddingLeft = getPaddingLeft();
+        Rect rect = this.f4078a;
+        rect.left = paddingLeft;
+        rect.right = (i5 - i) - getPaddingRight();
+        rect.top = getPaddingTop();
+        rect.bottom = (i6 - i4) - getPaddingBottom();
+        Rect rect2 = this.f4079b;
+        Gravity.apply(8388659, measuredWidth, measuredHeight, rect, rect2);
+        this.f4085j.layout(rect2.left, rect2.top, rect2.right, rect2.bottom);
+        if (this.f4082e) {
+            d();
+        }
+    }
+
+    @Override // android.view.View
+    public final void onMeasure(int i, int i4) {
+        measureChild(this.f4085j, i, i4);
+        int measuredWidth = this.f4085j.getMeasuredWidth();
+        int measuredHeight = this.f4085j.getMeasuredHeight();
+        int measuredState = this.f4085j.getMeasuredState();
+        int paddingRight = getPaddingRight() + getPaddingLeft() + measuredWidth;
+        int paddingBottom = getPaddingBottom() + getPaddingTop() + measuredHeight;
+        setMeasuredDimension(View.resolveSizeAndState(Math.max(paddingRight, getSuggestedMinimumWidth()), i, measuredState), View.resolveSizeAndState(Math.max(paddingBottom, getSuggestedMinimumHeight()), i4, measuredState << 16));
+    }
+
+    @Override // android.view.View
+    public final void onRestoreInstanceState(Parcelable parcelable) {
+        if (!(parcelable instanceof o)) {
+            super.onRestoreInstanceState(parcelable);
+            return;
+        }
+        o oVar = (o) parcelable;
+        super.onRestoreInstanceState(oVar.getSuperState());
+        this.h = oVar.f656b;
+        this.i = oVar.f657c;
+    }
+
+    /* JADX WARN: Type inference failed for: r1v0, types: [android.view.View$BaseSavedState, android.os.Parcelable, H0.o] */
+    @Override // android.view.View
+    public final Parcelable onSaveInstanceState() {
+        ?? baseSavedState = new View.BaseSavedState(super.onSaveInstanceState());
+        baseSavedState.f655a = this.f4085j.getId();
+        int i = this.h;
+        if (i == -1) {
+            i = this.f4081d;
+        }
+        baseSavedState.f656b = i;
+        Parcelable parcelable = this.i;
+        if (parcelable != null) {
+            baseSavedState.f657c = parcelable;
+            return baseSavedState;
+        }
+        AbstractC0220h0 adapter = this.f4085j.getAdapter();
+        if (adapter instanceof androidx.viewpager2.adapter.f) {
+            baseSavedState.f657c = ((androidx.viewpager2.adapter.f) adapter).saveState();
+        }
+        return baseSavedState;
+    }
+
+    @Override // android.view.ViewGroup
+    public final void onViewAdded(View view) {
+        throw new IllegalStateException("ViewPager2 does not support direct child views");
+    }
+
+    @Override // android.view.View
+    public final boolean performAccessibilityAction(int i, Bundle bundle) {
+        this.f4094t.getClass();
+        if (i != 8192 && i != 4096) {
+            return super.performAccessibilityAction(i, bundle);
+        }
+        j jVar = this.f4094t;
+        jVar.getClass();
+        if (i != 8192 && i != 4096) {
+            throw new IllegalStateException();
+        }
+        ViewPager2 viewPager2 = (ViewPager2) jVar.f30d;
+        int currentItem = i == 8192 ? viewPager2.getCurrentItem() - 1 : viewPager2.getCurrentItem() + 1;
+        if (viewPager2.f4092r) {
+            viewPager2.c(currentItem);
+        }
+        return true;
+    }
+
+    public void setAdapter(AbstractC0220h0 abstractC0220h0) {
+        AbstractC0220h0 adapter = this.f4085j.getAdapter();
+        j jVar = this.f4094t;
+        if (adapter != null) {
+            adapter.unregisterAdapterDataObserver((f) jVar.f29c);
+        } else {
+            jVar.getClass();
+        }
+        f fVar = this.f4083f;
+        if (adapter != null) {
+            adapter.unregisterAdapterDataObserver(fVar);
+        }
+        this.f4085j.setAdapter(abstractC0220h0);
+        this.f4081d = 0;
+        a();
+        j jVar2 = this.f4094t;
+        jVar2.q();
+        if (abstractC0220h0 != null) {
+            abstractC0220h0.registerAdapterDataObserver((f) jVar2.f29c);
+        }
+        if (abstractC0220h0 != null) {
+            abstractC0220h0.registerAdapterDataObserver(fVar);
+        }
+    }
+
+    public void setCurrentItem(int i) {
+        b(i);
+    }
+
+    @Override // android.view.View
+    public void setLayoutDirection(int i) {
+        super.setLayoutDirection(i);
+        this.f4094t.q();
+    }
+
+    public void setOffscreenPageLimit(int i) {
+        if (i < 1 && i != -1) {
+            throw new IllegalArgumentException("Offscreen page limit must be OFFSCREEN_PAGE_LIMIT_DEFAULT or a number > 0");
+        }
+        this.f4093s = i;
+        this.f4085j.requestLayout();
+    }
+
+    public void setOrientation(int i) {
+        this.f4084g.j1(i);
+        this.f4094t.q();
+    }
+
+    public void setPageTransformer(l lVar) {
+        if (lVar != null) {
+            if (!this.f4091q) {
+                this.p = this.f4085j.getItemAnimator();
+                this.f4091q = true;
+            }
+            this.f4085j.setItemAnimator(null);
+        } else if (this.f4091q) {
+            this.f4085j.setItemAnimator(this.p);
+            this.p = null;
+            this.f4091q = false;
+        }
+        this.f4090o.getClass();
+        if (lVar == null) {
+            return;
+        }
+        this.f4090o.getClass();
+        this.f4090o.getClass();
+    }
+
+    public void setUserInputEnabled(boolean z3) {
+        this.f4092r = z3;
+        this.f4094t.q();
+    }
+}