Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/fragment/R.java

@@ -0,0 +1,49 @@
+package androidx.fragment;
+
+/* loaded from: classes.dex */
+public final class R {
+
+    public static final class anim {
+        public static int fragment_fast_out_extra_slow_in = 0x7f01001a;
+
+        private anim() {
+        }
+    }
+
+    public static final class animator {
+        public static int fragment_close_enter = 0x7f020000;
+        public static int fragment_close_exit = 0x7f020001;
+        public static int fragment_fade_enter = 0x7f020002;
+        public static int fragment_fade_exit = 0x7f020003;
+        public static int fragment_open_enter = 0x7f020004;
+        public static int fragment_open_exit = 0x7f020005;
+
+        private animator() {
+        }
+    }
+
+    public static final class id {
+        public static int fragment_container_view_tag = 0x7f0a0108;
+        public static int special_effects_controller_view_tag = 0x7f0a0261;
+        public static int visible_removing_fragment_view_tag = 0x7f0a0294;
+
+        private id() {
+        }
+    }
+
+    public static final class styleable {
+        public static int[] Fragment = {android.R.attr.name, android.R.attr.id, android.R.attr.tag};
+        public static int[] FragmentContainerView = {android.R.attr.name, android.R.attr.tag};
+        public static int FragmentContainerView_android_name = 0x00000000;
+        public static int FragmentContainerView_android_tag = 0x00000001;
+        public static int Fragment_android_id = 0x00000001;
+        public static int Fragment_android_name = 0x00000000;
+        public static int Fragment_android_tag = 0x00000002;
+
+        private styleable() {
+        }
+    }
+
+    private R() {
+    }
+}

decompiled/sources/androidx/fragment/app/BackStackRecord.java

@@ -0,0 +1,601 @@
+package androidx.fragment.app;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.FragmentManager;
+import androidx.fragment.app.FragmentTransaction;
+import androidx.lifecycle.Lifecycle;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+final class BackStackRecord extends FragmentTransaction implements FragmentManager.BackStackEntry, FragmentManager.OpGenerator {
+    private static final String TAG = "FragmentManager";
+    boolean mBeingSaved;
+    boolean mCommitted;
+    int mIndex;
+    final FragmentManager mManager;
+
+    @Override // androidx.fragment.app.FragmentManager.BackStackEntry
+    public int getBreadCrumbShortTitleRes() {
+        return this.mBreadCrumbShortTitleRes;
+    }
+
+    @Override // androidx.fragment.app.FragmentManager.BackStackEntry
+    public int getBreadCrumbTitleRes() {
+        return this.mBreadCrumbTitleRes;
+    }
+
+    @Override // androidx.fragment.app.FragmentManager.BackStackEntry
+    public int getId() {
+        return this.mIndex;
+    }
+
+    @Override // androidx.fragment.app.FragmentManager.BackStackEntry
+    @Nullable
+    public String getName() {
+        return this.mName;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder(128);
+        sb.append("BackStackEntry{");
+        sb.append(Integer.toHexString(System.identityHashCode(this)));
+        if (this.mIndex >= 0) {
+            sb.append(" #");
+            sb.append(this.mIndex);
+        }
+        if (this.mName != null) {
+            sb.append(" ");
+            sb.append(this.mName);
+        }
+        sb.append("}");
+        return sb.toString();
+    }
+
+    public void dump(String str, PrintWriter printWriter) {
+        dump(str, printWriter, true);
+    }
+
+    public void dump(String str, PrintWriter printWriter, boolean z) {
+        String str2;
+        if (z) {
+            printWriter.print(str);
+            printWriter.print("mName=");
+            printWriter.print(this.mName);
+            printWriter.print(" mIndex=");
+            printWriter.print(this.mIndex);
+            printWriter.print(" mCommitted=");
+            printWriter.println(this.mCommitted);
+            if (this.mTransition != 0) {
+                printWriter.print(str);
+                printWriter.print("mTransition=#");
+                printWriter.print(Integer.toHexString(this.mTransition));
+            }
+            if (this.mEnterAnim != 0 || this.mExitAnim != 0) {
+                printWriter.print(str);
+                printWriter.print("mEnterAnim=#");
+                printWriter.print(Integer.toHexString(this.mEnterAnim));
+                printWriter.print(" mExitAnim=#");
+                printWriter.println(Integer.toHexString(this.mExitAnim));
+            }
+            if (this.mPopEnterAnim != 0 || this.mPopExitAnim != 0) {
+                printWriter.print(str);
+                printWriter.print("mPopEnterAnim=#");
+                printWriter.print(Integer.toHexString(this.mPopEnterAnim));
+                printWriter.print(" mPopExitAnim=#");
+                printWriter.println(Integer.toHexString(this.mPopExitAnim));
+            }
+            if (this.mBreadCrumbTitleRes != 0 || this.mBreadCrumbTitleText != null) {
+                printWriter.print(str);
+                printWriter.print("mBreadCrumbTitleRes=#");
+                printWriter.print(Integer.toHexString(this.mBreadCrumbTitleRes));
+                printWriter.print(" mBreadCrumbTitleText=");
+                printWriter.println(this.mBreadCrumbTitleText);
+            }
+            if (this.mBreadCrumbShortTitleRes != 0 || this.mBreadCrumbShortTitleText != null) {
+                printWriter.print(str);
+                printWriter.print("mBreadCrumbShortTitleRes=#");
+                printWriter.print(Integer.toHexString(this.mBreadCrumbShortTitleRes));
+                printWriter.print(" mBreadCrumbShortTitleText=");
+                printWriter.println(this.mBreadCrumbShortTitleText);
+            }
+        }
+        if (this.mOps.isEmpty()) {
+            return;
+        }
+        printWriter.print(str);
+        printWriter.println("Operations:");
+        int size = this.mOps.size();
+        for (int i = 0; i < size; i++) {
+            FragmentTransaction.Op op = this.mOps.get(i);
+            switch (op.mCmd) {
+                case 0:
+                    str2 = "NULL";
+                    break;
+                case 1:
+                    str2 = "ADD";
+                    break;
+                case 2:
+                    str2 = "REPLACE";
+                    break;
+                case 3:
+                    str2 = "REMOVE";
+                    break;
+                case 4:
+                    str2 = "HIDE";
+                    break;
+                case 5:
+                    str2 = "SHOW";
+                    break;
+                case 6:
+                    str2 = "DETACH";
+                    break;
+                case 7:
+                    str2 = "ATTACH";
+                    break;
+                case 8:
+                    str2 = "SET_PRIMARY_NAV";
+                    break;
+                case 9:
+                    str2 = "UNSET_PRIMARY_NAV";
+                    break;
+                case 10:
+                    str2 = "OP_SET_MAX_LIFECYCLE";
+                    break;
+                default:
+                    str2 = "cmd=" + op.mCmd;
+                    break;
+            }
+            printWriter.print(str);
+            printWriter.print("  Op #");
+            printWriter.print(i);
+            printWriter.print(": ");
+            printWriter.print(str2);
+            printWriter.print(" ");
+            printWriter.println(op.mFragment);
+            if (z) {
+                if (op.mEnterAnim != 0 || op.mExitAnim != 0) {
+                    printWriter.print(str);
+                    printWriter.print("enterAnim=#");
+                    printWriter.print(Integer.toHexString(op.mEnterAnim));
+                    printWriter.print(" exitAnim=#");
+                    printWriter.println(Integer.toHexString(op.mExitAnim));
+                }
+                if (op.mPopEnterAnim != 0 || op.mPopExitAnim != 0) {
+                    printWriter.print(str);
+                    printWriter.print("popEnterAnim=#");
+                    printWriter.print(Integer.toHexString(op.mPopEnterAnim));
+                    printWriter.print(" popExitAnim=#");
+                    printWriter.println(Integer.toHexString(op.mPopExitAnim));
+                }
+            }
+        }
+    }
+
+    public BackStackRecord(@NonNull FragmentManager fragmentManager) {
+        super(fragmentManager.getFragmentFactory(), fragmentManager.getHost() != null ? fragmentManager.getHost().getContext().getClassLoader() : null);
+        this.mIndex = -1;
+        this.mBeingSaved = false;
+        this.mManager = fragmentManager;
+    }
+
+    public BackStackRecord(@NonNull BackStackRecord backStackRecord) {
+        super(backStackRecord.mManager.getFragmentFactory(), backStackRecord.mManager.getHost() != null ? backStackRecord.mManager.getHost().getContext().getClassLoader() : null, backStackRecord);
+        this.mIndex = -1;
+        this.mBeingSaved = false;
+        this.mManager = backStackRecord.mManager;
+        this.mCommitted = backStackRecord.mCommitted;
+        this.mIndex = backStackRecord.mIndex;
+        this.mBeingSaved = backStackRecord.mBeingSaved;
+    }
+
+    @Override // androidx.fragment.app.FragmentManager.BackStackEntry
+    @Nullable
+    public CharSequence getBreadCrumbTitle() {
+        return this.mBreadCrumbTitleRes != 0 ? this.mManager.getHost().getContext().getText(this.mBreadCrumbTitleRes) : this.mBreadCrumbTitleText;
+    }
+
+    @Override // androidx.fragment.app.FragmentManager.BackStackEntry
+    @Nullable
+    public CharSequence getBreadCrumbShortTitle() {
+        return this.mBreadCrumbShortTitleRes != 0 ? this.mManager.getHost().getContext().getText(this.mBreadCrumbShortTitleRes) : this.mBreadCrumbShortTitleText;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    public void doAddOp(int i, Fragment fragment, @Nullable String str, int i2) {
+        super.doAddOp(i, fragment, str, i2);
+        fragment.mFragmentManager = this.mManager;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    @NonNull
+    public FragmentTransaction remove(@NonNull Fragment fragment) {
+        FragmentManager fragmentManager = fragment.mFragmentManager;
+        if (fragmentManager != null && fragmentManager != this.mManager) {
+            throw new IllegalStateException("Cannot remove Fragment attached to a different FragmentManager. Fragment " + fragment.toString() + " is already attached to a FragmentManager.");
+        }
+        return super.remove(fragment);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    @NonNull
+    public FragmentTransaction hide(@NonNull Fragment fragment) {
+        FragmentManager fragmentManager = fragment.mFragmentManager;
+        if (fragmentManager != null && fragmentManager != this.mManager) {
+            throw new IllegalStateException("Cannot hide Fragment attached to a different FragmentManager. Fragment " + fragment.toString() + " is already attached to a FragmentManager.");
+        }
+        return super.hide(fragment);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    @NonNull
+    public FragmentTransaction show(@NonNull Fragment fragment) {
+        FragmentManager fragmentManager = fragment.mFragmentManager;
+        if (fragmentManager != null && fragmentManager != this.mManager) {
+            throw new IllegalStateException("Cannot show Fragment attached to a different FragmentManager. Fragment " + fragment.toString() + " is already attached to a FragmentManager.");
+        }
+        return super.show(fragment);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    @NonNull
+    public FragmentTransaction detach(@NonNull Fragment fragment) {
+        FragmentManager fragmentManager = fragment.mFragmentManager;
+        if (fragmentManager != null && fragmentManager != this.mManager) {
+            throw new IllegalStateException("Cannot detach Fragment attached to a different FragmentManager. Fragment " + fragment.toString() + " is already attached to a FragmentManager.");
+        }
+        return super.detach(fragment);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    @NonNull
+    public FragmentTransaction setPrimaryNavigationFragment(@Nullable Fragment fragment) {
+        FragmentManager fragmentManager;
+        if (fragment != null && (fragmentManager = fragment.mFragmentManager) != null && fragmentManager != this.mManager) {
+            throw new IllegalStateException("Cannot setPrimaryNavigation for Fragment attached to a different FragmentManager. Fragment " + fragment.toString() + " is already attached to a FragmentManager.");
+        }
+        return super.setPrimaryNavigationFragment(fragment);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    @NonNull
+    public FragmentTransaction setMaxLifecycle(@NonNull Fragment fragment, @NonNull Lifecycle.State state) {
+        if (fragment.mFragmentManager != this.mManager) {
+            throw new IllegalArgumentException("Cannot setMaxLifecycle for Fragment not attached to FragmentManager " + this.mManager);
+        }
+        if (state == Lifecycle.State.INITIALIZED && fragment.mState > -1) {
+            throw new IllegalArgumentException("Cannot set maximum Lifecycle to " + state + " after the Fragment has been created");
+        }
+        if (state == Lifecycle.State.DESTROYED) {
+            throw new IllegalArgumentException("Cannot set maximum Lifecycle to " + state + ". Use remove() to remove the fragment from the FragmentManager and trigger its destruction.");
+        }
+        return super.setMaxLifecycle(fragment, state);
+    }
+
+    public void bumpBackStackNesting(int i) {
+        if (this.mAddToBackStack) {
+            if (FragmentManager.isLoggingEnabled(2)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Bump nesting in ");
+                sb.append(this);
+                sb.append(" by ");
+                sb.append(i);
+            }
+            int size = this.mOps.size();
+            for (int i2 = 0; i2 < size; i2++) {
+                FragmentTransaction.Op op = this.mOps.get(i2);
+                Fragment fragment = op.mFragment;
+                if (fragment != null) {
+                    fragment.mBackStackNesting += i;
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb2 = new StringBuilder();
+                        sb2.append("Bump nesting of ");
+                        sb2.append(op.mFragment);
+                        sb2.append(" to ");
+                        sb2.append(op.mFragment.mBackStackNesting);
+                    }
+                }
+            }
+        }
+    }
+
+    public void runOnCommitRunnables() {
+        if (this.mCommitRunnables != null) {
+            for (int i = 0; i < this.mCommitRunnables.size(); i++) {
+                this.mCommitRunnables.get(i).run();
+            }
+            this.mCommitRunnables = null;
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    public int commit() {
+        return commitInternal(false);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    public int commitAllowingStateLoss() {
+        return commitInternal(true);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    public void commitNow() {
+        disallowAddToBackStack();
+        this.mManager.execSingleAction(this, false);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    public void commitNowAllowingStateLoss() {
+        disallowAddToBackStack();
+        this.mManager.execSingleAction(this, true);
+    }
+
+    public int commitInternal(boolean z) {
+        if (this.mCommitted) {
+            throw new IllegalStateException("commit already called");
+        }
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Commit: ");
+            sb.append(this);
+            PrintWriter printWriter = new PrintWriter(new LogWriter("FragmentManager"));
+            dump("  ", printWriter);
+            printWriter.close();
+        }
+        this.mCommitted = true;
+        if (this.mAddToBackStack) {
+            this.mIndex = this.mManager.allocBackStackIndex();
+        } else {
+            this.mIndex = -1;
+        }
+        this.mManager.enqueueAction(this, z);
+        return this.mIndex;
+    }
+
+    @Override // androidx.fragment.app.FragmentManager.OpGenerator
+    public boolean generateOps(@NonNull ArrayList<BackStackRecord> arrayList, @NonNull ArrayList<Boolean> arrayList2) {
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Run: ");
+            sb.append(this);
+        }
+        arrayList.add(this);
+        arrayList2.add(Boolean.FALSE);
+        if (!this.mAddToBackStack) {
+            return true;
+        }
+        this.mManager.addBackStackState(this);
+        return true;
+    }
+
+    public void executeOps() {
+        int size = this.mOps.size();
+        for (int i = 0; i < size; i++) {
+            FragmentTransaction.Op op = this.mOps.get(i);
+            Fragment fragment = op.mFragment;
+            if (fragment != null) {
+                fragment.mBeingSaved = this.mBeingSaved;
+                fragment.setPopDirection(false);
+                fragment.setNextTransition(this.mTransition);
+                fragment.setSharedElementNames(this.mSharedElementSourceNames, this.mSharedElementTargetNames);
+            }
+            switch (op.mCmd) {
+                case 1:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.setExitAnimationOrder(fragment, false);
+                    this.mManager.addFragment(fragment);
+                    break;
+                case 2:
+                default:
+                    throw new IllegalArgumentException("Unknown cmd: " + op.mCmd);
+                case 3:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.removeFragment(fragment);
+                    break;
+                case 4:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.hideFragment(fragment);
+                    break;
+                case 5:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.setExitAnimationOrder(fragment, false);
+                    this.mManager.showFragment(fragment);
+                    break;
+                case 6:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.detachFragment(fragment);
+                    break;
+                case 7:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.setExitAnimationOrder(fragment, false);
+                    this.mManager.attachFragment(fragment);
+                    break;
+                case 8:
+                    this.mManager.setPrimaryNavigationFragment(fragment);
+                    break;
+                case 9:
+                    this.mManager.setPrimaryNavigationFragment(null);
+                    break;
+                case 10:
+                    this.mManager.setMaxLifecycle(fragment, op.mCurrentMaxState);
+                    break;
+            }
+        }
+    }
+
+    public void executePopOps() {
+        for (int size = this.mOps.size() - 1; size >= 0; size--) {
+            FragmentTransaction.Op op = this.mOps.get(size);
+            Fragment fragment = op.mFragment;
+            if (fragment != null) {
+                fragment.mBeingSaved = this.mBeingSaved;
+                fragment.setPopDirection(true);
+                fragment.setNextTransition(FragmentManager.reverseTransit(this.mTransition));
+                fragment.setSharedElementNames(this.mSharedElementTargetNames, this.mSharedElementSourceNames);
+            }
+            switch (op.mCmd) {
+                case 1:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.setExitAnimationOrder(fragment, true);
+                    this.mManager.removeFragment(fragment);
+                    break;
+                case 2:
+                default:
+                    throw new IllegalArgumentException("Unknown cmd: " + op.mCmd);
+                case 3:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.addFragment(fragment);
+                    break;
+                case 4:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.showFragment(fragment);
+                    break;
+                case 5:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.setExitAnimationOrder(fragment, true);
+                    this.mManager.hideFragment(fragment);
+                    break;
+                case 6:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.attachFragment(fragment);
+                    break;
+                case 7:
+                    fragment.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
+                    this.mManager.setExitAnimationOrder(fragment, true);
+                    this.mManager.detachFragment(fragment);
+                    break;
+                case 8:
+                    this.mManager.setPrimaryNavigationFragment(null);
+                    break;
+                case 9:
+                    this.mManager.setPrimaryNavigationFragment(fragment);
+                    break;
+                case 10:
+                    this.mManager.setMaxLifecycle(fragment, op.mOldMaxState);
+                    break;
+            }
+        }
+    }
+
+    public Fragment expandOps(ArrayList<Fragment> arrayList, Fragment fragment) {
+        Fragment fragment2 = fragment;
+        int i = 0;
+        while (i < this.mOps.size()) {
+            FragmentTransaction.Op op = this.mOps.get(i);
+            int i2 = op.mCmd;
+            if (i2 != 1) {
+                if (i2 == 2) {
+                    Fragment fragment3 = op.mFragment;
+                    int i3 = fragment3.mContainerId;
+                    boolean z = false;
+                    for (int size = arrayList.size() - 1; size >= 0; size--) {
+                        Fragment fragment4 = arrayList.get(size);
+                        if (fragment4.mContainerId == i3) {
+                            if (fragment4 == fragment3) {
+                                z = true;
+                            } else {
+                                if (fragment4 == fragment2) {
+                                    this.mOps.add(i, new FragmentTransaction.Op(9, fragment4, true));
+                                    i++;
+                                    fragment2 = null;
+                                }
+                                FragmentTransaction.Op op2 = new FragmentTransaction.Op(3, fragment4, true);
+                                op2.mEnterAnim = op.mEnterAnim;
+                                op2.mPopEnterAnim = op.mPopEnterAnim;
+                                op2.mExitAnim = op.mExitAnim;
+                                op2.mPopExitAnim = op.mPopExitAnim;
+                                this.mOps.add(i, op2);
+                                arrayList.remove(fragment4);
+                                i++;
+                            }
+                        }
+                    }
+                    if (z) {
+                        this.mOps.remove(i);
+                        i--;
+                    } else {
+                        op.mCmd = 1;
+                        op.mFromExpandedOp = true;
+                        arrayList.add(fragment3);
+                    }
+                } else if (i2 == 3 || i2 == 6) {
+                    arrayList.remove(op.mFragment);
+                    Fragment fragment5 = op.mFragment;
+                    if (fragment5 == fragment2) {
+                        this.mOps.add(i, new FragmentTransaction.Op(9, fragment5));
+                        i++;
+                        fragment2 = null;
+                    }
+                } else if (i2 != 7) {
+                    if (i2 == 8) {
+                        this.mOps.add(i, new FragmentTransaction.Op(9, fragment2, true));
+                        op.mFromExpandedOp = true;
+                        i++;
+                        fragment2 = op.mFragment;
+                    }
+                }
+                i++;
+            }
+            arrayList.add(op.mFragment);
+            i++;
+        }
+        return fragment2;
+    }
+
+    public Fragment trackAddedFragmentsInPop(ArrayList<Fragment> arrayList, Fragment fragment) {
+        for (int size = this.mOps.size() - 1; size >= 0; size--) {
+            FragmentTransaction.Op op = this.mOps.get(size);
+            int i = op.mCmd;
+            if (i != 1) {
+                if (i != 3) {
+                    switch (i) {
+                        case 8:
+                            fragment = null;
+                            break;
+                        case 9:
+                            fragment = op.mFragment;
+                            break;
+                        case 10:
+                            op.mCurrentMaxState = op.mOldMaxState;
+                            break;
+                    }
+                }
+                arrayList.add(op.mFragment);
+            }
+            arrayList.remove(op.mFragment);
+        }
+        return fragment;
+    }
+
+    public void collapseOps() {
+        int size = this.mOps.size() - 1;
+        while (size >= 0) {
+            FragmentTransaction.Op op = this.mOps.get(size);
+            if (op.mFromExpandedOp) {
+                if (op.mCmd == 8) {
+                    op.mFromExpandedOp = false;
+                    this.mOps.remove(size - 1);
+                    size--;
+                } else {
+                    int i = op.mFragment.mContainerId;
+                    op.mCmd = 2;
+                    op.mFromExpandedOp = false;
+                    for (int i2 = size - 1; i2 >= 0; i2--) {
+                        FragmentTransaction.Op op2 = this.mOps.get(i2);
+                        if (op2.mFromExpandedOp && op2.mFragment.mContainerId == i) {
+                            this.mOps.remove(i2);
+                            size--;
+                        }
+                    }
+                }
+            }
+            size--;
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransaction
+    public boolean isEmpty() {
+        return this.mOps.isEmpty();
+    }
+}

decompiled/sources/androidx/fragment/app/BackStackRecordState.java

@@ -0,0 +1,216 @@
+package androidx.fragment.app;
+
+import android.annotation.SuppressLint;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.FragmentTransaction;
+import androidx.lifecycle.Lifecycle;
+import java.util.ArrayList;
+import java.util.Map;
+
+@SuppressLint({"BanParcelableUsage"})
+/* loaded from: classes.dex */
+final class BackStackRecordState implements Parcelable {
+    public static final Parcelable.Creator<BackStackRecordState> CREATOR = new Parcelable.Creator<BackStackRecordState>() { // from class: androidx.fragment.app.BackStackRecordState.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public BackStackRecordState createFromParcel(Parcel parcel) {
+            return new BackStackRecordState(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public BackStackRecordState[] newArray(int i) {
+            return new BackStackRecordState[i];
+        }
+    };
+    private static final String TAG = "FragmentManager";
+    final int mBreadCrumbShortTitleRes;
+    final CharSequence mBreadCrumbShortTitleText;
+    final int mBreadCrumbTitleRes;
+    final CharSequence mBreadCrumbTitleText;
+    final int[] mCurrentMaxLifecycleStates;
+    final ArrayList<String> mFragmentWhos;
+    final int mIndex;
+    final String mName;
+    final int[] mOldMaxLifecycleStates;
+    final int[] mOps;
+    final boolean mReorderingAllowed;
+    final ArrayList<String> mSharedElementSourceNames;
+    final ArrayList<String> mSharedElementTargetNames;
+    final int mTransition;
+
+    @Override // android.os.Parcelable
+    public int describeContents() {
+        return 0;
+    }
+
+    public BackStackRecordState(BackStackRecord backStackRecord) {
+        int size = backStackRecord.mOps.size();
+        this.mOps = new int[size * 6];
+        if (!backStackRecord.mAddToBackStack) {
+            throw new IllegalStateException("Not on back stack");
+        }
+        this.mFragmentWhos = new ArrayList<>(size);
+        this.mOldMaxLifecycleStates = new int[size];
+        this.mCurrentMaxLifecycleStates = new int[size];
+        int i = 0;
+        for (int i2 = 0; i2 < size; i2++) {
+            FragmentTransaction.Op op = backStackRecord.mOps.get(i2);
+            int i3 = i + 1;
+            this.mOps[i] = op.mCmd;
+            ArrayList<String> arrayList = this.mFragmentWhos;
+            Fragment fragment = op.mFragment;
+            arrayList.add(fragment != null ? fragment.mWho : null);
+            int[] iArr = this.mOps;
+            iArr[i3] = op.mFromExpandedOp ? 1 : 0;
+            iArr[i + 2] = op.mEnterAnim;
+            iArr[i + 3] = op.mExitAnim;
+            int i4 = i + 5;
+            iArr[i + 4] = op.mPopEnterAnim;
+            i += 6;
+            iArr[i4] = op.mPopExitAnim;
+            this.mOldMaxLifecycleStates[i2] = op.mOldMaxState.ordinal();
+            this.mCurrentMaxLifecycleStates[i2] = op.mCurrentMaxState.ordinal();
+        }
+        this.mTransition = backStackRecord.mTransition;
+        this.mName = backStackRecord.mName;
+        this.mIndex = backStackRecord.mIndex;
+        this.mBreadCrumbTitleRes = backStackRecord.mBreadCrumbTitleRes;
+        this.mBreadCrumbTitleText = backStackRecord.mBreadCrumbTitleText;
+        this.mBreadCrumbShortTitleRes = backStackRecord.mBreadCrumbShortTitleRes;
+        this.mBreadCrumbShortTitleText = backStackRecord.mBreadCrumbShortTitleText;
+        this.mSharedElementSourceNames = backStackRecord.mSharedElementSourceNames;
+        this.mSharedElementTargetNames = backStackRecord.mSharedElementTargetNames;
+        this.mReorderingAllowed = backStackRecord.mReorderingAllowed;
+    }
+
+    public BackStackRecordState(Parcel parcel) {
+        this.mOps = parcel.createIntArray();
+        this.mFragmentWhos = parcel.createStringArrayList();
+        this.mOldMaxLifecycleStates = parcel.createIntArray();
+        this.mCurrentMaxLifecycleStates = parcel.createIntArray();
+        this.mTransition = parcel.readInt();
+        this.mName = parcel.readString();
+        this.mIndex = parcel.readInt();
+        this.mBreadCrumbTitleRes = parcel.readInt();
+        Parcelable.Creator creator = TextUtils.CHAR_SEQUENCE_CREATOR;
+        this.mBreadCrumbTitleText = (CharSequence) creator.createFromParcel(parcel);
+        this.mBreadCrumbShortTitleRes = parcel.readInt();
+        this.mBreadCrumbShortTitleText = (CharSequence) creator.createFromParcel(parcel);
+        this.mSharedElementSourceNames = parcel.createStringArrayList();
+        this.mSharedElementTargetNames = parcel.createStringArrayList();
+        this.mReorderingAllowed = parcel.readInt() != 0;
+    }
+
+    @NonNull
+    public BackStackRecord instantiate(@NonNull FragmentManager fragmentManager) {
+        BackStackRecord backStackRecord = new BackStackRecord(fragmentManager);
+        fillInBackStackRecord(backStackRecord);
+        backStackRecord.mIndex = this.mIndex;
+        for (int i = 0; i < this.mFragmentWhos.size(); i++) {
+            String str = this.mFragmentWhos.get(i);
+            if (str != null) {
+                backStackRecord.mOps.get(i).mFragment = fragmentManager.findActiveFragment(str);
+            }
+        }
+        backStackRecord.bumpBackStackNesting(1);
+        return backStackRecord;
+    }
+
+    @NonNull
+    public BackStackRecord instantiate(@NonNull FragmentManager fragmentManager, @NonNull Map<String, Fragment> map) {
+        BackStackRecord backStackRecord = new BackStackRecord(fragmentManager);
+        fillInBackStackRecord(backStackRecord);
+        for (int i = 0; i < this.mFragmentWhos.size(); i++) {
+            String str = this.mFragmentWhos.get(i);
+            if (str != null) {
+                Fragment fragment = map.get(str);
+                if (fragment != null) {
+                    backStackRecord.mOps.get(i).mFragment = fragment;
+                } else {
+                    throw new IllegalStateException("Restoring FragmentTransaction " + this.mName + " failed due to missing saved state for Fragment (" + str + ")");
+                }
+            }
+        }
+        return backStackRecord;
+    }
+
+    private void fillInBackStackRecord(@NonNull BackStackRecord backStackRecord) {
+        int i = 0;
+        int i2 = 0;
+        while (true) {
+            boolean z = true;
+            if (i < this.mOps.length) {
+                FragmentTransaction.Op op = new FragmentTransaction.Op();
+                int i3 = i + 1;
+                op.mCmd = this.mOps[i];
+                if (FragmentManager.isLoggingEnabled(2)) {
+                    StringBuilder sb = new StringBuilder();
+                    sb.append("Instantiate ");
+                    sb.append(backStackRecord);
+                    sb.append(" op #");
+                    sb.append(i2);
+                    sb.append(" base fragment #");
+                    sb.append(this.mOps[i3]);
+                }
+                op.mOldMaxState = Lifecycle.State.values()[this.mOldMaxLifecycleStates[i2]];
+                op.mCurrentMaxState = Lifecycle.State.values()[this.mCurrentMaxLifecycleStates[i2]];
+                int[] iArr = this.mOps;
+                int i4 = i + 2;
+                if (iArr[i3] == 0) {
+                    z = false;
+                }
+                op.mFromExpandedOp = z;
+                int i5 = iArr[i4];
+                op.mEnterAnim = i5;
+                int i6 = iArr[i + 3];
+                op.mExitAnim = i6;
+                int i7 = i + 5;
+                int i8 = iArr[i + 4];
+                op.mPopEnterAnim = i8;
+                i += 6;
+                int i9 = iArr[i7];
+                op.mPopExitAnim = i9;
+                backStackRecord.mEnterAnim = i5;
+                backStackRecord.mExitAnim = i6;
+                backStackRecord.mPopEnterAnim = i8;
+                backStackRecord.mPopExitAnim = i9;
+                backStackRecord.addOp(op);
+                i2++;
+            } else {
+                backStackRecord.mTransition = this.mTransition;
+                backStackRecord.mName = this.mName;
+                backStackRecord.mAddToBackStack = true;
+                backStackRecord.mBreadCrumbTitleRes = this.mBreadCrumbTitleRes;
+                backStackRecord.mBreadCrumbTitleText = this.mBreadCrumbTitleText;
+                backStackRecord.mBreadCrumbShortTitleRes = this.mBreadCrumbShortTitleRes;
+                backStackRecord.mBreadCrumbShortTitleText = this.mBreadCrumbShortTitleText;
+                backStackRecord.mSharedElementSourceNames = this.mSharedElementSourceNames;
+                backStackRecord.mSharedElementTargetNames = this.mSharedElementTargetNames;
+                backStackRecord.mReorderingAllowed = this.mReorderingAllowed;
+                return;
+            }
+        }
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        parcel.writeIntArray(this.mOps);
+        parcel.writeStringList(this.mFragmentWhos);
+        parcel.writeIntArray(this.mOldMaxLifecycleStates);
+        parcel.writeIntArray(this.mCurrentMaxLifecycleStates);
+        parcel.writeInt(this.mTransition);
+        parcel.writeString(this.mName);
+        parcel.writeInt(this.mIndex);
+        parcel.writeInt(this.mBreadCrumbTitleRes);
+        TextUtils.writeToParcel(this.mBreadCrumbTitleText, parcel, 0);
+        parcel.writeInt(this.mBreadCrumbShortTitleRes);
+        TextUtils.writeToParcel(this.mBreadCrumbShortTitleText, parcel, 0);
+        parcel.writeStringList(this.mSharedElementSourceNames);
+        parcel.writeStringList(this.mSharedElementTargetNames);
+        parcel.writeInt(this.mReorderingAllowed ? 1 : 0);
+    }
+}

decompiled/sources/androidx/fragment/app/BackStackState.java

@@ -0,0 +1,75 @@
+package androidx.fragment.app;
+
+import android.annotation.SuppressLint;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+@SuppressLint({"BanParcelableUsage"})
+/* loaded from: classes.dex */
+class BackStackState implements Parcelable {
+    public static final Parcelable.Creator<BackStackState> CREATOR = new Parcelable.Creator<BackStackState>() { // from class: androidx.fragment.app.BackStackState.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public BackStackState createFromParcel(Parcel parcel) {
+            return new BackStackState(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public BackStackState[] newArray(int i) {
+            return new BackStackState[i];
+        }
+    };
+    final List<String> mFragments;
+    final List<BackStackRecordState> mTransactions;
+
+    @Override // android.os.Parcelable
+    public int describeContents() {
+        return 0;
+    }
+
+    public BackStackState(List<String> list, List<BackStackRecordState> list2) {
+        this.mFragments = list;
+        this.mTransactions = list2;
+    }
+
+    public BackStackState(@NonNull Parcel parcel) {
+        this.mFragments = parcel.createStringArrayList();
+        this.mTransactions = parcel.createTypedArrayList(BackStackRecordState.CREATOR);
+    }
+
+    @NonNull
+    public List<BackStackRecord> instantiate(@NonNull FragmentManager fragmentManager, Map<String, Fragment> map) {
+        HashMap hashMap = new HashMap(this.mFragments.size());
+        for (String str : this.mFragments) {
+            Fragment fragment = map.get(str);
+            if (fragment != null) {
+                hashMap.put(fragment.mWho, fragment);
+            } else {
+                FragmentState savedState = fragmentManager.getFragmentStore().setSavedState(str, null);
+                if (savedState != null) {
+                    Fragment instantiate = savedState.instantiate(fragmentManager.getFragmentFactory(), fragmentManager.getHost().getContext().getClassLoader());
+                    hashMap.put(instantiate.mWho, instantiate);
+                }
+            }
+        }
+        ArrayList arrayList = new ArrayList();
+        Iterator<BackStackRecordState> it = this.mTransactions.iterator();
+        while (it.hasNext()) {
+            arrayList.add(it.next().instantiate(fragmentManager, hashMap));
+        }
+        return arrayList;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel parcel, int i) {
+        parcel.writeStringList(this.mFragments);
+        parcel.writeTypedList(this.mTransactions);
+    }
+}

decompiled/sources/androidx/fragment/app/DefaultSpecialEffectsController.java

@@ -0,0 +1,994 @@
+package androidx.fragment.app;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.content.Context;
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.collection.ArrayMap;
+import androidx.core.app.SharedElementCallback;
+import androidx.core.os.CancellationSignal;
+import androidx.core.util.Preconditions;
+import androidx.core.view.OneShotPreDrawListener;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.ViewGroupCompat;
+import androidx.fragment.app.FragmentAnim;
+import androidx.fragment.app.SpecialEffectsController;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+class DefaultSpecialEffectsController extends SpecialEffectsController {
+    public DefaultSpecialEffectsController(@NonNull ViewGroup viewGroup) {
+        super(viewGroup);
+    }
+
+    @Override // androidx.fragment.app.SpecialEffectsController
+    public void executeOperations(@NonNull List<SpecialEffectsController.Operation> list, boolean z) {
+        SpecialEffectsController.Operation operation = null;
+        SpecialEffectsController.Operation operation2 = null;
+        for (SpecialEffectsController.Operation operation3 : list) {
+            SpecialEffectsController.Operation.State from = SpecialEffectsController.Operation.State.from(operation3.getFragment().mView);
+            int i = AnonymousClass10.$SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[operation3.getFinalState().ordinal()];
+            if (i == 1 || i == 2 || i == 3) {
+                if (from == SpecialEffectsController.Operation.State.VISIBLE && operation == null) {
+                    operation = operation3;
+                }
+            } else if (i == 4 && from != SpecialEffectsController.Operation.State.VISIBLE) {
+                operation2 = operation3;
+            }
+        }
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Executing operations from ");
+            sb.append(operation);
+            sb.append(" to ");
+            sb.append(operation2);
+        }
+        ArrayList arrayList = new ArrayList();
+        ArrayList arrayList2 = new ArrayList();
+        final ArrayList arrayList3 = new ArrayList(list);
+        syncAnimations(list);
+        for (final SpecialEffectsController.Operation operation4 : list) {
+            CancellationSignal cancellationSignal = new CancellationSignal();
+            operation4.markStartedSpecialEffect(cancellationSignal);
+            arrayList.add(new AnimationInfo(operation4, cancellationSignal, z));
+            CancellationSignal cancellationSignal2 = new CancellationSignal();
+            operation4.markStartedSpecialEffect(cancellationSignal2);
+            boolean z2 = false;
+            if (z) {
+                if (operation4 != operation) {
+                    arrayList2.add(new TransitionInfo(operation4, cancellationSignal2, z, z2));
+                    operation4.addCompletionListener(new Runnable() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.1
+                        @Override // java.lang.Runnable
+                        public void run() {
+                            if (arrayList3.contains(operation4)) {
+                                arrayList3.remove(operation4);
+                                DefaultSpecialEffectsController.this.applyContainerChanges(operation4);
+                            }
+                        }
+                    });
+                }
+                z2 = true;
+                arrayList2.add(new TransitionInfo(operation4, cancellationSignal2, z, z2));
+                operation4.addCompletionListener(new Runnable() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.1
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (arrayList3.contains(operation4)) {
+                            arrayList3.remove(operation4);
+                            DefaultSpecialEffectsController.this.applyContainerChanges(operation4);
+                        }
+                    }
+                });
+            } else {
+                if (operation4 != operation2) {
+                    arrayList2.add(new TransitionInfo(operation4, cancellationSignal2, z, z2));
+                    operation4.addCompletionListener(new Runnable() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.1
+                        @Override // java.lang.Runnable
+                        public void run() {
+                            if (arrayList3.contains(operation4)) {
+                                arrayList3.remove(operation4);
+                                DefaultSpecialEffectsController.this.applyContainerChanges(operation4);
+                            }
+                        }
+                    });
+                }
+                z2 = true;
+                arrayList2.add(new TransitionInfo(operation4, cancellationSignal2, z, z2));
+                operation4.addCompletionListener(new Runnable() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.1
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (arrayList3.contains(operation4)) {
+                            arrayList3.remove(operation4);
+                            DefaultSpecialEffectsController.this.applyContainerChanges(operation4);
+                        }
+                    }
+                });
+            }
+        }
+        Map<SpecialEffectsController.Operation, Boolean> startTransitions = startTransitions(arrayList2, arrayList3, z, operation, operation2);
+        startAnimations(arrayList, arrayList3, startTransitions.containsValue(Boolean.TRUE), startTransitions);
+        Iterator<SpecialEffectsController.Operation> it = arrayList3.iterator();
+        while (it.hasNext()) {
+            applyContainerChanges(it.next());
+        }
+        arrayList3.clear();
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb2 = new StringBuilder();
+            sb2.append("Completed executing operations from ");
+            sb2.append(operation);
+            sb2.append(" to ");
+            sb2.append(operation2);
+        }
+    }
+
+    /* renamed from: androidx.fragment.app.DefaultSpecialEffectsController$10, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass10 {
+        static final /* synthetic */ int[] $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State;
+
+        static {
+            int[] iArr = new int[SpecialEffectsController.Operation.State.values().length];
+            $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State = iArr;
+            try {
+                iArr[SpecialEffectsController.Operation.State.GONE.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[SpecialEffectsController.Operation.State.INVISIBLE.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[SpecialEffectsController.Operation.State.REMOVED.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[SpecialEffectsController.Operation.State.VISIBLE.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+        }
+    }
+
+    private void syncAnimations(@NonNull List<SpecialEffectsController.Operation> list) {
+        Fragment fragment = list.get(list.size() - 1).getFragment();
+        for (SpecialEffectsController.Operation operation : list) {
+            operation.getFragment().mAnimationInfo.mEnterAnim = fragment.mAnimationInfo.mEnterAnim;
+            operation.getFragment().mAnimationInfo.mExitAnim = fragment.mAnimationInfo.mExitAnim;
+            operation.getFragment().mAnimationInfo.mPopEnterAnim = fragment.mAnimationInfo.mPopEnterAnim;
+            operation.getFragment().mAnimationInfo.mPopExitAnim = fragment.mAnimationInfo.mPopExitAnim;
+        }
+    }
+
+    private void startAnimations(@NonNull List<AnimationInfo> list, @NonNull List<SpecialEffectsController.Operation> list2, boolean z, @NonNull Map<SpecialEffectsController.Operation, Boolean> map) {
+        int i;
+        boolean z2;
+        int i2;
+        final SpecialEffectsController.Operation operation;
+        final ViewGroup container = getContainer();
+        Context context = container.getContext();
+        ArrayList arrayList = new ArrayList();
+        Iterator<AnimationInfo> it = list.iterator();
+        boolean z3 = false;
+        while (true) {
+            i = 2;
+            if (!it.hasNext()) {
+                break;
+            }
+            final AnimationInfo next = it.next();
+            if (next.isVisibilityUnchanged()) {
+                next.completeSpecialEffect();
+            } else {
+                FragmentAnim.AnimationOrAnimator animation = next.getAnimation(context);
+                if (animation == null) {
+                    next.completeSpecialEffect();
+                } else {
+                    final Animator animator = animation.animator;
+                    if (animator == null) {
+                        arrayList.add(next);
+                    } else {
+                        final SpecialEffectsController.Operation operation2 = next.getOperation();
+                        Fragment fragment = operation2.getFragment();
+                        if (Boolean.TRUE.equals(map.get(operation2))) {
+                            if (FragmentManager.isLoggingEnabled(2)) {
+                                StringBuilder sb = new StringBuilder();
+                                sb.append("Ignoring Animator set on ");
+                                sb.append(fragment);
+                                sb.append(" as this Fragment was involved in a Transition.");
+                            }
+                            next.completeSpecialEffect();
+                        } else {
+                            boolean z4 = operation2.getFinalState() == SpecialEffectsController.Operation.State.GONE;
+                            if (z4) {
+                                list2.remove(operation2);
+                            }
+                            final View view = fragment.mView;
+                            container.startViewTransition(view);
+                            final boolean z5 = z4;
+                            animator.addListener(new AnimatorListenerAdapter() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.2
+                                @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+                                public void onAnimationEnd(Animator animator2) {
+                                    container.endViewTransition(view);
+                                    if (z5) {
+                                        operation2.getFinalState().applyState(view);
+                                    }
+                                    next.completeSpecialEffect();
+                                    if (FragmentManager.isLoggingEnabled(2)) {
+                                        StringBuilder sb2 = new StringBuilder();
+                                        sb2.append("Animator from operation ");
+                                        sb2.append(operation2);
+                                        sb2.append(" has ended.");
+                                    }
+                                }
+                            });
+                            animator.setTarget(view);
+                            animator.start();
+                            if (FragmentManager.isLoggingEnabled(2)) {
+                                StringBuilder sb2 = new StringBuilder();
+                                sb2.append("Animator from operation ");
+                                operation = operation2;
+                                sb2.append(operation);
+                                sb2.append(" has started.");
+                            } else {
+                                operation = operation2;
+                            }
+                            next.getSignal().setOnCancelListener(new CancellationSignal.OnCancelListener() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.3
+                                @Override // androidx.core.os.CancellationSignal.OnCancelListener
+                                public void onCancel() {
+                                    animator.end();
+                                    if (FragmentManager.isLoggingEnabled(2)) {
+                                        StringBuilder sb3 = new StringBuilder();
+                                        sb3.append("Animator from operation ");
+                                        sb3.append(operation);
+                                        sb3.append(" has been canceled.");
+                                    }
+                                }
+                            });
+                            z3 = true;
+                        }
+                    }
+                }
+            }
+        }
+        Iterator it2 = arrayList.iterator();
+        while (it2.hasNext()) {
+            final AnimationInfo animationInfo = (AnimationInfo) it2.next();
+            final SpecialEffectsController.Operation operation3 = animationInfo.getOperation();
+            Fragment fragment2 = operation3.getFragment();
+            if (z) {
+                if (FragmentManager.isLoggingEnabled(i)) {
+                    StringBuilder sb3 = new StringBuilder();
+                    sb3.append("Ignoring Animation set on ");
+                    sb3.append(fragment2);
+                    sb3.append(" as Animations cannot run alongside Transitions.");
+                }
+                animationInfo.completeSpecialEffect();
+            } else if (z3) {
+                if (FragmentManager.isLoggingEnabled(i)) {
+                    StringBuilder sb4 = new StringBuilder();
+                    sb4.append("Ignoring Animation set on ");
+                    sb4.append(fragment2);
+                    sb4.append(" as Animations cannot run alongside Animators.");
+                }
+                animationInfo.completeSpecialEffect();
+            } else {
+                final View view2 = fragment2.mView;
+                Animation animation2 = (Animation) Preconditions.checkNotNull(((FragmentAnim.AnimationOrAnimator) Preconditions.checkNotNull(animationInfo.getAnimation(context))).animation);
+                if (operation3.getFinalState() != SpecialEffectsController.Operation.State.REMOVED) {
+                    view2.startAnimation(animation2);
+                    animationInfo.completeSpecialEffect();
+                    z2 = z3;
+                    i2 = i;
+                } else {
+                    container.startViewTransition(view2);
+                    FragmentAnim.EndViewTransitionAnimation endViewTransitionAnimation = new FragmentAnim.EndViewTransitionAnimation(animation2, container, view2);
+                    z2 = z3;
+                    endViewTransitionAnimation.setAnimationListener(new Animation.AnimationListener() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.4
+                        @Override // android.view.animation.Animation.AnimationListener
+                        public void onAnimationRepeat(Animation animation3) {
+                        }
+
+                        @Override // android.view.animation.Animation.AnimationListener
+                        public void onAnimationStart(Animation animation3) {
+                            if (FragmentManager.isLoggingEnabled(2)) {
+                                StringBuilder sb5 = new StringBuilder();
+                                sb5.append("Animation from operation ");
+                                sb5.append(operation3);
+                                sb5.append(" has reached onAnimationStart.");
+                            }
+                        }
+
+                        @Override // android.view.animation.Animation.AnimationListener
+                        public void onAnimationEnd(Animation animation3) {
+                            container.post(new Runnable() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.4.1
+                                @Override // java.lang.Runnable
+                                public void run() {
+                                    AnonymousClass4 anonymousClass4 = AnonymousClass4.this;
+                                    container.endViewTransition(view2);
+                                    animationInfo.completeSpecialEffect();
+                                }
+                            });
+                            if (FragmentManager.isLoggingEnabled(2)) {
+                                StringBuilder sb5 = new StringBuilder();
+                                sb5.append("Animation from operation ");
+                                sb5.append(operation3);
+                                sb5.append(" has ended.");
+                            }
+                        }
+                    });
+                    view2.startAnimation(endViewTransitionAnimation);
+                    i2 = 2;
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb5 = new StringBuilder();
+                        sb5.append("Animation from operation ");
+                        sb5.append(operation3);
+                        sb5.append(" has started.");
+                    }
+                }
+                animationInfo.getSignal().setOnCancelListener(new CancellationSignal.OnCancelListener() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.5
+                    @Override // androidx.core.os.CancellationSignal.OnCancelListener
+                    public void onCancel() {
+                        view2.clearAnimation();
+                        container.endViewTransition(view2);
+                        animationInfo.completeSpecialEffect();
+                        if (FragmentManager.isLoggingEnabled(2)) {
+                            StringBuilder sb6 = new StringBuilder();
+                            sb6.append("Animation from operation ");
+                            sb6.append(operation3);
+                            sb6.append(" has been cancelled.");
+                        }
+                    }
+                });
+                i = i2;
+                z3 = z2;
+            }
+        }
+    }
+
+    @NonNull
+    private Map<SpecialEffectsController.Operation, Boolean> startTransitions(@NonNull List<TransitionInfo> list, @NonNull List<SpecialEffectsController.Operation> list2, final boolean z, @Nullable final SpecialEffectsController.Operation operation, @Nullable final SpecialEffectsController.Operation operation2) {
+        Iterator<TransitionInfo> it;
+        View view;
+        Object obj;
+        ArrayList<View> arrayList;
+        Object obj2;
+        ArrayList<View> arrayList2;
+        SpecialEffectsController.Operation operation3;
+        SpecialEffectsController.Operation operation4;
+        View view2;
+        Object mergeTransitionsTogether;
+        ArrayMap arrayMap;
+        ArrayList<View> arrayList3;
+        DefaultSpecialEffectsController defaultSpecialEffectsController;
+        SpecialEffectsController.Operation operation5;
+        ArrayList<View> arrayList4;
+        Rect rect;
+        FragmentTransitionImpl fragmentTransitionImpl;
+        SpecialEffectsController.Operation operation6;
+        View view3;
+        SharedElementCallback enterTransitionCallback;
+        SharedElementCallback exitTransitionCallback;
+        ArrayList<String> arrayList5;
+        final View view4;
+        String findKeyForValue;
+        ArrayList<String> arrayList6;
+        DefaultSpecialEffectsController defaultSpecialEffectsController2 = this;
+        boolean z2 = z;
+        SpecialEffectsController.Operation operation7 = operation;
+        SpecialEffectsController.Operation operation8 = operation2;
+        HashMap hashMap = new HashMap();
+        final FragmentTransitionImpl fragmentTransitionImpl2 = null;
+        for (TransitionInfo transitionInfo : list) {
+            if (!transitionInfo.isVisibilityUnchanged()) {
+                FragmentTransitionImpl handlingImpl = transitionInfo.getHandlingImpl();
+                if (fragmentTransitionImpl2 == null) {
+                    fragmentTransitionImpl2 = handlingImpl;
+                } else if (handlingImpl != null && fragmentTransitionImpl2 != handlingImpl) {
+                    throw new IllegalArgumentException("Mixing framework transitions and AndroidX transitions is not allowed. Fragment " + transitionInfo.getOperation().getFragment() + " returned Transition " + transitionInfo.getTransition() + " which uses a different Transition  type than other Fragments.");
+                }
+            }
+        }
+        if (fragmentTransitionImpl2 == null) {
+            for (TransitionInfo transitionInfo2 : list) {
+                hashMap.put(transitionInfo2.getOperation(), Boolean.FALSE);
+                transitionInfo2.completeSpecialEffect();
+            }
+            return hashMap;
+        }
+        View view5 = new View(getContainer().getContext());
+        final Rect rect2 = new Rect();
+        ArrayList<View> arrayList7 = new ArrayList<>();
+        ArrayList<View> arrayList8 = new ArrayList<>();
+        ArrayMap arrayMap2 = new ArrayMap();
+        Object obj3 = null;
+        View view6 = null;
+        boolean z3 = false;
+        for (TransitionInfo transitionInfo3 : list) {
+            if (!transitionInfo3.hasSharedElementTransition() || operation7 == null || operation8 == null) {
+                arrayMap = arrayMap2;
+                arrayList3 = arrayList8;
+                defaultSpecialEffectsController = defaultSpecialEffectsController2;
+                operation5 = operation7;
+                arrayList4 = arrayList7;
+                rect = rect2;
+                fragmentTransitionImpl = fragmentTransitionImpl2;
+                operation6 = operation8;
+                view3 = view5;
+                view6 = view6;
+            } else {
+                Object wrapTransitionInSet = fragmentTransitionImpl2.wrapTransitionInSet(fragmentTransitionImpl2.cloneTransition(transitionInfo3.getSharedElementTransition()));
+                ArrayList<String> sharedElementSourceNames = operation2.getFragment().getSharedElementSourceNames();
+                ArrayList<String> sharedElementSourceNames2 = operation.getFragment().getSharedElementSourceNames();
+                ArrayList<String> sharedElementTargetNames = operation.getFragment().getSharedElementTargetNames();
+                View view7 = view6;
+                int i = 0;
+                while (i < sharedElementTargetNames.size()) {
+                    int indexOf = sharedElementSourceNames.indexOf(sharedElementTargetNames.get(i));
+                    ArrayList<String> arrayList9 = sharedElementTargetNames;
+                    if (indexOf != -1) {
+                        sharedElementSourceNames.set(indexOf, sharedElementSourceNames2.get(i));
+                    }
+                    i++;
+                    sharedElementTargetNames = arrayList9;
+                }
+                ArrayList<String> sharedElementTargetNames2 = operation2.getFragment().getSharedElementTargetNames();
+                if (!z2) {
+                    enterTransitionCallback = operation.getFragment().getExitTransitionCallback();
+                    exitTransitionCallback = operation2.getFragment().getEnterTransitionCallback();
+                } else {
+                    enterTransitionCallback = operation.getFragment().getEnterTransitionCallback();
+                    exitTransitionCallback = operation2.getFragment().getExitTransitionCallback();
+                }
+                int size = sharedElementSourceNames.size();
+                HashMap hashMap2 = hashMap;
+                int i2 = 0;
+                while (i2 < size) {
+                    arrayMap2.put(sharedElementSourceNames.get(i2), sharedElementTargetNames2.get(i2));
+                    i2++;
+                    size = size;
+                    view5 = view5;
+                }
+                View view8 = view5;
+                if (FragmentManager.isLoggingEnabled(2)) {
+                    Iterator<String> it2 = sharedElementTargetNames2.iterator();
+                    while (it2.hasNext()) {
+                        String next = it2.next();
+                        Iterator<String> it3 = it2;
+                        StringBuilder sb = new StringBuilder();
+                        sb.append("Name: ");
+                        sb.append(next);
+                        it2 = it3;
+                    }
+                    Iterator<String> it4 = sharedElementSourceNames.iterator();
+                    while (it4.hasNext()) {
+                        String next2 = it4.next();
+                        Iterator<String> it5 = it4;
+                        StringBuilder sb2 = new StringBuilder();
+                        sb2.append("Name: ");
+                        sb2.append(next2);
+                        it4 = it5;
+                    }
+                }
+                ArrayMap<String, View> arrayMap3 = new ArrayMap<>();
+                defaultSpecialEffectsController2.findNamedViews(arrayMap3, operation.getFragment().mView);
+                arrayMap3.retainAll(sharedElementSourceNames);
+                if (enterTransitionCallback != null) {
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb3 = new StringBuilder();
+                        sb3.append("Executing exit callback for operation ");
+                        sb3.append(operation7);
+                    }
+                    enterTransitionCallback.onMapSharedElements(sharedElementSourceNames, arrayMap3);
+                    int size2 = sharedElementSourceNames.size() - 1;
+                    while (size2 >= 0) {
+                        String str = sharedElementSourceNames.get(size2);
+                        View view9 = arrayMap3.get(str);
+                        if (view9 == null) {
+                            arrayMap2.remove(str);
+                            arrayList6 = sharedElementSourceNames;
+                        } else {
+                            arrayList6 = sharedElementSourceNames;
+                            if (!str.equals(ViewCompat.getTransitionName(view9))) {
+                                arrayMap2.put(ViewCompat.getTransitionName(view9), (String) arrayMap2.remove(str));
+                            }
+                        }
+                        size2--;
+                        sharedElementSourceNames = arrayList6;
+                    }
+                    arrayList5 = sharedElementSourceNames;
+                } else {
+                    arrayList5 = sharedElementSourceNames;
+                    arrayMap2.retainAll(arrayMap3.keySet());
+                }
+                final ArrayMap<String, View> arrayMap4 = new ArrayMap<>();
+                defaultSpecialEffectsController2.findNamedViews(arrayMap4, operation2.getFragment().mView);
+                arrayMap4.retainAll(sharedElementTargetNames2);
+                arrayMap4.retainAll(arrayMap2.values());
+                if (exitTransitionCallback != null) {
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb4 = new StringBuilder();
+                        sb4.append("Executing enter callback for operation ");
+                        sb4.append(operation8);
+                    }
+                    exitTransitionCallback.onMapSharedElements(sharedElementTargetNames2, arrayMap4);
+                    for (int size3 = sharedElementTargetNames2.size() - 1; size3 >= 0; size3--) {
+                        String str2 = sharedElementTargetNames2.get(size3);
+                        View view10 = arrayMap4.get(str2);
+                        if (view10 == null) {
+                            String findKeyForValue2 = FragmentTransition.findKeyForValue(arrayMap2, str2);
+                            if (findKeyForValue2 != null) {
+                                arrayMap2.remove(findKeyForValue2);
+                            }
+                        } else if (!str2.equals(ViewCompat.getTransitionName(view10)) && (findKeyForValue = FragmentTransition.findKeyForValue(arrayMap2, str2)) != null) {
+                            arrayMap2.put(findKeyForValue, ViewCompat.getTransitionName(view10));
+                        }
+                    }
+                } else {
+                    FragmentTransition.retainValues(arrayMap2, arrayMap4);
+                }
+                defaultSpecialEffectsController2.retainMatchingViews(arrayMap3, arrayMap2.keySet());
+                defaultSpecialEffectsController2.retainMatchingViews(arrayMap4, arrayMap2.values());
+                if (arrayMap2.isEmpty()) {
+                    arrayList7.clear();
+                    arrayList8.clear();
+                    arrayMap = arrayMap2;
+                    arrayList3 = arrayList8;
+                    defaultSpecialEffectsController = defaultSpecialEffectsController2;
+                    operation5 = operation7;
+                    arrayList4 = arrayList7;
+                    rect = rect2;
+                    fragmentTransitionImpl = fragmentTransitionImpl2;
+                    view6 = view7;
+                    hashMap = hashMap2;
+                    obj3 = null;
+                    operation6 = operation8;
+                    view3 = view8;
+                } else {
+                    FragmentTransition.callSharedElementStartEnd(operation2.getFragment(), operation.getFragment(), z2, arrayMap3, true);
+                    ArrayList<String> arrayList10 = arrayList5;
+                    arrayMap = arrayMap2;
+                    ArrayList<View> arrayList11 = arrayList8;
+                    OneShotPreDrawListener.add(getContainer(), new Runnable() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.6
+                        @Override // java.lang.Runnable
+                        public void run() {
+                            FragmentTransition.callSharedElementStartEnd(operation2.getFragment(), operation.getFragment(), z, arrayMap4, false);
+                        }
+                    });
+                    arrayList7.addAll(arrayMap3.values());
+                    if (arrayList10.isEmpty()) {
+                        view6 = view7;
+                    } else {
+                        view6 = arrayMap3.get(arrayList10.get(0));
+                        fragmentTransitionImpl2.setEpicenter(wrapTransitionInSet, view6);
+                    }
+                    arrayList3 = arrayList11;
+                    arrayList3.addAll(arrayMap4.values());
+                    if (sharedElementTargetNames2.isEmpty() || (view4 = arrayMap4.get(sharedElementTargetNames2.get(0))) == null) {
+                        defaultSpecialEffectsController = this;
+                    } else {
+                        defaultSpecialEffectsController = this;
+                        OneShotPreDrawListener.add(getContainer(), new Runnable() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.7
+                            @Override // java.lang.Runnable
+                            public void run() {
+                                fragmentTransitionImpl2.getBoundsOnScreen(view4, rect2);
+                            }
+                        });
+                        z3 = true;
+                    }
+                    fragmentTransitionImpl2.setSharedElementTargets(wrapTransitionInSet, view8, arrayList7);
+                    arrayList4 = arrayList7;
+                    rect = rect2;
+                    view3 = view8;
+                    fragmentTransitionImpl = fragmentTransitionImpl2;
+                    fragmentTransitionImpl2.scheduleRemoveTargets(wrapTransitionInSet, null, null, null, null, wrapTransitionInSet, arrayList3);
+                    Boolean bool = Boolean.TRUE;
+                    operation5 = operation;
+                    hashMap = hashMap2;
+                    hashMap.put(operation5, bool);
+                    operation6 = operation2;
+                    hashMap.put(operation6, bool);
+                    obj3 = wrapTransitionInSet;
+                }
+            }
+            z2 = z;
+            arrayList7 = arrayList4;
+            defaultSpecialEffectsController2 = defaultSpecialEffectsController;
+            rect2 = rect;
+            view5 = view3;
+            operation8 = operation6;
+            arrayMap2 = arrayMap;
+            arrayList8 = arrayList3;
+            operation7 = operation5;
+            fragmentTransitionImpl2 = fragmentTransitionImpl;
+        }
+        View view11 = view6;
+        ArrayMap arrayMap5 = arrayMap2;
+        ArrayList<View> arrayList12 = arrayList8;
+        DefaultSpecialEffectsController defaultSpecialEffectsController3 = defaultSpecialEffectsController2;
+        SpecialEffectsController.Operation operation9 = operation7;
+        ArrayList<View> arrayList13 = arrayList7;
+        Rect rect3 = rect2;
+        FragmentTransitionImpl fragmentTransitionImpl3 = fragmentTransitionImpl2;
+        SpecialEffectsController.Operation operation10 = operation8;
+        View view12 = view5;
+        ArrayList arrayList14 = new ArrayList();
+        Iterator<TransitionInfo> it6 = list.iterator();
+        Object obj4 = null;
+        Object obj5 = null;
+        while (it6.hasNext()) {
+            TransitionInfo next3 = it6.next();
+            if (next3.isVisibilityUnchanged()) {
+                hashMap.put(next3.getOperation(), Boolean.FALSE);
+                next3.completeSpecialEffect();
+            } else {
+                Object cloneTransition = fragmentTransitionImpl3.cloneTransition(next3.getTransition());
+                SpecialEffectsController.Operation operation11 = next3.getOperation();
+                boolean z4 = obj3 != null && (operation11 == operation9 || operation11 == operation10);
+                if (cloneTransition == null) {
+                    if (!z4) {
+                        hashMap.put(operation11, Boolean.FALSE);
+                        next3.completeSpecialEffect();
+                    }
+                    arrayList2 = arrayList12;
+                    arrayList = arrayList13;
+                    it = it6;
+                    view = view12;
+                    mergeTransitionsTogether = obj4;
+                    operation3 = operation10;
+                    view2 = view11;
+                } else {
+                    it = it6;
+                    final ArrayList<View> arrayList15 = new ArrayList<>();
+                    Object obj6 = obj4;
+                    defaultSpecialEffectsController3.captureTransitioningViews(arrayList15, operation11.getFragment().mView);
+                    if (z4) {
+                        if (operation11 == operation9) {
+                            arrayList15.removeAll(arrayList13);
+                        } else {
+                            arrayList15.removeAll(arrayList12);
+                        }
+                    }
+                    if (arrayList15.isEmpty()) {
+                        fragmentTransitionImpl3.addTarget(cloneTransition, view12);
+                        arrayList2 = arrayList12;
+                        arrayList = arrayList13;
+                        view = view12;
+                        operation4 = operation11;
+                        obj2 = obj5;
+                        operation3 = operation10;
+                        obj = obj6;
+                    } else {
+                        fragmentTransitionImpl3.addTargets(cloneTransition, arrayList15);
+                        view = view12;
+                        obj = obj6;
+                        arrayList = arrayList13;
+                        obj2 = obj5;
+                        arrayList2 = arrayList12;
+                        operation3 = operation10;
+                        fragmentTransitionImpl3.scheduleRemoveTargets(cloneTransition, cloneTransition, arrayList15, null, null, null, null);
+                        if (operation11.getFinalState() == SpecialEffectsController.Operation.State.GONE) {
+                            operation4 = operation11;
+                            list2.remove(operation4);
+                            ArrayList<View> arrayList16 = new ArrayList<>(arrayList15);
+                            arrayList16.remove(operation4.getFragment().mView);
+                            fragmentTransitionImpl3.scheduleHideFragmentView(cloneTransition, operation4.getFragment().mView, arrayList16);
+                            OneShotPreDrawListener.add(getContainer(), new Runnable() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.8
+                                @Override // java.lang.Runnable
+                                public void run() {
+                                    FragmentTransition.setViewVisibility(arrayList15, 4);
+                                }
+                            });
+                        } else {
+                            operation4 = operation11;
+                        }
+                    }
+                    if (operation4.getFinalState() == SpecialEffectsController.Operation.State.VISIBLE) {
+                        arrayList14.addAll(arrayList15);
+                        if (z3) {
+                            fragmentTransitionImpl3.setEpicenter(cloneTransition, rect3);
+                        }
+                        view2 = view11;
+                    } else {
+                        view2 = view11;
+                        fragmentTransitionImpl3.setEpicenter(cloneTransition, view2);
+                    }
+                    hashMap.put(operation4, Boolean.TRUE);
+                    if (next3.isOverlapAllowed()) {
+                        obj5 = fragmentTransitionImpl3.mergeTransitionsTogether(obj2, cloneTransition, null);
+                        mergeTransitionsTogether = obj;
+                    } else {
+                        mergeTransitionsTogether = fragmentTransitionImpl3.mergeTransitionsTogether(obj, cloneTransition, null);
+                        obj5 = obj2;
+                    }
+                }
+                operation10 = operation3;
+                obj4 = mergeTransitionsTogether;
+                view11 = view2;
+                view12 = view;
+                arrayList13 = arrayList;
+                arrayList12 = arrayList2;
+                it6 = it;
+            }
+        }
+        ArrayList<View> arrayList17 = arrayList12;
+        ArrayList<View> arrayList18 = arrayList13;
+        SpecialEffectsController.Operation operation12 = operation10;
+        Object mergeTransitionsInSequence = fragmentTransitionImpl3.mergeTransitionsInSequence(obj5, obj4, obj3);
+        if (mergeTransitionsInSequence == null) {
+            return hashMap;
+        }
+        for (final TransitionInfo transitionInfo4 : list) {
+            if (!transitionInfo4.isVisibilityUnchanged()) {
+                Object transition = transitionInfo4.getTransition();
+                final SpecialEffectsController.Operation operation13 = transitionInfo4.getOperation();
+                boolean z5 = obj3 != null && (operation13 == operation9 || operation13 == operation12);
+                if (transition != null || z5) {
+                    if (!ViewCompat.isLaidOut(getContainer())) {
+                        if (FragmentManager.isLoggingEnabled(2)) {
+                            StringBuilder sb5 = new StringBuilder();
+                            sb5.append("SpecialEffectsController: Container ");
+                            sb5.append(getContainer());
+                            sb5.append(" has not been laid out. Completing operation ");
+                            sb5.append(operation13);
+                        }
+                        transitionInfo4.completeSpecialEffect();
+                    } else {
+                        fragmentTransitionImpl3.setListenerForTransitionEnd(transitionInfo4.getOperation().getFragment(), mergeTransitionsInSequence, transitionInfo4.getSignal(), new Runnable() { // from class: androidx.fragment.app.DefaultSpecialEffectsController.9
+                            @Override // java.lang.Runnable
+                            public void run() {
+                                transitionInfo4.completeSpecialEffect();
+                                if (FragmentManager.isLoggingEnabled(2)) {
+                                    StringBuilder sb6 = new StringBuilder();
+                                    sb6.append("Transition for operation ");
+                                    sb6.append(operation13);
+                                    sb6.append("has completed");
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        if (!ViewCompat.isLaidOut(getContainer())) {
+            return hashMap;
+        }
+        FragmentTransition.setViewVisibility(arrayList14, 4);
+        ArrayList<String> prepareSetNameOverridesReordered = fragmentTransitionImpl3.prepareSetNameOverridesReordered(arrayList17);
+        if (FragmentManager.isLoggingEnabled(2)) {
+            Iterator<View> it7 = arrayList18.iterator();
+            while (it7.hasNext()) {
+                View next4 = it7.next();
+                StringBuilder sb6 = new StringBuilder();
+                sb6.append("View: ");
+                sb6.append(next4);
+                sb6.append(" Name: ");
+                sb6.append(ViewCompat.getTransitionName(next4));
+            }
+            Iterator<View> it8 = arrayList17.iterator();
+            while (it8.hasNext()) {
+                View next5 = it8.next();
+                StringBuilder sb7 = new StringBuilder();
+                sb7.append("View: ");
+                sb7.append(next5);
+                sb7.append(" Name: ");
+                sb7.append(ViewCompat.getTransitionName(next5));
+            }
+        }
+        fragmentTransitionImpl3.beginDelayedTransition(getContainer(), mergeTransitionsInSequence);
+        fragmentTransitionImpl3.setNameOverridesReordered(getContainer(), arrayList18, arrayList17, prepareSetNameOverridesReordered, arrayMap5);
+        FragmentTransition.setViewVisibility(arrayList14, 0);
+        fragmentTransitionImpl3.swapSharedElementTargets(obj3, arrayList18, arrayList17);
+        return hashMap;
+    }
+
+    public void retainMatchingViews(@NonNull ArrayMap<String, View> arrayMap, @NonNull Collection<String> collection) {
+        Iterator<Map.Entry<String, View>> it = arrayMap.entrySet().iterator();
+        while (it.hasNext()) {
+            if (!collection.contains(ViewCompat.getTransitionName(it.next().getValue()))) {
+                it.remove();
+            }
+        }
+    }
+
+    public void captureTransitioningViews(ArrayList<View> arrayList, View view) {
+        if (view instanceof ViewGroup) {
+            ViewGroup viewGroup = (ViewGroup) view;
+            if (ViewGroupCompat.isTransitionGroup(viewGroup)) {
+                if (arrayList.contains(view)) {
+                    return;
+                }
+                arrayList.add(viewGroup);
+                return;
+            }
+            int childCount = viewGroup.getChildCount();
+            for (int i = 0; i < childCount; i++) {
+                View childAt = viewGroup.getChildAt(i);
+                if (childAt.getVisibility() == 0) {
+                    captureTransitioningViews(arrayList, childAt);
+                }
+            }
+            return;
+        }
+        if (arrayList.contains(view)) {
+            return;
+        }
+        arrayList.add(view);
+    }
+
+    public void findNamedViews(Map<String, View> map, @NonNull View view) {
+        String transitionName = ViewCompat.getTransitionName(view);
+        if (transitionName != null) {
+            map.put(transitionName, view);
+        }
+        if (view instanceof ViewGroup) {
+            ViewGroup viewGroup = (ViewGroup) view;
+            int childCount = viewGroup.getChildCount();
+            for (int i = 0; i < childCount; i++) {
+                View childAt = viewGroup.getChildAt(i);
+                if (childAt.getVisibility() == 0) {
+                    findNamedViews(map, childAt);
+                }
+            }
+        }
+    }
+
+    public void applyContainerChanges(@NonNull SpecialEffectsController.Operation operation) {
+        operation.getFinalState().applyState(operation.getFragment().mView);
+    }
+
+    public static class SpecialEffectsInfo {
+
+        @NonNull
+        private final SpecialEffectsController.Operation mOperation;
+
+        @NonNull
+        private final CancellationSignal mSignal;
+
+        @NonNull
+        public SpecialEffectsController.Operation getOperation() {
+            return this.mOperation;
+        }
+
+        @NonNull
+        public CancellationSignal getSignal() {
+            return this.mSignal;
+        }
+
+        public SpecialEffectsInfo(@NonNull SpecialEffectsController.Operation operation, @NonNull CancellationSignal cancellationSignal) {
+            this.mOperation = operation;
+            this.mSignal = cancellationSignal;
+        }
+
+        public boolean isVisibilityUnchanged() {
+            SpecialEffectsController.Operation.State state;
+            SpecialEffectsController.Operation.State from = SpecialEffectsController.Operation.State.from(this.mOperation.getFragment().mView);
+            SpecialEffectsController.Operation.State finalState = this.mOperation.getFinalState();
+            return from == finalState || !(from == (state = SpecialEffectsController.Operation.State.VISIBLE) || finalState == state);
+        }
+
+        public void completeSpecialEffect() {
+            this.mOperation.completeSpecialEffect(this.mSignal);
+        }
+    }
+
+    public static class AnimationInfo extends SpecialEffectsInfo {
+
+        @Nullable
+        private FragmentAnim.AnimationOrAnimator mAnimation;
+        private boolean mIsPop;
+        private boolean mLoadedAnim;
+
+        public AnimationInfo(@NonNull SpecialEffectsController.Operation operation, @NonNull CancellationSignal cancellationSignal, boolean z) {
+            super(operation, cancellationSignal);
+            this.mLoadedAnim = false;
+            this.mIsPop = z;
+        }
+
+        @Nullable
+        public FragmentAnim.AnimationOrAnimator getAnimation(@NonNull Context context) {
+            if (this.mLoadedAnim) {
+                return this.mAnimation;
+            }
+            FragmentAnim.AnimationOrAnimator loadAnimation = FragmentAnim.loadAnimation(context, getOperation().getFragment(), getOperation().getFinalState() == SpecialEffectsController.Operation.State.VISIBLE, this.mIsPop);
+            this.mAnimation = loadAnimation;
+            this.mLoadedAnim = true;
+            return loadAnimation;
+        }
+    }
+
+    public static class TransitionInfo extends SpecialEffectsInfo {
+        private final boolean mOverlapAllowed;
+
+        @Nullable
+        private final Object mSharedElementTransition;
+
+        @Nullable
+        private final Object mTransition;
+
+        @Nullable
+        public Object getSharedElementTransition() {
+            return this.mSharedElementTransition;
+        }
+
+        @Nullable
+        public Object getTransition() {
+            return this.mTransition;
+        }
+
+        public boolean hasSharedElementTransition() {
+            return this.mSharedElementTransition != null;
+        }
+
+        public boolean isOverlapAllowed() {
+            return this.mOverlapAllowed;
+        }
+
+        public TransitionInfo(@NonNull SpecialEffectsController.Operation operation, @NonNull CancellationSignal cancellationSignal, boolean z, boolean z2) {
+            super(operation, cancellationSignal);
+            Object exitTransition;
+            Object enterTransition;
+            boolean allowEnterTransitionOverlap;
+            if (operation.getFinalState() == SpecialEffectsController.Operation.State.VISIBLE) {
+                if (z) {
+                    enterTransition = operation.getFragment().getReenterTransition();
+                } else {
+                    enterTransition = operation.getFragment().getEnterTransition();
+                }
+                this.mTransition = enterTransition;
+                if (z) {
+                    allowEnterTransitionOverlap = operation.getFragment().getAllowReturnTransitionOverlap();
+                } else {
+                    allowEnterTransitionOverlap = operation.getFragment().getAllowEnterTransitionOverlap();
+                }
+                this.mOverlapAllowed = allowEnterTransitionOverlap;
+            } else {
+                if (z) {
+                    exitTransition = operation.getFragment().getReturnTransition();
+                } else {
+                    exitTransition = operation.getFragment().getExitTransition();
+                }
+                this.mTransition = exitTransition;
+                this.mOverlapAllowed = true;
+            }
+            if (!z2) {
+                this.mSharedElementTransition = null;
+            } else if (z) {
+                this.mSharedElementTransition = operation.getFragment().getSharedElementReturnTransition();
+            } else {
+                this.mSharedElementTransition = operation.getFragment().getSharedElementEnterTransition();
+            }
+        }
+
+        @Nullable
+        public FragmentTransitionImpl getHandlingImpl() {
+            FragmentTransitionImpl handlingImpl = getHandlingImpl(this.mTransition);
+            FragmentTransitionImpl handlingImpl2 = getHandlingImpl(this.mSharedElementTransition);
+            if (handlingImpl == null || handlingImpl2 == null || handlingImpl == handlingImpl2) {
+                return handlingImpl != null ? handlingImpl : handlingImpl2;
+            }
+            throw new IllegalArgumentException("Mixing framework transitions and AndroidX transitions is not allowed. Fragment " + getOperation().getFragment() + " returned Transition " + this.mTransition + " which uses a different Transition  type than its shared element transition " + this.mSharedElementTransition);
+        }
+
+        @Nullable
+        private FragmentTransitionImpl getHandlingImpl(Object obj) {
+            if (obj == null) {
+                return null;
+            }
+            FragmentTransitionImpl fragmentTransitionImpl = FragmentTransition.PLATFORM_IMPL;
+            if (fragmentTransitionImpl != null && fragmentTransitionImpl.canHandle(obj)) {
+                return fragmentTransitionImpl;
+            }
+            FragmentTransitionImpl fragmentTransitionImpl2 = FragmentTransition.SUPPORT_IMPL;
+            if (fragmentTransitionImpl2 != null && fragmentTransitionImpl2.canHandle(obj)) {
+                return fragmentTransitionImpl2;
+            }
+            throw new IllegalArgumentException("Transition " + obj + " for fragment " + getOperation().getFragment() + " is not a valid framework Transition or AndroidX Transition");
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/DialogFragment.java

@@ -0,0 +1,592 @@
+package androidx.fragment.app;
+
+import android.R;
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import androidx.activity.ComponentDialog;
+import androidx.annotation.LayoutRes;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.StyleRes;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.Observer;
+import androidx.lifecycle.ViewTreeLifecycleOwner;
+import androidx.lifecycle.ViewTreeViewModelStoreOwner;
+import androidx.savedstate.ViewTreeSavedStateRegistryOwner;
+
+/* loaded from: classes.dex */
+public class DialogFragment extends Fragment implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener {
+    private static final String SAVED_BACK_STACK_ID = "android:backStackId";
+    private static final String SAVED_CANCELABLE = "android:cancelable";
+    private static final String SAVED_DIALOG_STATE_TAG = "android:savedDialogState";
+    private static final String SAVED_INTERNAL_DIALOG_SHOWING = "android:dialogShowing";
+    private static final String SAVED_SHOWS_DIALOG = "android:showsDialog";
+    private static final String SAVED_STYLE = "android:style";
+    private static final String SAVED_THEME = "android:theme";
+    public static final int STYLE_NORMAL = 0;
+    public static final int STYLE_NO_FRAME = 2;
+    public static final int STYLE_NO_INPUT = 3;
+    public static final int STYLE_NO_TITLE = 1;
+    private int mBackStackId;
+    private boolean mCancelable;
+    private boolean mCreatingDialog;
+
+    @Nullable
+    private Dialog mDialog;
+    private boolean mDialogCreated;
+    private Runnable mDismissRunnable;
+    private boolean mDismissed;
+    private Handler mHandler;
+    private Observer<LifecycleOwner> mObserver;
+    private DialogInterface.OnCancelListener mOnCancelListener;
+    private DialogInterface.OnDismissListener mOnDismissListener;
+    private boolean mShownByMe;
+    private boolean mShowsDialog;
+    private int mStyle;
+    private int mTheme;
+    private boolean mViewDestroyed;
+
+    @Nullable
+    public Dialog getDialog() {
+        return this.mDialog;
+    }
+
+    public boolean getShowsDialog() {
+        return this.mShowsDialog;
+    }
+
+    @StyleRes
+    public int getTheme() {
+        return this.mTheme;
+    }
+
+    public boolean isCancelable() {
+        return this.mCancelable;
+    }
+
+    public void onCancel(@NonNull DialogInterface dialogInterface) {
+    }
+
+    public boolean onHasView() {
+        return this.mDialogCreated;
+    }
+
+    public void setShowsDialog(boolean z) {
+        this.mShowsDialog = z;
+    }
+
+    public DialogFragment() {
+        this.mDismissRunnable = new Runnable() { // from class: androidx.fragment.app.DialogFragment.1
+            @Override // java.lang.Runnable
+            @SuppressLint({"SyntheticAccessor"})
+            public void run() {
+                DialogFragment.this.mOnDismissListener.onDismiss(DialogFragment.this.mDialog);
+            }
+        };
+        this.mOnCancelListener = new DialogInterface.OnCancelListener() { // from class: androidx.fragment.app.DialogFragment.2
+            @Override // android.content.DialogInterface.OnCancelListener
+            @SuppressLint({"SyntheticAccessor"})
+            public void onCancel(@Nullable DialogInterface dialogInterface) {
+                if (DialogFragment.this.mDialog != null) {
+                    DialogFragment dialogFragment = DialogFragment.this;
+                    dialogFragment.onCancel(dialogFragment.mDialog);
+                }
+            }
+        };
+        this.mOnDismissListener = new DialogInterface.OnDismissListener() { // from class: androidx.fragment.app.DialogFragment.3
+            @Override // android.content.DialogInterface.OnDismissListener
+            @SuppressLint({"SyntheticAccessor"})
+            public void onDismiss(@Nullable DialogInterface dialogInterface) {
+                if (DialogFragment.this.mDialog != null) {
+                    DialogFragment dialogFragment = DialogFragment.this;
+                    dialogFragment.onDismiss(dialogFragment.mDialog);
+                }
+            }
+        };
+        this.mStyle = 0;
+        this.mTheme = 0;
+        this.mCancelable = true;
+        this.mShowsDialog = true;
+        this.mBackStackId = -1;
+        this.mObserver = new Observer<LifecycleOwner>() { // from class: androidx.fragment.app.DialogFragment.4
+            @Override // androidx.lifecycle.Observer
+            @SuppressLint({"SyntheticAccessor"})
+            public void onChanged(LifecycleOwner lifecycleOwner) {
+                if (lifecycleOwner == null || !DialogFragment.this.mShowsDialog) {
+                    return;
+                }
+                View requireView = DialogFragment.this.requireView();
+                if (requireView.getParent() == null) {
+                    if (DialogFragment.this.mDialog != null) {
+                        if (FragmentManager.isLoggingEnabled(3)) {
+                            StringBuilder sb = new StringBuilder();
+                            sb.append("DialogFragment ");
+                            sb.append(this);
+                            sb.append(" setting the content view on ");
+                            sb.append(DialogFragment.this.mDialog);
+                        }
+                        DialogFragment.this.mDialog.setContentView(requireView);
+                        return;
+                    }
+                    return;
+                }
+                throw new IllegalStateException("DialogFragment can not be attached to a container view");
+            }
+        };
+        this.mDialogCreated = false;
+    }
+
+    public DialogFragment(@LayoutRes int i) {
+        super(i);
+        this.mDismissRunnable = new Runnable() { // from class: androidx.fragment.app.DialogFragment.1
+            @Override // java.lang.Runnable
+            @SuppressLint({"SyntheticAccessor"})
+            public void run() {
+                DialogFragment.this.mOnDismissListener.onDismiss(DialogFragment.this.mDialog);
+            }
+        };
+        this.mOnCancelListener = new DialogInterface.OnCancelListener() { // from class: androidx.fragment.app.DialogFragment.2
+            @Override // android.content.DialogInterface.OnCancelListener
+            @SuppressLint({"SyntheticAccessor"})
+            public void onCancel(@Nullable DialogInterface dialogInterface) {
+                if (DialogFragment.this.mDialog != null) {
+                    DialogFragment dialogFragment = DialogFragment.this;
+                    dialogFragment.onCancel(dialogFragment.mDialog);
+                }
+            }
+        };
+        this.mOnDismissListener = new DialogInterface.OnDismissListener() { // from class: androidx.fragment.app.DialogFragment.3
+            @Override // android.content.DialogInterface.OnDismissListener
+            @SuppressLint({"SyntheticAccessor"})
+            public void onDismiss(@Nullable DialogInterface dialogInterface) {
+                if (DialogFragment.this.mDialog != null) {
+                    DialogFragment dialogFragment = DialogFragment.this;
+                    dialogFragment.onDismiss(dialogFragment.mDialog);
+                }
+            }
+        };
+        this.mStyle = 0;
+        this.mTheme = 0;
+        this.mCancelable = true;
+        this.mShowsDialog = true;
+        this.mBackStackId = -1;
+        this.mObserver = new Observer<LifecycleOwner>() { // from class: androidx.fragment.app.DialogFragment.4
+            @Override // androidx.lifecycle.Observer
+            @SuppressLint({"SyntheticAccessor"})
+            public void onChanged(LifecycleOwner lifecycleOwner) {
+                if (lifecycleOwner == null || !DialogFragment.this.mShowsDialog) {
+                    return;
+                }
+                View requireView = DialogFragment.this.requireView();
+                if (requireView.getParent() == null) {
+                    if (DialogFragment.this.mDialog != null) {
+                        if (FragmentManager.isLoggingEnabled(3)) {
+                            StringBuilder sb = new StringBuilder();
+                            sb.append("DialogFragment ");
+                            sb.append(this);
+                            sb.append(" setting the content view on ");
+                            sb.append(DialogFragment.this.mDialog);
+                        }
+                        DialogFragment.this.mDialog.setContentView(requireView);
+                        return;
+                    }
+                    return;
+                }
+                throw new IllegalStateException("DialogFragment can not be attached to a container view");
+            }
+        };
+        this.mDialogCreated = false;
+    }
+
+    public void setStyle(int i, @StyleRes int i2) {
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Setting style and theme for DialogFragment ");
+            sb.append(this);
+            sb.append(" to ");
+            sb.append(i);
+            sb.append(", ");
+            sb.append(i2);
+        }
+        this.mStyle = i;
+        if (i == 2 || i == 3) {
+            this.mTheme = R.style.Theme.Panel;
+        }
+        if (i2 != 0) {
+            this.mTheme = i2;
+        }
+    }
+
+    public void show(@NonNull FragmentManager fragmentManager, @Nullable String str) {
+        this.mDismissed = false;
+        this.mShownByMe = true;
+        FragmentTransaction beginTransaction = fragmentManager.beginTransaction();
+        beginTransaction.setReorderingAllowed(true);
+        beginTransaction.add(this, str);
+        beginTransaction.commit();
+    }
+
+    public int show(@NonNull FragmentTransaction fragmentTransaction, @Nullable String str) {
+        this.mDismissed = false;
+        this.mShownByMe = true;
+        fragmentTransaction.add(this, str);
+        this.mViewDestroyed = false;
+        int commit = fragmentTransaction.commit();
+        this.mBackStackId = commit;
+        return commit;
+    }
+
+    public void showNow(@NonNull FragmentManager fragmentManager, @Nullable String str) {
+        this.mDismissed = false;
+        this.mShownByMe = true;
+        FragmentTransaction beginTransaction = fragmentManager.beginTransaction();
+        beginTransaction.setReorderingAllowed(true);
+        beginTransaction.add(this, str);
+        beginTransaction.commitNow();
+    }
+
+    public void dismiss() {
+        dismissInternal(false, false, false);
+    }
+
+    @MainThread
+    public void dismissNow() {
+        dismissInternal(false, false, true);
+    }
+
+    public void dismissAllowingStateLoss() {
+        dismissInternal(true, false, false);
+    }
+
+    private void dismissInternal(boolean z, boolean z2, boolean z3) {
+        if (this.mDismissed) {
+            return;
+        }
+        this.mDismissed = true;
+        this.mShownByMe = false;
+        Dialog dialog = this.mDialog;
+        if (dialog != null) {
+            dialog.setOnDismissListener(null);
+            this.mDialog.dismiss();
+            if (!z2) {
+                if (Looper.myLooper() == this.mHandler.getLooper()) {
+                    onDismiss(this.mDialog);
+                } else {
+                    this.mHandler.post(this.mDismissRunnable);
+                }
+            }
+        }
+        this.mViewDestroyed = true;
+        if (this.mBackStackId >= 0) {
+            if (z3) {
+                getParentFragmentManager().popBackStackImmediate(this.mBackStackId, 1);
+            } else {
+                getParentFragmentManager().popBackStack(this.mBackStackId, 1, z);
+            }
+            this.mBackStackId = -1;
+            return;
+        }
+        FragmentTransaction beginTransaction = getParentFragmentManager().beginTransaction();
+        beginTransaction.setReorderingAllowed(true);
+        beginTransaction.remove(this);
+        if (z3) {
+            beginTransaction.commitNow();
+        } else if (z) {
+            beginTransaction.commitAllowingStateLoss();
+        } else {
+            beginTransaction.commit();
+        }
+    }
+
+    @NonNull
+    public final Dialog requireDialog() {
+        Dialog dialog = getDialog();
+        if (dialog != null) {
+            return dialog;
+        }
+        throw new IllegalStateException("DialogFragment " + this + " does not have a Dialog.");
+    }
+
+    public void setCancelable(boolean z) {
+        this.mCancelable = z;
+        Dialog dialog = this.mDialog;
+        if (dialog != null) {
+            dialog.setCancelable(z);
+        }
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @MainThread
+    public void onAttach(@NonNull Context context) {
+        super.onAttach(context);
+        getViewLifecycleOwnerLiveData().observeForever(this.mObserver);
+        if (this.mShownByMe) {
+            return;
+        }
+        this.mDismissed = false;
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @MainThread
+    public void onDetach() {
+        super.onDetach();
+        if (!this.mShownByMe && !this.mDismissed) {
+            this.mDismissed = true;
+        }
+        getViewLifecycleOwnerLiveData().removeObserver(this.mObserver);
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @MainThread
+    public void onCreate(@Nullable Bundle bundle) {
+        super.onCreate(bundle);
+        this.mHandler = new Handler();
+        this.mShowsDialog = this.mContainerId == 0;
+        if (bundle != null) {
+            this.mStyle = bundle.getInt(SAVED_STYLE, 0);
+            this.mTheme = bundle.getInt(SAVED_THEME, 0);
+            this.mCancelable = bundle.getBoolean(SAVED_CANCELABLE, true);
+            this.mShowsDialog = bundle.getBoolean(SAVED_SHOWS_DIALOG, this.mShowsDialog);
+            this.mBackStackId = bundle.getInt(SAVED_BACK_STACK_ID, -1);
+        }
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    public void performCreateView(@NonNull LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
+        Bundle bundle2;
+        super.performCreateView(layoutInflater, viewGroup, bundle);
+        if (this.mView != null || this.mDialog == null || bundle == null || (bundle2 = bundle.getBundle(SAVED_DIALOG_STATE_TAG)) == null) {
+            return;
+        }
+        this.mDialog.onRestoreInstanceState(bundle2);
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @NonNull
+    public FragmentContainer createFragmentContainer() {
+        final FragmentContainer createFragmentContainer = super.createFragmentContainer();
+        return new FragmentContainer() { // from class: androidx.fragment.app.DialogFragment.5
+            @Override // androidx.fragment.app.FragmentContainer
+            @Nullable
+            public View onFindViewById(int i) {
+                if (createFragmentContainer.onHasView()) {
+                    return createFragmentContainer.onFindViewById(i);
+                }
+                return DialogFragment.this.onFindViewById(i);
+            }
+
+            @Override // androidx.fragment.app.FragmentContainer
+            public boolean onHasView() {
+                return createFragmentContainer.onHasView() || DialogFragment.this.onHasView();
+            }
+        };
+    }
+
+    @Nullable
+    public View onFindViewById(int i) {
+        Dialog dialog = this.mDialog;
+        if (dialog != null) {
+            return dialog.findViewById(i);
+        }
+        return null;
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @NonNull
+    public LayoutInflater onGetLayoutInflater(@Nullable Bundle bundle) {
+        LayoutInflater onGetLayoutInflater = super.onGetLayoutInflater(bundle);
+        if (!this.mShowsDialog || this.mCreatingDialog) {
+            if (FragmentManager.isLoggingEnabled(2)) {
+                String str = "getting layout inflater for DialogFragment " + this;
+                if (!this.mShowsDialog) {
+                    StringBuilder sb = new StringBuilder();
+                    sb.append("mShowsDialog = false: ");
+                    sb.append(str);
+                } else {
+                    StringBuilder sb2 = new StringBuilder();
+                    sb2.append("mCreatingDialog = true: ");
+                    sb2.append(str);
+                }
+            }
+            return onGetLayoutInflater;
+        }
+        prepareDialog(bundle);
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb3 = new StringBuilder();
+            sb3.append("get layout inflater for DialogFragment ");
+            sb3.append(this);
+            sb3.append(" from dialog context");
+        }
+        Dialog dialog = this.mDialog;
+        return dialog != null ? onGetLayoutInflater.cloneInContext(dialog.getContext()) : onGetLayoutInflater;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public void setupDialog(@NonNull Dialog dialog, int i) {
+        if (i != 1 && i != 2) {
+            if (i != 3) {
+                return;
+            }
+            Window window = dialog.getWindow();
+            if (window != null) {
+                window.addFlags(24);
+            }
+        }
+        dialog.requestWindowFeature(1);
+    }
+
+    @NonNull
+    @MainThread
+    public Dialog onCreateDialog(@Nullable Bundle bundle) {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("onCreateDialog called for DialogFragment ");
+            sb.append(this);
+        }
+        return new ComponentDialog(requireContext(), getTheme());
+    }
+
+    @Override // android.content.DialogInterface.OnDismissListener
+    public void onDismiss(@NonNull DialogInterface dialogInterface) {
+        if (this.mViewDestroyed) {
+            return;
+        }
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("onDismiss called for DialogFragment ");
+            sb.append(this);
+        }
+        dismissInternal(true, true, false);
+    }
+
+    private void prepareDialog(@Nullable Bundle bundle) {
+        if (this.mShowsDialog && !this.mDialogCreated) {
+            try {
+                this.mCreatingDialog = true;
+                Dialog onCreateDialog = onCreateDialog(bundle);
+                this.mDialog = onCreateDialog;
+                if (this.mShowsDialog) {
+                    setupDialog(onCreateDialog, this.mStyle);
+                    Context context = getContext();
+                    if (context instanceof Activity) {
+                        this.mDialog.setOwnerActivity((Activity) context);
+                    }
+                    this.mDialog.setCancelable(this.mCancelable);
+                    this.mDialog.setOnCancelListener(this.mOnCancelListener);
+                    this.mDialog.setOnDismissListener(this.mOnDismissListener);
+                    this.mDialogCreated = true;
+                } else {
+                    this.mDialog = null;
+                }
+                this.mCreatingDialog = false;
+            } catch (Throwable th) {
+                this.mCreatingDialog = false;
+                throw th;
+            }
+        }
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @MainThread
+    public void onViewStateRestored(@Nullable Bundle bundle) {
+        Bundle bundle2;
+        super.onViewStateRestored(bundle);
+        if (this.mDialog == null || bundle == null || (bundle2 = bundle.getBundle(SAVED_DIALOG_STATE_TAG)) == null) {
+            return;
+        }
+        this.mDialog.onRestoreInstanceState(bundle2);
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @MainThread
+    @Deprecated
+    public void onActivityCreated(@Nullable Bundle bundle) {
+        super.onActivityCreated(bundle);
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @MainThread
+    public void onStart() {
+        super.onStart();
+        Dialog dialog = this.mDialog;
+        if (dialog != null) {
+            this.mViewDestroyed = false;
+            dialog.show();
+            View decorView = this.mDialog.getWindow().getDecorView();
+            ViewTreeLifecycleOwner.set(decorView, this);
+            ViewTreeViewModelStoreOwner.set(decorView, this);
+            ViewTreeSavedStateRegistryOwner.set(decorView, this);
+        }
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @MainThread
+    public void onSaveInstanceState(@NonNull Bundle bundle) {
+        super.onSaveInstanceState(bundle);
+        Dialog dialog = this.mDialog;
+        if (dialog != null) {
+            Bundle onSaveInstanceState = dialog.onSaveInstanceState();
+            onSaveInstanceState.putBoolean(SAVED_INTERNAL_DIALOG_SHOWING, false);
+            bundle.putBundle(SAVED_DIALOG_STATE_TAG, onSaveInstanceState);
+        }
+        int i = this.mStyle;
+        if (i != 0) {
+            bundle.putInt(SAVED_STYLE, i);
+        }
+        int i2 = this.mTheme;
+        if (i2 != 0) {
+            bundle.putInt(SAVED_THEME, i2);
+        }
+        boolean z = this.mCancelable;
+        if (!z) {
+            bundle.putBoolean(SAVED_CANCELABLE, z);
+        }
+        boolean z2 = this.mShowsDialog;
+        if (!z2) {
+            bundle.putBoolean(SAVED_SHOWS_DIALOG, z2);
+        }
+        int i3 = this.mBackStackId;
+        if (i3 != -1) {
+            bundle.putInt(SAVED_BACK_STACK_ID, i3);
+        }
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @MainThread
+    public void onStop() {
+        super.onStop();
+        Dialog dialog = this.mDialog;
+        if (dialog != null) {
+            dialog.hide();
+        }
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @MainThread
+    public void onDestroyView() {
+        super.onDestroyView();
+        Dialog dialog = this.mDialog;
+        if (dialog != null) {
+            this.mViewDestroyed = true;
+            dialog.setOnDismissListener(null);
+            this.mDialog.dismiss();
+            if (!this.mDismissed) {
+                onDismiss(this.mDialog);
+            }
+            this.mDialog = null;
+            this.mDialogCreated = false;
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentActivity.java

@@ -0,0 +1,516 @@
+package androidx.fragment.app;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.Window;
+import androidx.activity.ComponentActivity;
+import androidx.activity.OnBackPressedDispatcher;
+import androidx.activity.OnBackPressedDispatcherOwner;
+import androidx.activity.contextaware.OnContextAvailableListener;
+import androidx.activity.result.ActivityResultRegistry;
+import androidx.activity.result.ActivityResultRegistryOwner;
+import androidx.annotation.CallSuper;
+import androidx.annotation.ContentView;
+import androidx.annotation.LayoutRes;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.app.ActivityCompat;
+import androidx.core.app.MultiWindowModeChangedInfo;
+import androidx.core.app.OnMultiWindowModeChangedProvider;
+import androidx.core.app.OnPictureInPictureModeChangedProvider;
+import androidx.core.app.PictureInPictureModeChangedInfo;
+import androidx.core.app.SharedElementCallback;
+import androidx.core.content.OnConfigurationChangedProvider;
+import androidx.core.content.OnTrimMemoryProvider;
+import androidx.core.util.Consumer;
+import androidx.core.view.MenuHost;
+import androidx.core.view.MenuProvider;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LifecycleRegistry;
+import androidx.lifecycle.ViewModelStore;
+import androidx.lifecycle.ViewModelStoreOwner;
+import androidx.loader.app.LoaderManager;
+import androidx.savedstate.SavedStateRegistry;
+import androidx.savedstate.SavedStateRegistryOwner;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+
+/* loaded from: classes.dex */
+public class FragmentActivity extends ComponentActivity implements ActivityCompat.OnRequestPermissionsResultCallback, ActivityCompat.RequestPermissionsRequestCodeValidator {
+    static final String LIFECYCLE_TAG = "android:support:lifecycle";
+    boolean mCreated;
+    final LifecycleRegistry mFragmentLifecycleRegistry;
+    final FragmentController mFragments;
+    boolean mResumed;
+    boolean mStopped;
+
+    @MainThread
+    @Deprecated
+    public void onAttachFragment(@NonNull Fragment fragment) {
+    }
+
+    @Override // androidx.core.app.ActivityCompat.RequestPermissionsRequestCodeValidator
+    @Deprecated
+    public final void validateRequestPermissionsRequestCode(int i) {
+    }
+
+    public FragmentActivity() {
+        this.mFragments = FragmentController.createController(new HostCallbacks());
+        this.mFragmentLifecycleRegistry = new LifecycleRegistry(this);
+        this.mStopped = true;
+        init();
+    }
+
+    @ContentView
+    public FragmentActivity(@LayoutRes int i) {
+        super(i);
+        this.mFragments = FragmentController.createController(new HostCallbacks());
+        this.mFragmentLifecycleRegistry = new LifecycleRegistry(this);
+        this.mStopped = true;
+        init();
+    }
+
+    private void init() {
+        getSavedStateRegistry().registerSavedStateProvider(LIFECYCLE_TAG, new SavedStateRegistry.SavedStateProvider() { // from class: androidx.fragment.app.FragmentActivity$$ExternalSyntheticLambda0
+            @Override // androidx.savedstate.SavedStateRegistry.SavedStateProvider
+            public final Bundle saveState() {
+                Bundle lambda$init$0;
+                lambda$init$0 = FragmentActivity.this.lambda$init$0();
+                return lambda$init$0;
+            }
+        });
+        addOnConfigurationChangedListener(new Consumer() { // from class: androidx.fragment.app.FragmentActivity$$ExternalSyntheticLambda1
+            @Override // androidx.core.util.Consumer
+            public final void accept(Object obj) {
+                FragmentActivity.this.lambda$init$1((Configuration) obj);
+            }
+        });
+        addOnNewIntentListener(new Consumer() { // from class: androidx.fragment.app.FragmentActivity$$ExternalSyntheticLambda2
+            @Override // androidx.core.util.Consumer
+            public final void accept(Object obj) {
+                FragmentActivity.this.lambda$init$2((Intent) obj);
+            }
+        });
+        addOnContextAvailableListener(new OnContextAvailableListener() { // from class: androidx.fragment.app.FragmentActivity$$ExternalSyntheticLambda3
+            @Override // androidx.activity.contextaware.OnContextAvailableListener
+            public final void onContextAvailable(Context context) {
+                FragmentActivity.this.lambda$init$3(context);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ Bundle lambda$init$0() {
+        markFragmentsCreated();
+        this.mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
+        return new Bundle();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$init$1(Configuration configuration) {
+        this.mFragments.noteStateNotSaved();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$init$2(Intent intent) {
+        this.mFragments.noteStateNotSaved();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$init$3(Context context) {
+        this.mFragments.attachHost(null);
+    }
+
+    @Override // androidx.activity.ComponentActivity, android.app.Activity
+    @CallSuper
+    public void onActivityResult(int i, int i2, @Nullable Intent intent) {
+        this.mFragments.noteStateNotSaved();
+        super.onActivityResult(i, i2, intent);
+    }
+
+    public void supportFinishAfterTransition() {
+        ActivityCompat.finishAfterTransition(this);
+    }
+
+    public void setEnterSharedElementCallback(@Nullable SharedElementCallback sharedElementCallback) {
+        ActivityCompat.setEnterSharedElementCallback(this, sharedElementCallback);
+    }
+
+    public void setExitSharedElementCallback(@Nullable SharedElementCallback sharedElementCallback) {
+        ActivityCompat.setExitSharedElementCallback(this, sharedElementCallback);
+    }
+
+    public void supportPostponeEnterTransition() {
+        ActivityCompat.postponeEnterTransition(this);
+    }
+
+    public void supportStartPostponedEnterTransition() {
+        ActivityCompat.startPostponedEnterTransition(this);
+    }
+
+    @Override // androidx.activity.ComponentActivity, androidx.core.app.ComponentActivity, android.app.Activity
+    public void onCreate(@Nullable Bundle bundle) {
+        super.onCreate(bundle);
+        this.mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
+        this.mFragments.dispatchCreate();
+    }
+
+    @Override // android.app.Activity, android.view.LayoutInflater.Factory2
+    @Nullable
+    public View onCreateView(@Nullable View view, @NonNull String str, @NonNull Context context, @NonNull AttributeSet attributeSet) {
+        View dispatchFragmentsOnCreateView = dispatchFragmentsOnCreateView(view, str, context, attributeSet);
+        return dispatchFragmentsOnCreateView == null ? super.onCreateView(view, str, context, attributeSet) : dispatchFragmentsOnCreateView;
+    }
+
+    @Override // android.app.Activity, android.view.LayoutInflater.Factory
+    @Nullable
+    public View onCreateView(@NonNull String str, @NonNull Context context, @NonNull AttributeSet attributeSet) {
+        View dispatchFragmentsOnCreateView = dispatchFragmentsOnCreateView(null, str, context, attributeSet);
+        return dispatchFragmentsOnCreateView == null ? super.onCreateView(str, context, attributeSet) : dispatchFragmentsOnCreateView;
+    }
+
+    @Nullable
+    public final View dispatchFragmentsOnCreateView(@Nullable View view, @NonNull String str, @NonNull Context context, @NonNull AttributeSet attributeSet) {
+        return this.mFragments.onCreateView(view, str, context, attributeSet);
+    }
+
+    @Override // android.app.Activity
+    public void onDestroy() {
+        super.onDestroy();
+        this.mFragments.dispatchDestroy();
+        this.mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
+    }
+
+    @Override // androidx.activity.ComponentActivity, android.app.Activity, android.view.Window.Callback
+    public boolean onMenuItemSelected(int i, @NonNull MenuItem menuItem) {
+        if (super.onMenuItemSelected(i, menuItem)) {
+            return true;
+        }
+        if (i == 6) {
+            return this.mFragments.dispatchContextItemSelected(menuItem);
+        }
+        return false;
+    }
+
+    @Override // android.app.Activity
+    public void onPause() {
+        super.onPause();
+        this.mResumed = false;
+        this.mFragments.dispatchPause();
+        this.mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
+    }
+
+    @Override // android.app.Activity
+    public void onStateNotSaved() {
+        this.mFragments.noteStateNotSaved();
+    }
+
+    @Override // android.app.Activity
+    public void onResume() {
+        this.mFragments.noteStateNotSaved();
+        super.onResume();
+        this.mResumed = true;
+        this.mFragments.execPendingActions();
+    }
+
+    @Override // android.app.Activity
+    public void onPostResume() {
+        super.onPostResume();
+        onResumeFragments();
+    }
+
+    public void onResumeFragments() {
+        this.mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
+        this.mFragments.dispatchResume();
+    }
+
+    @Override // android.app.Activity
+    public void onStart() {
+        this.mFragments.noteStateNotSaved();
+        super.onStart();
+        this.mStopped = false;
+        if (!this.mCreated) {
+            this.mCreated = true;
+            this.mFragments.dispatchActivityCreated();
+        }
+        this.mFragments.execPendingActions();
+        this.mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
+        this.mFragments.dispatchStart();
+    }
+
+    @Override // android.app.Activity
+    public void onStop() {
+        super.onStop();
+        this.mStopped = true;
+        markFragmentsCreated();
+        this.mFragments.dispatchStop();
+        this.mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
+    }
+
+    @Deprecated
+    public void supportInvalidateOptionsMenu() {
+        invalidateMenu();
+    }
+
+    @Override // android.app.Activity
+    public void dump(@NonNull String str, @Nullable FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @Nullable String[] strArr) {
+        super.dump(str, fileDescriptor, printWriter, strArr);
+        if (shouldDumpInternalState(strArr)) {
+            printWriter.print(str);
+            printWriter.print("Local FragmentActivity ");
+            printWriter.print(Integer.toHexString(System.identityHashCode(this)));
+            printWriter.println(" State:");
+            String str2 = str + "  ";
+            printWriter.print(str2);
+            printWriter.print("mCreated=");
+            printWriter.print(this.mCreated);
+            printWriter.print(" mResumed=");
+            printWriter.print(this.mResumed);
+            printWriter.print(" mStopped=");
+            printWriter.print(this.mStopped);
+            if (getApplication() != null) {
+                LoaderManager.getInstance(this).dump(str2, fileDescriptor, printWriter, strArr);
+            }
+            this.mFragments.getSupportFragmentManager().dump(str, fileDescriptor, printWriter, strArr);
+        }
+    }
+
+    @NonNull
+    public FragmentManager getSupportFragmentManager() {
+        return this.mFragments.getSupportFragmentManager();
+    }
+
+    @NonNull
+    @Deprecated
+    public LoaderManager getSupportLoaderManager() {
+        return LoaderManager.getInstance(this);
+    }
+
+    @Override // androidx.activity.ComponentActivity, android.app.Activity
+    @CallSuper
+    public void onRequestPermissionsResult(int i, @NonNull String[] strArr, @NonNull int[] iArr) {
+        this.mFragments.noteStateNotSaved();
+        super.onRequestPermissionsResult(i, strArr, iArr);
+    }
+
+    public void startActivityFromFragment(@NonNull Fragment fragment, @SuppressLint({"UnknownNullness"}) Intent intent, int i) {
+        startActivityFromFragment(fragment, intent, i, (Bundle) null);
+    }
+
+    public void startActivityFromFragment(@NonNull Fragment fragment, @SuppressLint({"UnknownNullness"}) Intent intent, int i, @Nullable Bundle bundle) {
+        if (i == -1) {
+            ActivityCompat.startActivityForResult(this, intent, -1, bundle);
+        } else {
+            fragment.startActivityForResult(intent, i, bundle);
+        }
+    }
+
+    @Deprecated
+    public void startIntentSenderFromFragment(@NonNull Fragment fragment, @SuppressLint({"UnknownNullness"}) IntentSender intentSender, int i, @Nullable Intent intent, int i2, int i3, int i4, @Nullable Bundle bundle) throws IntentSender.SendIntentException {
+        if (i == -1) {
+            ActivityCompat.startIntentSenderForResult(this, intentSender, i, intent, i2, i3, i4, bundle);
+        } else {
+            fragment.startIntentSenderForResult(intentSender, i, intent, i2, i3, i4, bundle);
+        }
+    }
+
+    public class HostCallbacks extends FragmentHostCallback<FragmentActivity> implements OnConfigurationChangedProvider, OnTrimMemoryProvider, OnMultiWindowModeChangedProvider, OnPictureInPictureModeChangedProvider, ViewModelStoreOwner, OnBackPressedDispatcherOwner, ActivityResultRegistryOwner, SavedStateRegistryOwner, FragmentOnAttachListener, MenuHost {
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // androidx.fragment.app.FragmentHostCallback
+        public FragmentActivity onGetHost() {
+            return FragmentActivity.this;
+        }
+
+        public HostCallbacks() {
+            super(FragmentActivity.this);
+        }
+
+        @Override // androidx.lifecycle.LifecycleOwner
+        @NonNull
+        public Lifecycle getLifecycle() {
+            return FragmentActivity.this.mFragmentLifecycleRegistry;
+        }
+
+        @Override // androidx.lifecycle.ViewModelStoreOwner
+        @NonNull
+        public ViewModelStore getViewModelStore() {
+            return FragmentActivity.this.getViewModelStore();
+        }
+
+        @Override // androidx.activity.OnBackPressedDispatcherOwner
+        @NonNull
+        public OnBackPressedDispatcher getOnBackPressedDispatcher() {
+            return FragmentActivity.this.getOnBackPressedDispatcher();
+        }
+
+        @Override // androidx.fragment.app.FragmentHostCallback
+        public void onDump(@NonNull String str, @Nullable FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @Nullable String[] strArr) {
+            FragmentActivity.this.dump(str, fileDescriptor, printWriter, strArr);
+        }
+
+        @Override // androidx.fragment.app.FragmentHostCallback
+        public boolean onShouldSaveFragmentState(@NonNull Fragment fragment) {
+            return !FragmentActivity.this.isFinishing();
+        }
+
+        @Override // androidx.fragment.app.FragmentHostCallback
+        @NonNull
+        public LayoutInflater onGetLayoutInflater() {
+            return FragmentActivity.this.getLayoutInflater().cloneInContext(FragmentActivity.this);
+        }
+
+        @Override // androidx.fragment.app.FragmentHostCallback
+        public void onSupportInvalidateOptionsMenu() {
+            invalidateMenu();
+        }
+
+        @Override // androidx.fragment.app.FragmentHostCallback
+        public boolean onShouldShowRequestPermissionRationale(@NonNull String str) {
+            return ActivityCompat.shouldShowRequestPermissionRationale(FragmentActivity.this, str);
+        }
+
+        @Override // androidx.fragment.app.FragmentHostCallback
+        public boolean onHasWindowAnimations() {
+            return FragmentActivity.this.getWindow() != null;
+        }
+
+        @Override // androidx.fragment.app.FragmentHostCallback
+        public int onGetWindowAnimations() {
+            Window window = FragmentActivity.this.getWindow();
+            if (window == null) {
+                return 0;
+            }
+            return window.getAttributes().windowAnimations;
+        }
+
+        @Override // androidx.fragment.app.FragmentOnAttachListener
+        public void onAttachFragment(@NonNull FragmentManager fragmentManager, @NonNull Fragment fragment) {
+            FragmentActivity.this.onAttachFragment(fragment);
+        }
+
+        @Override // androidx.fragment.app.FragmentHostCallback, androidx.fragment.app.FragmentContainer
+        @Nullable
+        public View onFindViewById(int i) {
+            return FragmentActivity.this.findViewById(i);
+        }
+
+        @Override // androidx.fragment.app.FragmentHostCallback, androidx.fragment.app.FragmentContainer
+        public boolean onHasView() {
+            Window window = FragmentActivity.this.getWindow();
+            return (window == null || window.peekDecorView() == null) ? false : true;
+        }
+
+        @Override // androidx.activity.result.ActivityResultRegistryOwner
+        @NonNull
+        public ActivityResultRegistry getActivityResultRegistry() {
+            return FragmentActivity.this.getActivityResultRegistry();
+        }
+
+        @Override // androidx.savedstate.SavedStateRegistryOwner
+        @NonNull
+        public SavedStateRegistry getSavedStateRegistry() {
+            return FragmentActivity.this.getSavedStateRegistry();
+        }
+
+        @Override // androidx.core.content.OnConfigurationChangedProvider
+        public void addOnConfigurationChangedListener(@NonNull Consumer<Configuration> consumer) {
+            FragmentActivity.this.addOnConfigurationChangedListener(consumer);
+        }
+
+        @Override // androidx.core.content.OnConfigurationChangedProvider
+        public void removeOnConfigurationChangedListener(@NonNull Consumer<Configuration> consumer) {
+            FragmentActivity.this.removeOnConfigurationChangedListener(consumer);
+        }
+
+        @Override // androidx.core.content.OnTrimMemoryProvider
+        public void addOnTrimMemoryListener(@NonNull Consumer<Integer> consumer) {
+            FragmentActivity.this.addOnTrimMemoryListener(consumer);
+        }
+
+        @Override // androidx.core.content.OnTrimMemoryProvider
+        public void removeOnTrimMemoryListener(@NonNull Consumer<Integer> consumer) {
+            FragmentActivity.this.removeOnTrimMemoryListener(consumer);
+        }
+
+        @Override // androidx.core.app.OnMultiWindowModeChangedProvider
+        public void addOnMultiWindowModeChangedListener(@NonNull Consumer<MultiWindowModeChangedInfo> consumer) {
+            FragmentActivity.this.addOnMultiWindowModeChangedListener(consumer);
+        }
+
+        @Override // androidx.core.app.OnMultiWindowModeChangedProvider
+        public void removeOnMultiWindowModeChangedListener(@NonNull Consumer<MultiWindowModeChangedInfo> consumer) {
+            FragmentActivity.this.removeOnMultiWindowModeChangedListener(consumer);
+        }
+
+        @Override // androidx.core.app.OnPictureInPictureModeChangedProvider
+        public void addOnPictureInPictureModeChangedListener(@NonNull Consumer<PictureInPictureModeChangedInfo> consumer) {
+            FragmentActivity.this.addOnPictureInPictureModeChangedListener(consumer);
+        }
+
+        @Override // androidx.core.app.OnPictureInPictureModeChangedProvider
+        public void removeOnPictureInPictureModeChangedListener(@NonNull Consumer<PictureInPictureModeChangedInfo> consumer) {
+            FragmentActivity.this.removeOnPictureInPictureModeChangedListener(consumer);
+        }
+
+        @Override // androidx.core.view.MenuHost
+        public void addMenuProvider(@NonNull MenuProvider menuProvider) {
+            FragmentActivity.this.addMenuProvider(menuProvider);
+        }
+
+        @Override // androidx.core.view.MenuHost
+        public void addMenuProvider(@NonNull MenuProvider menuProvider, @NonNull LifecycleOwner lifecycleOwner) {
+            FragmentActivity.this.addMenuProvider(menuProvider, lifecycleOwner);
+        }
+
+        @Override // androidx.core.view.MenuHost
+        public void addMenuProvider(@NonNull MenuProvider menuProvider, @NonNull LifecycleOwner lifecycleOwner, @NonNull Lifecycle.State state) {
+            FragmentActivity.this.addMenuProvider(menuProvider, lifecycleOwner, state);
+        }
+
+        @Override // androidx.core.view.MenuHost
+        public void removeMenuProvider(@NonNull MenuProvider menuProvider) {
+            FragmentActivity.this.removeMenuProvider(menuProvider);
+        }
+
+        @Override // androidx.core.view.MenuHost
+        public void invalidateMenu() {
+            FragmentActivity.this.invalidateMenu();
+        }
+    }
+
+    public void markFragmentsCreated() {
+        while (markState(getSupportFragmentManager(), Lifecycle.State.CREATED)) {
+        }
+    }
+
+    private static boolean markState(FragmentManager fragmentManager, Lifecycle.State state) {
+        boolean z = false;
+        for (Fragment fragment : fragmentManager.getFragments()) {
+            if (fragment != null) {
+                if (fragment.getHost() != null) {
+                    z |= markState(fragment.getChildFragmentManager(), state);
+                }
+                FragmentViewLifecycleOwner fragmentViewLifecycleOwner = fragment.mViewLifecycleOwner;
+                if (fragmentViewLifecycleOwner != null && fragmentViewLifecycleOwner.getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
+                    fragment.mViewLifecycleOwner.setCurrentState(state);
+                    z = true;
+                }
+                if (fragment.mLifecycleRegistry.getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
+                    fragment.mLifecycleRegistry.setCurrentState(state);
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentAnim.java

@@ -0,0 +1,200 @@
+package androidx.fragment.app;
+
+import android.animation.Animator;
+import android.animation.AnimatorInflater;
+import android.content.Context;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationSet;
+import android.view.animation.AnimationUtils;
+import android.view.animation.Transformation;
+import androidx.annotation.AnimRes;
+import androidx.annotation.NonNull;
+import androidx.core.view.OneShotPreDrawListener;
+import androidx.fragment.R;
+
+/* loaded from: classes.dex */
+class FragmentAnim {
+    private FragmentAnim() {
+    }
+
+    public static AnimationOrAnimator loadAnimation(@NonNull Context context, @NonNull Fragment fragment, boolean z, boolean z2) {
+        int nextTransition = fragment.getNextTransition();
+        int nextAnim = getNextAnim(fragment, z, z2);
+        fragment.setAnimations(0, 0, 0, 0);
+        ViewGroup viewGroup = fragment.mContainer;
+        if (viewGroup != null && viewGroup.getTag(R.id.visible_removing_fragment_view_tag) != null) {
+            fragment.mContainer.setTag(R.id.visible_removing_fragment_view_tag, null);
+        }
+        ViewGroup viewGroup2 = fragment.mContainer;
+        if (viewGroup2 != null && viewGroup2.getLayoutTransition() != null) {
+            return null;
+        }
+        Animation onCreateAnimation = fragment.onCreateAnimation(nextTransition, z, nextAnim);
+        if (onCreateAnimation != null) {
+            return new AnimationOrAnimator(onCreateAnimation);
+        }
+        Animator onCreateAnimator = fragment.onCreateAnimator(nextTransition, z, nextAnim);
+        if (onCreateAnimator != null) {
+            return new AnimationOrAnimator(onCreateAnimator);
+        }
+        if (nextAnim == 0 && nextTransition != 0) {
+            nextAnim = transitToAnimResourceId(context, nextTransition, z);
+        }
+        if (nextAnim != 0) {
+            boolean equals = "anim".equals(context.getResources().getResourceTypeName(nextAnim));
+            if (equals) {
+                try {
+                    Animation loadAnimation = AnimationUtils.loadAnimation(context, nextAnim);
+                    if (loadAnimation != null) {
+                        return new AnimationOrAnimator(loadAnimation);
+                    }
+                } catch (Resources.NotFoundException e) {
+                    throw e;
+                } catch (RuntimeException unused) {
+                }
+            }
+            try {
+                Animator loadAnimator = AnimatorInflater.loadAnimator(context, nextAnim);
+                if (loadAnimator != null) {
+                    return new AnimationOrAnimator(loadAnimator);
+                }
+            } catch (RuntimeException e2) {
+                if (equals) {
+                    throw e2;
+                }
+                Animation loadAnimation2 = AnimationUtils.loadAnimation(context, nextAnim);
+                if (loadAnimation2 != null) {
+                    return new AnimationOrAnimator(loadAnimation2);
+                }
+            }
+        }
+        return null;
+    }
+
+    @AnimRes
+    private static int getNextAnim(Fragment fragment, boolean z, boolean z2) {
+        if (z2) {
+            if (z) {
+                return fragment.getPopEnterAnim();
+            }
+            return fragment.getPopExitAnim();
+        }
+        if (z) {
+            return fragment.getEnterAnim();
+        }
+        return fragment.getExitAnim();
+    }
+
+    @AnimRes
+    private static int transitToAnimResourceId(@NonNull Context context, int i, boolean z) {
+        if (i == 4097) {
+            return z ? R.animator.fragment_open_enter : R.animator.fragment_open_exit;
+        }
+        if (i == 8194) {
+            return z ? R.animator.fragment_close_enter : R.animator.fragment_close_exit;
+        }
+        if (i == 8197) {
+            if (z) {
+                return toActivityTransitResId(context, android.R.attr.activityCloseEnterAnimation);
+            }
+            return toActivityTransitResId(context, android.R.attr.activityCloseExitAnimation);
+        }
+        if (i == 4099) {
+            return z ? R.animator.fragment_fade_enter : R.animator.fragment_fade_exit;
+        }
+        if (i != 4100) {
+            return -1;
+        }
+        if (z) {
+            return toActivityTransitResId(context, android.R.attr.activityOpenEnterAnimation);
+        }
+        return toActivityTransitResId(context, android.R.attr.activityOpenExitAnimation);
+    }
+
+    @AnimRes
+    private static int toActivityTransitResId(@NonNull Context context, int i) {
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(android.R.style.Animation.Activity, new int[]{i});
+        int resourceId = obtainStyledAttributes.getResourceId(0, -1);
+        obtainStyledAttributes.recycle();
+        return resourceId;
+    }
+
+    public static class AnimationOrAnimator {
+        public final Animation animation;
+        public final Animator animator;
+
+        public AnimationOrAnimator(Animation animation) {
+            this.animation = animation;
+            this.animator = null;
+            if (animation == null) {
+                throw new IllegalStateException("Animation cannot be null");
+            }
+        }
+
+        public AnimationOrAnimator(Animator animator) {
+            this.animation = null;
+            this.animator = animator;
+            if (animator == null) {
+                throw new IllegalStateException("Animator cannot be null");
+            }
+        }
+    }
+
+    public static class EndViewTransitionAnimation extends AnimationSet implements Runnable {
+        private boolean mAnimating;
+        private final View mChild;
+        private boolean mEnded;
+        private final ViewGroup mParent;
+        private boolean mTransitionEnded;
+
+        public EndViewTransitionAnimation(@NonNull Animation animation, @NonNull ViewGroup viewGroup, @NonNull View view) {
+            super(false);
+            this.mAnimating = true;
+            this.mParent = viewGroup;
+            this.mChild = view;
+            addAnimation(animation);
+            viewGroup.post(this);
+        }
+
+        @Override // android.view.animation.AnimationSet, android.view.animation.Animation
+        public boolean getTransformation(long j, @NonNull Transformation transformation) {
+            this.mAnimating = true;
+            if (this.mEnded) {
+                return !this.mTransitionEnded;
+            }
+            if (!super.getTransformation(j, transformation)) {
+                this.mEnded = true;
+                OneShotPreDrawListener.add(this.mParent, this);
+            }
+            return true;
+        }
+
+        @Override // android.view.animation.Animation
+        public boolean getTransformation(long j, @NonNull Transformation transformation, float f) {
+            this.mAnimating = true;
+            if (this.mEnded) {
+                return !this.mTransitionEnded;
+            }
+            if (!super.getTransformation(j, transformation, f)) {
+                this.mEnded = true;
+                OneShotPreDrawListener.add(this.mParent, this);
+            }
+            return true;
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            if (!this.mEnded && this.mAnimating) {
+                this.mAnimating = false;
+                this.mParent.post(this);
+            } else {
+                this.mParent.endViewTransition(this.mChild);
+                this.mTransitionEnded = true;
+            }
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentContainer.java

@@ -0,0 +1,22 @@
+package androidx.fragment.app;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.view.View;
+import androidx.annotation.IdRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public abstract class FragmentContainer {
+    @Nullable
+    public abstract View onFindViewById(@IdRes int i);
+
+    public abstract boolean onHasView();
+
+    @NonNull
+    @Deprecated
+    public Fragment instantiate(@NonNull Context context, @NonNull String str, @Nullable Bundle bundle) {
+        return Fragment.instantiate(context, str, bundle);
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentContainerView.java

@@ -0,0 +1,295 @@
+package androidx.fragment.app;
+
+import android.animation.LayoutTransition;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.os.Bundle;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowInsets;
+import android.widget.FrameLayout;
+import androidx.annotation.RequiresApi;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsCompat;
+import androidx.fragment.R;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class FragmentContainerView extends FrameLayout {
+    private View.OnApplyWindowInsetsListener applyWindowInsetsListener;
+    private final List<View> disappearingFragmentChildren;
+    private boolean drawDisappearingViewsFirst;
+    private final List<View> transitioningFragmentViews;
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public FragmentContainerView(Context context, AttributeSet attributeSet) {
+        this(context, attributeSet, 0, 4, null);
+        Intrinsics.checkNotNullParameter(context, "context");
+    }
+
+    @Override // android.view.View
+    @RequiresApi(20)
+    public WindowInsets onApplyWindowInsets(WindowInsets insets) {
+        Intrinsics.checkNotNullParameter(insets, "insets");
+        return insets;
+    }
+
+    public final void setDrawDisappearingViewsLast(boolean z) {
+        this.drawDisappearingViewsFirst = z;
+    }
+
+    @Override // android.view.View
+    public void setOnApplyWindowInsetsListener(View.OnApplyWindowInsetsListener listener) {
+        Intrinsics.checkNotNullParameter(listener, "listener");
+        this.applyWindowInsetsListener = listener;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FragmentContainerView(Context context) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.disappearingFragmentChildren = new ArrayList();
+        this.transitioningFragmentViews = new ArrayList();
+        this.drawDisappearingViewsFirst = true;
+    }
+
+    public /* synthetic */ FragmentContainerView(Context context, AttributeSet attributeSet, int i, int i2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(context, attributeSet, (i2 & 4) != 0 ? 0 : i);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FragmentContainerView(Context context, AttributeSet attributeSet, int i) {
+        super(context, attributeSet, i);
+        String str;
+        Intrinsics.checkNotNullParameter(context, "context");
+        this.disappearingFragmentChildren = new ArrayList();
+        this.transitioningFragmentViews = new ArrayList();
+        this.drawDisappearingViewsFirst = true;
+        if (attributeSet != null) {
+            String classAttribute = attributeSet.getClassAttribute();
+            int[] FragmentContainerView = R.styleable.FragmentContainerView;
+            Intrinsics.checkNotNullExpressionValue(FragmentContainerView, "FragmentContainerView");
+            TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, FragmentContainerView, 0, 0);
+            if (classAttribute == null) {
+                classAttribute = obtainStyledAttributes.getString(R.styleable.FragmentContainerView_android_name);
+                str = "android:name";
+            } else {
+                str = "class";
+            }
+            obtainStyledAttributes.recycle();
+            if (classAttribute == null || isInEditMode()) {
+                return;
+            }
+            throw new UnsupportedOperationException("FragmentContainerView must be within a FragmentActivity to use " + str + "=\"" + classAttribute + '\"');
+        }
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FragmentContainerView(Context context, AttributeSet attrs, FragmentManager fm) {
+        super(context, attrs);
+        String str;
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(attrs, "attrs");
+        Intrinsics.checkNotNullParameter(fm, "fm");
+        this.disappearingFragmentChildren = new ArrayList();
+        this.transitioningFragmentViews = new ArrayList();
+        this.drawDisappearingViewsFirst = true;
+        String classAttribute = attrs.getClassAttribute();
+        int[] FragmentContainerView = R.styleable.FragmentContainerView;
+        Intrinsics.checkNotNullExpressionValue(FragmentContainerView, "FragmentContainerView");
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attrs, FragmentContainerView, 0, 0);
+        classAttribute = classAttribute == null ? obtainStyledAttributes.getString(R.styleable.FragmentContainerView_android_name) : classAttribute;
+        String string = obtainStyledAttributes.getString(R.styleable.FragmentContainerView_android_tag);
+        obtainStyledAttributes.recycle();
+        int id = getId();
+        Fragment findFragmentById = fm.findFragmentById(id);
+        if (classAttribute != null && findFragmentById == null) {
+            if (id == -1) {
+                if (string != null) {
+                    str = " with tag " + string;
+                } else {
+                    str = "";
+                }
+                throw new IllegalStateException("FragmentContainerView must have an android:id to add Fragment " + classAttribute + str);
+            }
+            Fragment instantiate = fm.getFragmentFactory().instantiate(context.getClassLoader(), classAttribute);
+            Intrinsics.checkNotNullExpressionValue(instantiate, "fm.fragmentFactory.insta…ontext.classLoader, name)");
+            instantiate.onInflate(context, attrs, (Bundle) null);
+            fm.beginTransaction().setReorderingAllowed(true).add(this, instantiate, string).commitNowAllowingStateLoss();
+        }
+        fm.onContainerAvailable(this);
+    }
+
+    @Override // android.view.ViewGroup
+    public void setLayoutTransition(LayoutTransition layoutTransition) {
+        throw new UnsupportedOperationException("FragmentContainerView does not support Layout Transitions or animateLayoutChanges=\"true\".");
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    @RequiresApi(20)
+    public WindowInsets dispatchApplyWindowInsets(WindowInsets insets) {
+        WindowInsetsCompat onApplyWindowInsets;
+        Intrinsics.checkNotNullParameter(insets, "insets");
+        WindowInsetsCompat windowInsetsCompat = WindowInsetsCompat.toWindowInsetsCompat(insets);
+        Intrinsics.checkNotNullExpressionValue(windowInsetsCompat, "toWindowInsetsCompat(insets)");
+        View.OnApplyWindowInsetsListener onApplyWindowInsetsListener = this.applyWindowInsetsListener;
+        if (onApplyWindowInsetsListener != null) {
+            Api20Impl api20Impl = Api20Impl.INSTANCE;
+            Intrinsics.checkNotNull(onApplyWindowInsetsListener);
+            onApplyWindowInsets = WindowInsetsCompat.toWindowInsetsCompat(api20Impl.onApplyWindowInsets(onApplyWindowInsetsListener, this, insets));
+        } else {
+            onApplyWindowInsets = ViewCompat.onApplyWindowInsets(this, windowInsetsCompat);
+        }
+        Intrinsics.checkNotNullExpressionValue(onApplyWindowInsets, "if (applyWindowInsetsLis…, insetsCompat)\n        }");
+        if (!onApplyWindowInsets.isConsumed()) {
+            int childCount = getChildCount();
+            for (int i = 0; i < childCount; i++) {
+                ViewCompat.dispatchApplyWindowInsets(getChildAt(i), onApplyWindowInsets);
+            }
+        }
+        return insets;
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    public void dispatchDraw(Canvas canvas) {
+        Intrinsics.checkNotNullParameter(canvas, "canvas");
+        if (this.drawDisappearingViewsFirst) {
+            Iterator<T> it = this.disappearingFragmentChildren.iterator();
+            while (it.hasNext()) {
+                super.drawChild(canvas, (View) it.next(), getDrawingTime());
+            }
+        }
+        super.dispatchDraw(canvas);
+    }
+
+    @Override // android.view.ViewGroup
+    public boolean drawChild(Canvas canvas, View child, long j) {
+        Intrinsics.checkNotNullParameter(canvas, "canvas");
+        Intrinsics.checkNotNullParameter(child, "child");
+        if (this.drawDisappearingViewsFirst && (!this.disappearingFragmentChildren.isEmpty()) && this.disappearingFragmentChildren.contains(child)) {
+            return false;
+        }
+        return super.drawChild(canvas, child, j);
+    }
+
+    @Override // android.view.ViewGroup
+    public void startViewTransition(View view) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        if (view.getParent() == this) {
+            this.transitioningFragmentViews.add(view);
+        }
+        super.startViewTransition(view);
+    }
+
+    @Override // android.view.ViewGroup
+    public void endViewTransition(View view) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        this.transitioningFragmentViews.remove(view);
+        if (this.disappearingFragmentChildren.remove(view)) {
+            this.drawDisappearingViewsFirst = true;
+        }
+        super.endViewTransition(view);
+    }
+
+    @Override // android.view.ViewGroup
+    public void addView(View child, int i, ViewGroup.LayoutParams layoutParams) {
+        Intrinsics.checkNotNullParameter(child, "child");
+        if (FragmentManager.getViewFragment(child) == null) {
+            throw new IllegalStateException(("Views added to a FragmentContainerView must be associated with a Fragment. View " + child + " is not associated with a Fragment.").toString());
+        }
+        super.addView(child, i, layoutParams);
+    }
+
+    @Override // android.view.ViewGroup
+    public void removeViewAt(int i) {
+        View view = getChildAt(i);
+        Intrinsics.checkNotNullExpressionValue(view, "view");
+        addDisappearingFragmentView(view);
+        super.removeViewAt(i);
+    }
+
+    @Override // android.view.ViewGroup
+    public void removeViewInLayout(View view) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        addDisappearingFragmentView(view);
+        super.removeViewInLayout(view);
+    }
+
+    @Override // android.view.ViewGroup, android.view.ViewManager
+    public void removeView(View view) {
+        Intrinsics.checkNotNullParameter(view, "view");
+        addDisappearingFragmentView(view);
+        super.removeView(view);
+    }
+
+    @Override // android.view.ViewGroup
+    public void removeViews(int i, int i2) {
+        int i3 = i + i2;
+        for (int i4 = i; i4 < i3; i4++) {
+            View view = getChildAt(i4);
+            Intrinsics.checkNotNullExpressionValue(view, "view");
+            addDisappearingFragmentView(view);
+        }
+        super.removeViews(i, i2);
+    }
+
+    @Override // android.view.ViewGroup
+    public void removeViewsInLayout(int i, int i2) {
+        int i3 = i + i2;
+        for (int i4 = i; i4 < i3; i4++) {
+            View view = getChildAt(i4);
+            Intrinsics.checkNotNullExpressionValue(view, "view");
+            addDisappearingFragmentView(view);
+        }
+        super.removeViewsInLayout(i, i2);
+    }
+
+    @Override // android.view.ViewGroup
+    public void removeAllViewsInLayout() {
+        int childCount = getChildCount();
+        while (true) {
+            childCount--;
+            if (-1 < childCount) {
+                View view = getChildAt(childCount);
+                Intrinsics.checkNotNullExpressionValue(view, "view");
+                addDisappearingFragmentView(view);
+            } else {
+                super.removeAllViewsInLayout();
+                return;
+            }
+        }
+    }
+
+    private final void addDisappearingFragmentView(View view) {
+        if (this.transitioningFragmentViews.contains(view)) {
+            this.disappearingFragmentChildren.add(view);
+        }
+    }
+
+    public final <F extends Fragment> F getFragment() {
+        return (F) FragmentManager.findFragmentManager(this).findFragmentById(getId());
+    }
+
+    @RequiresApi(20)
+    public static final class Api20Impl {
+        public static final Api20Impl INSTANCE = new Api20Impl();
+
+        private Api20Impl() {
+        }
+
+        public final WindowInsets onApplyWindowInsets(View.OnApplyWindowInsetsListener onApplyWindowInsetsListener, View v, WindowInsets insets) {
+            Intrinsics.checkNotNullParameter(onApplyWindowInsetsListener, "onApplyWindowInsetsListener");
+            Intrinsics.checkNotNullParameter(v, "v");
+            Intrinsics.checkNotNullParameter(insets, "insets");
+            WindowInsets onApplyWindowInsets = onApplyWindowInsetsListener.onApplyWindowInsets(v, insets);
+            Intrinsics.checkNotNullExpressionValue(onApplyWindowInsets, "onApplyWindowInsetsListe…lyWindowInsets(v, insets)");
+            return onApplyWindowInsets;
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentController.java

@@ -0,0 +1,233 @@
+package androidx.fragment.app;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.os.Parcelable;
+import android.util.AttributeSet;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.collection.SimpleArrayMap;
+import androidx.core.util.Preconditions;
+import androidx.lifecycle.ViewModelStoreOwner;
+import androidx.loader.app.LoaderManager;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class FragmentController {
+    private final FragmentHostCallback<?> mHost;
+
+    @Deprecated
+    public void dispatchReallyStop() {
+    }
+
+    @Deprecated
+    public void doLoaderDestroy() {
+    }
+
+    @Deprecated
+    public void doLoaderRetain() {
+    }
+
+    @Deprecated
+    public void doLoaderStart() {
+    }
+
+    @Deprecated
+    public void doLoaderStop(boolean z) {
+    }
+
+    @Deprecated
+    public void dumpLoaders(@NonNull String str, @Nullable FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @Nullable String[] strArr) {
+    }
+
+    @Deprecated
+    public void reportLoaderStart() {
+    }
+
+    @Deprecated
+    public void restoreLoaderNonConfig(@SuppressLint({"UnknownNullness"}) SimpleArrayMap<String, LoaderManager> simpleArrayMap) {
+    }
+
+    @Nullable
+    @Deprecated
+    public SimpleArrayMap<String, LoaderManager> retainLoaderNonConfig() {
+        return null;
+    }
+
+    @NonNull
+    public static FragmentController createController(@NonNull FragmentHostCallback<?> fragmentHostCallback) {
+        return new FragmentController((FragmentHostCallback) Preconditions.checkNotNull(fragmentHostCallback, "callbacks == null"));
+    }
+
+    private FragmentController(FragmentHostCallback<?> fragmentHostCallback) {
+        this.mHost = fragmentHostCallback;
+    }
+
+    @NonNull
+    public FragmentManager getSupportFragmentManager() {
+        return this.mHost.mFragmentManager;
+    }
+
+    @SuppressLint({"UnknownNullness"})
+    @Deprecated
+    public LoaderManager getSupportLoaderManager() {
+        throw new UnsupportedOperationException("Loaders are managed separately from FragmentController, use LoaderManager.getInstance() to obtain a LoaderManager.");
+    }
+
+    @Nullable
+    public Fragment findFragmentByWho(@NonNull String str) {
+        return this.mHost.mFragmentManager.findFragmentByWho(str);
+    }
+
+    public int getActiveFragmentsCount() {
+        return this.mHost.mFragmentManager.getActiveFragmentCount();
+    }
+
+    @NonNull
+    public List<Fragment> getActiveFragments(@SuppressLint({"UnknownNullness"}) List<Fragment> list) {
+        return this.mHost.mFragmentManager.getActiveFragments();
+    }
+
+    public void attachHost(@Nullable Fragment fragment) {
+        FragmentHostCallback<?> fragmentHostCallback = this.mHost;
+        fragmentHostCallback.mFragmentManager.attachController(fragmentHostCallback, fragmentHostCallback, fragment);
+    }
+
+    @Nullable
+    public View onCreateView(@Nullable View view, @NonNull String str, @NonNull Context context, @NonNull AttributeSet attributeSet) {
+        return this.mHost.mFragmentManager.getLayoutInflaterFactory().onCreateView(view, str, context, attributeSet);
+    }
+
+    public void noteStateNotSaved() {
+        this.mHost.mFragmentManager.noteStateNotSaved();
+    }
+
+    @Nullable
+    @Deprecated
+    public Parcelable saveAllState() {
+        return this.mHost.mFragmentManager.saveAllState();
+    }
+
+    @Deprecated
+    public void restoreAllState(@Nullable Parcelable parcelable, @Nullable List<Fragment> list) {
+        this.mHost.mFragmentManager.restoreAllState(parcelable, new FragmentManagerNonConfig(list, null, null));
+    }
+
+    @Deprecated
+    public void restoreAllState(@Nullable Parcelable parcelable, @Nullable FragmentManagerNonConfig fragmentManagerNonConfig) {
+        this.mHost.mFragmentManager.restoreAllState(parcelable, fragmentManagerNonConfig);
+    }
+
+    @Deprecated
+    public void restoreSaveState(@Nullable Parcelable parcelable) {
+        FragmentHostCallback<?> fragmentHostCallback = this.mHost;
+        if (!(fragmentHostCallback instanceof ViewModelStoreOwner)) {
+            throw new IllegalStateException("Your FragmentHostCallback must implement ViewModelStoreOwner to call restoreSaveState(). Call restoreAllState()  if you're still using retainNestedNonConfig().");
+        }
+        fragmentHostCallback.mFragmentManager.restoreSaveState(parcelable);
+    }
+
+    @Nullable
+    @Deprecated
+    public List<Fragment> retainNonConfig() {
+        FragmentManagerNonConfig retainNonConfig = this.mHost.mFragmentManager.retainNonConfig();
+        if (retainNonConfig == null || retainNonConfig.getFragments() == null) {
+            return null;
+        }
+        return new ArrayList(retainNonConfig.getFragments());
+    }
+
+    @Nullable
+    @Deprecated
+    public FragmentManagerNonConfig retainNestedNonConfig() {
+        return this.mHost.mFragmentManager.retainNonConfig();
+    }
+
+    public void dispatchCreate() {
+        this.mHost.mFragmentManager.dispatchCreate();
+    }
+
+    public void dispatchActivityCreated() {
+        this.mHost.mFragmentManager.dispatchActivityCreated();
+    }
+
+    public void dispatchStart() {
+        this.mHost.mFragmentManager.dispatchStart();
+    }
+
+    public void dispatchResume() {
+        this.mHost.mFragmentManager.dispatchResume();
+    }
+
+    public void dispatchPause() {
+        this.mHost.mFragmentManager.dispatchPause();
+    }
+
+    public void dispatchStop() {
+        this.mHost.mFragmentManager.dispatchStop();
+    }
+
+    public void dispatchDestroyView() {
+        this.mHost.mFragmentManager.dispatchDestroyView();
+    }
+
+    public void dispatchDestroy() {
+        this.mHost.mFragmentManager.dispatchDestroy();
+    }
+
+    @Deprecated
+    public void dispatchMultiWindowModeChanged(boolean z) {
+        this.mHost.mFragmentManager.dispatchMultiWindowModeChanged(z, true);
+    }
+
+    @Deprecated
+    public void dispatchPictureInPictureModeChanged(boolean z) {
+        this.mHost.mFragmentManager.dispatchPictureInPictureModeChanged(z, true);
+    }
+
+    @Deprecated
+    public void dispatchConfigurationChanged(@NonNull Configuration configuration) {
+        this.mHost.mFragmentManager.dispatchConfigurationChanged(configuration, true);
+    }
+
+    @Deprecated
+    public void dispatchLowMemory() {
+        this.mHost.mFragmentManager.dispatchLowMemory(true);
+    }
+
+    @Deprecated
+    public boolean dispatchCreateOptionsMenu(@NonNull Menu menu, @NonNull MenuInflater menuInflater) {
+        return this.mHost.mFragmentManager.dispatchCreateOptionsMenu(menu, menuInflater);
+    }
+
+    @Deprecated
+    public boolean dispatchPrepareOptionsMenu(@NonNull Menu menu) {
+        return this.mHost.mFragmentManager.dispatchPrepareOptionsMenu(menu);
+    }
+
+    @Deprecated
+    public boolean dispatchOptionsItemSelected(@NonNull MenuItem menuItem) {
+        return this.mHost.mFragmentManager.dispatchOptionsItemSelected(menuItem);
+    }
+
+    public boolean dispatchContextItemSelected(@NonNull MenuItem menuItem) {
+        return this.mHost.mFragmentManager.dispatchContextItemSelected(menuItem);
+    }
+
+    @Deprecated
+    public void dispatchOptionsMenuClosed(@NonNull Menu menu) {
+        this.mHost.mFragmentManager.dispatchOptionsMenuClosed(menu);
+    }
+
+    public boolean execPendingActions() {
+        return this.mHost.mFragmentManager.execPendingActions(true);
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentFactory.java

@@ -0,0 +1,62 @@
+package androidx.fragment.app;
+
+import androidx.annotation.NonNull;
+import androidx.collection.SimpleArrayMap;
+import androidx.fragment.app.Fragment;
+import java.lang.reflect.InvocationTargetException;
+
+/* loaded from: classes.dex */
+public class FragmentFactory {
+    private static final SimpleArrayMap<ClassLoader, SimpleArrayMap<String, Class<?>>> sClassCacheMap = new SimpleArrayMap<>();
+
+    @NonNull
+    private static Class<?> loadClass(@NonNull ClassLoader classLoader, @NonNull String str) throws ClassNotFoundException {
+        SimpleArrayMap<ClassLoader, SimpleArrayMap<String, Class<?>>> simpleArrayMap = sClassCacheMap;
+        SimpleArrayMap<String, Class<?>> simpleArrayMap2 = simpleArrayMap.get(classLoader);
+        if (simpleArrayMap2 == null) {
+            simpleArrayMap2 = new SimpleArrayMap<>();
+            simpleArrayMap.put(classLoader, simpleArrayMap2);
+        }
+        Class<?> cls = simpleArrayMap2.get(str);
+        if (cls != null) {
+            return cls;
+        }
+        Class<?> cls2 = Class.forName(str, false, classLoader);
+        simpleArrayMap2.put(str, cls2);
+        return cls2;
+    }
+
+    public static boolean isFragmentClass(@NonNull ClassLoader classLoader, @NonNull String str) {
+        try {
+            return Fragment.class.isAssignableFrom(loadClass(classLoader, str));
+        } catch (ClassNotFoundException unused) {
+            return false;
+        }
+    }
+
+    @NonNull
+    public static Class<? extends Fragment> loadFragmentClass(@NonNull ClassLoader classLoader, @NonNull String str) {
+        try {
+            return loadClass(classLoader, str);
+        } catch (ClassCastException e) {
+            throw new Fragment.InstantiationException("Unable to instantiate fragment " + str + ": make sure class is a valid subclass of Fragment", e);
+        } catch (ClassNotFoundException e2) {
+            throw new Fragment.InstantiationException("Unable to instantiate fragment " + str + ": make sure class name exists", e2);
+        }
+    }
+
+    @NonNull
+    public Fragment instantiate(@NonNull ClassLoader classLoader, @NonNull String str) {
+        try {
+            return loadFragmentClass(classLoader, str).getConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (IllegalAccessException e) {
+            throw new Fragment.InstantiationException("Unable to instantiate fragment " + str + ": make sure class name exists, is public, and has an empty constructor that is public", e);
+        } catch (InstantiationException e2) {
+            throw new Fragment.InstantiationException("Unable to instantiate fragment " + str + ": make sure class name exists, is public, and has an empty constructor that is public", e2);
+        } catch (NoSuchMethodException e3) {
+            throw new Fragment.InstantiationException("Unable to instantiate fragment " + str + ": could not find Fragment constructor", e3);
+        } catch (InvocationTargetException e4) {
+            throw new Fragment.InstantiationException("Unable to instantiate fragment " + str + ": calling Fragment constructor caused an exception", e4);
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentHostCallback.java

@@ -0,0 +1,130 @@
+package androidx.fragment.app;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.os.Bundle;
+import android.os.Handler;
+import android.view.LayoutInflater;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+import androidx.core.util.Preconditions;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+
+/* loaded from: classes.dex */
+public abstract class FragmentHostCallback<E> extends FragmentContainer {
+
+    @Nullable
+    private final Activity mActivity;
+
+    @NonNull
+    private final Context mContext;
+    final FragmentManager mFragmentManager;
+
+    @NonNull
+    private final Handler mHandler;
+    private final int mWindowAnimations;
+
+    @Nullable
+    public Activity getActivity() {
+        return this.mActivity;
+    }
+
+    @NonNull
+    public Context getContext() {
+        return this.mContext;
+    }
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public Handler getHandler() {
+        return this.mHandler;
+    }
+
+    public void onDump(@NonNull String str, @Nullable FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @Nullable String[] strArr) {
+    }
+
+    @Override // androidx.fragment.app.FragmentContainer
+    @Nullable
+    public View onFindViewById(int i) {
+        return null;
+    }
+
+    @Nullable
+    public abstract E onGetHost();
+
+    public int onGetWindowAnimations() {
+        return this.mWindowAnimations;
+    }
+
+    @Override // androidx.fragment.app.FragmentContainer
+    public boolean onHasView() {
+        return true;
+    }
+
+    public boolean onHasWindowAnimations() {
+        return true;
+    }
+
+    @Deprecated
+    public void onRequestPermissionsFromFragment(@NonNull Fragment fragment, @NonNull String[] strArr, int i) {
+    }
+
+    public boolean onShouldSaveFragmentState(@NonNull Fragment fragment) {
+        return true;
+    }
+
+    public boolean onShouldShowRequestPermissionRationale(@NonNull String str) {
+        return false;
+    }
+
+    public void onSupportInvalidateOptionsMenu() {
+    }
+
+    public FragmentHostCallback(@NonNull Context context, @NonNull Handler handler, int i) {
+        this(context instanceof Activity ? (Activity) context : null, context, handler, i);
+    }
+
+    public FragmentHostCallback(@NonNull FragmentActivity fragmentActivity) {
+        this(fragmentActivity, fragmentActivity, new Handler(), 0);
+    }
+
+    public FragmentHostCallback(@Nullable Activity activity, @NonNull Context context, @NonNull Handler handler, int i) {
+        this.mFragmentManager = new FragmentManagerImpl();
+        this.mActivity = activity;
+        this.mContext = (Context) Preconditions.checkNotNull(context, "context == null");
+        this.mHandler = (Handler) Preconditions.checkNotNull(handler, "handler == null");
+        this.mWindowAnimations = i;
+    }
+
+    @NonNull
+    public LayoutInflater onGetLayoutInflater() {
+        return LayoutInflater.from(this.mContext);
+    }
+
+    public void onStartActivityFromFragment(@NonNull Fragment fragment, @SuppressLint({"UnknownNullness"}) Intent intent, int i) {
+        onStartActivityFromFragment(fragment, intent, i, null);
+    }
+
+    public void onStartActivityFromFragment(@NonNull Fragment fragment, @SuppressLint({"UnknownNullness"}) Intent intent, int i, @Nullable Bundle bundle) {
+        if (i != -1) {
+            throw new IllegalStateException("Starting activity with a requestCode requires a FragmentActivity host");
+        }
+        ContextCompat.startActivity(this.mContext, intent, bundle);
+    }
+
+    @Deprecated
+    public void onStartIntentSenderFromFragment(@NonNull Fragment fragment, @SuppressLint({"UnknownNullness"}) IntentSender intentSender, int i, @Nullable Intent intent, int i2, int i3, int i4, @Nullable Bundle bundle) throws IntentSender.SendIntentException {
+        if (i != -1) {
+            throw new IllegalStateException("Starting intent sender with a requestCode requires a FragmentActivity host");
+        }
+        ActivityCompat.startIntentSenderForResult(this.mActivity, intentSender, i, intent, i2, i3, i4, bundle);
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentLayoutInflaterFactory.java

@@ -0,0 +1,127 @@
+package androidx.fragment.app;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.R;
+import androidx.fragment.app.strictmode.FragmentStrictMode;
+
+/* loaded from: classes.dex */
+class FragmentLayoutInflaterFactory implements LayoutInflater.Factory2 {
+    private static final String TAG = "FragmentManager";
+    final FragmentManager mFragmentManager;
+
+    public FragmentLayoutInflaterFactory(FragmentManager fragmentManager) {
+        this.mFragmentManager = fragmentManager;
+    }
+
+    @Override // android.view.LayoutInflater.Factory
+    @Nullable
+    public View onCreateView(@NonNull String str, @NonNull Context context, @NonNull AttributeSet attributeSet) {
+        return onCreateView(null, str, context, attributeSet);
+    }
+
+    @Override // android.view.LayoutInflater.Factory2
+    @Nullable
+    public View onCreateView(@Nullable View view, @NonNull String str, @NonNull Context context, @NonNull AttributeSet attributeSet) {
+        final FragmentStateManager createOrGetFragmentStateManager;
+        if (FragmentContainerView.class.getName().equals(str)) {
+            return new FragmentContainerView(context, attributeSet, this.mFragmentManager);
+        }
+        if (!"fragment".equals(str)) {
+            return null;
+        }
+        String attributeValue = attributeSet.getAttributeValue(null, "class");
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.Fragment);
+        if (attributeValue == null) {
+            attributeValue = obtainStyledAttributes.getString(R.styleable.Fragment_android_name);
+        }
+        int resourceId = obtainStyledAttributes.getResourceId(R.styleable.Fragment_android_id, -1);
+        String string = obtainStyledAttributes.getString(R.styleable.Fragment_android_tag);
+        obtainStyledAttributes.recycle();
+        if (attributeValue == null || !FragmentFactory.isFragmentClass(context.getClassLoader(), attributeValue)) {
+            return null;
+        }
+        int id = view != null ? view.getId() : 0;
+        if (id == -1 && resourceId == -1 && string == null) {
+            throw new IllegalArgumentException(attributeSet.getPositionDescription() + ": Must specify unique android:id, android:tag, or have a parent with an id for " + attributeValue);
+        }
+        Fragment findFragmentById = resourceId != -1 ? this.mFragmentManager.findFragmentById(resourceId) : null;
+        if (findFragmentById == null && string != null) {
+            findFragmentById = this.mFragmentManager.findFragmentByTag(string);
+        }
+        if (findFragmentById == null && id != -1) {
+            findFragmentById = this.mFragmentManager.findFragmentById(id);
+        }
+        if (findFragmentById == null) {
+            findFragmentById = this.mFragmentManager.getFragmentFactory().instantiate(context.getClassLoader(), attributeValue);
+            findFragmentById.mFromLayout = true;
+            findFragmentById.mFragmentId = resourceId != 0 ? resourceId : id;
+            findFragmentById.mContainerId = id;
+            findFragmentById.mTag = string;
+            findFragmentById.mInLayout = true;
+            FragmentManager fragmentManager = this.mFragmentManager;
+            findFragmentById.mFragmentManager = fragmentManager;
+            findFragmentById.mHost = fragmentManager.getHost();
+            findFragmentById.onInflate(this.mFragmentManager.getHost().getContext(), attributeSet, findFragmentById.mSavedFragmentState);
+            createOrGetFragmentStateManager = this.mFragmentManager.addFragment(findFragmentById);
+            if (FragmentManager.isLoggingEnabled(2)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Fragment ");
+                sb.append(findFragmentById);
+                sb.append(" has been inflated via the <fragment> tag: id=0x");
+                sb.append(Integer.toHexString(resourceId));
+            }
+        } else {
+            if (findFragmentById.mInLayout) {
+                throw new IllegalArgumentException(attributeSet.getPositionDescription() + ": Duplicate id 0x" + Integer.toHexString(resourceId) + ", tag " + string + ", or parent id 0x" + Integer.toHexString(id) + " with another fragment for " + attributeValue);
+            }
+            findFragmentById.mInLayout = true;
+            FragmentManager fragmentManager2 = this.mFragmentManager;
+            findFragmentById.mFragmentManager = fragmentManager2;
+            findFragmentById.mHost = fragmentManager2.getHost();
+            findFragmentById.onInflate(this.mFragmentManager.getHost().getContext(), attributeSet, findFragmentById.mSavedFragmentState);
+            createOrGetFragmentStateManager = this.mFragmentManager.createOrGetFragmentStateManager(findFragmentById);
+            if (FragmentManager.isLoggingEnabled(2)) {
+                StringBuilder sb2 = new StringBuilder();
+                sb2.append("Retained Fragment ");
+                sb2.append(findFragmentById);
+                sb2.append(" has been re-attached via the <fragment> tag: id=0x");
+                sb2.append(Integer.toHexString(resourceId));
+            }
+        }
+        ViewGroup viewGroup = (ViewGroup) view;
+        FragmentStrictMode.onFragmentTagUsage(findFragmentById, viewGroup);
+        findFragmentById.mContainer = viewGroup;
+        createOrGetFragmentStateManager.moveToExpectedState();
+        createOrGetFragmentStateManager.ensureInflatedView();
+        View view2 = findFragmentById.mView;
+        if (view2 == null) {
+            throw new IllegalStateException("Fragment " + attributeValue + " did not create a view.");
+        }
+        if (resourceId != 0) {
+            view2.setId(resourceId);
+        }
+        if (findFragmentById.mView.getTag() == null) {
+            findFragmentById.mView.setTag(string);
+        }
+        findFragmentById.mView.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() { // from class: androidx.fragment.app.FragmentLayoutInflaterFactory.1
+            @Override // android.view.View.OnAttachStateChangeListener
+            public void onViewDetachedFromWindow(View view3) {
+            }
+
+            @Override // android.view.View.OnAttachStateChangeListener
+            public void onViewAttachedToWindow(View view3) {
+                Fragment fragment = createOrGetFragmentStateManager.getFragment();
+                createOrGetFragmentStateManager.moveToExpectedState();
+                SpecialEffectsController.getOrCreateController((ViewGroup) fragment.mView.getParent(), FragmentLayoutInflaterFactory.this.mFragmentManager).forceCompleteAllOperations();
+            }
+        });
+        return findFragmentById.mView;
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentLifecycleCallbacksDispatcher.java

@@ -0,0 +1,259 @@
+package androidx.fragment.app;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.FragmentManager;
+import java.util.Iterator;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/* loaded from: classes.dex */
+class FragmentLifecycleCallbacksDispatcher {
+
+    @NonNull
+    private final FragmentManager mFragmentManager;
+
+    @NonNull
+    private final CopyOnWriteArrayList<FragmentLifecycleCallbacksHolder> mLifecycleCallbacks = new CopyOnWriteArrayList<>();
+
+    public static final class FragmentLifecycleCallbacksHolder {
+
+        @NonNull
+        final FragmentManager.FragmentLifecycleCallbacks mCallback;
+        final boolean mRecursive;
+
+        public FragmentLifecycleCallbacksHolder(@NonNull FragmentManager.FragmentLifecycleCallbacks fragmentLifecycleCallbacks, boolean z) {
+            this.mCallback = fragmentLifecycleCallbacks;
+            this.mRecursive = z;
+        }
+    }
+
+    public FragmentLifecycleCallbacksDispatcher(@NonNull FragmentManager fragmentManager) {
+        this.mFragmentManager = fragmentManager;
+    }
+
+    public void registerFragmentLifecycleCallbacks(@NonNull FragmentManager.FragmentLifecycleCallbacks fragmentLifecycleCallbacks, boolean z) {
+        this.mLifecycleCallbacks.add(new FragmentLifecycleCallbacksHolder(fragmentLifecycleCallbacks, z));
+    }
+
+    public void unregisterFragmentLifecycleCallbacks(@NonNull FragmentManager.FragmentLifecycleCallbacks fragmentLifecycleCallbacks) {
+        synchronized (this.mLifecycleCallbacks) {
+            try {
+                int size = this.mLifecycleCallbacks.size();
+                int i = 0;
+                while (true) {
+                    if (i >= size) {
+                        break;
+                    }
+                    if (this.mLifecycleCallbacks.get(i).mCallback == fragmentLifecycleCallbacks) {
+                        this.mLifecycleCallbacks.remove(i);
+                        break;
+                    }
+                    i++;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public void dispatchOnFragmentPreAttached(@NonNull Fragment fragment, boolean z) {
+        Context context = this.mFragmentManager.getHost().getContext();
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentPreAttached(fragment, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentPreAttached(this.mFragmentManager, fragment, context);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentAttached(@NonNull Fragment fragment, boolean z) {
+        Context context = this.mFragmentManager.getHost().getContext();
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentAttached(fragment, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentAttached(this.mFragmentManager, fragment, context);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentPreCreated(@NonNull Fragment fragment, @Nullable Bundle bundle, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentPreCreated(fragment, bundle, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentPreCreated(this.mFragmentManager, fragment, bundle);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentCreated(@NonNull Fragment fragment, @Nullable Bundle bundle, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentCreated(fragment, bundle, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentCreated(this.mFragmentManager, fragment, bundle);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentActivityCreated(@NonNull Fragment fragment, @Nullable Bundle bundle, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentActivityCreated(fragment, bundle, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentActivityCreated(this.mFragmentManager, fragment, bundle);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentViewCreated(@NonNull Fragment fragment, @NonNull View view, @Nullable Bundle bundle, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentViewCreated(fragment, view, bundle, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentViewCreated(this.mFragmentManager, fragment, view, bundle);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentStarted(@NonNull Fragment fragment, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentStarted(fragment, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentStarted(this.mFragmentManager, fragment);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentResumed(@NonNull Fragment fragment, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentResumed(fragment, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentResumed(this.mFragmentManager, fragment);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentPaused(@NonNull Fragment fragment, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentPaused(fragment, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentPaused(this.mFragmentManager, fragment);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentStopped(@NonNull Fragment fragment, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentStopped(fragment, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentStopped(this.mFragmentManager, fragment);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentSaveInstanceState(@NonNull Fragment fragment, @NonNull Bundle bundle, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentSaveInstanceState(fragment, bundle, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentSaveInstanceState(this.mFragmentManager, fragment, bundle);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentViewDestroyed(@NonNull Fragment fragment, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentViewDestroyed(fragment, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentViewDestroyed(this.mFragmentManager, fragment);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentDestroyed(@NonNull Fragment fragment, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentDestroyed(fragment, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentDestroyed(this.mFragmentManager, fragment);
+            }
+        }
+    }
+
+    public void dispatchOnFragmentDetached(@NonNull Fragment fragment, boolean z) {
+        Fragment parent = this.mFragmentManager.getParent();
+        if (parent != null) {
+            parent.getParentFragmentManager().getLifecycleCallbacksDispatcher().dispatchOnFragmentDetached(fragment, true);
+        }
+        Iterator<FragmentLifecycleCallbacksHolder> it = this.mLifecycleCallbacks.iterator();
+        while (it.hasNext()) {
+            FragmentLifecycleCallbacksHolder next = it.next();
+            if (!z || next.mRecursive) {
+                next.mCallback.onFragmentDetached(this.mFragmentManager, fragment);
+            }
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentManagerImpl.java

@@ -0,0 +1,5 @@
+package androidx.fragment.app;
+
+/* loaded from: classes.dex */
+class FragmentManagerImpl extends FragmentManager {
+}

decompiled/sources/androidx/fragment/app/FragmentManagerNonConfig.java

@@ -0,0 +1,49 @@
+package androidx.fragment.app;
+
+import androidx.annotation.Nullable;
+import androidx.lifecycle.ViewModelStore;
+import java.util.Collection;
+import java.util.Map;
+
+@Deprecated
+/* loaded from: classes.dex */
+public class FragmentManagerNonConfig {
+
+    @Nullable
+    private final Map<String, FragmentManagerNonConfig> mChildNonConfigs;
+
+    @Nullable
+    private final Collection<Fragment> mFragments;
+
+    @Nullable
+    private final Map<String, ViewModelStore> mViewModelStores;
+
+    @Nullable
+    public Map<String, FragmentManagerNonConfig> getChildNonConfigs() {
+        return this.mChildNonConfigs;
+    }
+
+    @Nullable
+    public Collection<Fragment> getFragments() {
+        return this.mFragments;
+    }
+
+    @Nullable
+    public Map<String, ViewModelStore> getViewModelStores() {
+        return this.mViewModelStores;
+    }
+
+    public FragmentManagerNonConfig(@Nullable Collection<Fragment> collection, @Nullable Map<String, FragmentManagerNonConfig> map, @Nullable Map<String, ViewModelStore> map2) {
+        this.mFragments = collection;
+        this.mChildNonConfigs = map;
+        this.mViewModelStores = map2;
+    }
+
+    public boolean isRetaining(Fragment fragment) {
+        Collection<Fragment> collection = this.mFragments;
+        if (collection == null) {
+            return false;
+        }
+        return collection.contains(fragment);
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentManagerState.java

@@ -0,0 +1,70 @@
+package androidx.fragment.app;
+
+import android.annotation.SuppressLint;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.fragment.app.FragmentManager;
+import java.util.ArrayList;
+
+@SuppressLint({"BanParcelableUsage"})
+/* loaded from: classes.dex */
+final class FragmentManagerState implements Parcelable {
+    public static final Parcelable.Creator<FragmentManagerState> CREATOR = new Parcelable.Creator<FragmentManagerState>() { // from class: androidx.fragment.app.FragmentManagerState.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public FragmentManagerState createFromParcel(Parcel parcel) {
+            return new FragmentManagerState(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public FragmentManagerState[] newArray(int i) {
+            return new FragmentManagerState[i];
+        }
+    };
+    ArrayList<String> mActive;
+    ArrayList<String> mAdded;
+    BackStackRecordState[] mBackStack;
+    int mBackStackIndex;
+    ArrayList<String> mBackStackStateKeys;
+    ArrayList<BackStackState> mBackStackStates;
+    ArrayList<FragmentManager.LaunchedFragmentInfo> mLaunchedFragments;
+    String mPrimaryNavActiveWho;
+
+    @Override // android.os.Parcelable
+    public int describeContents() {
+        return 0;
+    }
+
+    public FragmentManagerState() {
+        this.mPrimaryNavActiveWho = null;
+        this.mBackStackStateKeys = new ArrayList<>();
+        this.mBackStackStates = new ArrayList<>();
+    }
+
+    public FragmentManagerState(Parcel parcel) {
+        this.mPrimaryNavActiveWho = null;
+        this.mBackStackStateKeys = new ArrayList<>();
+        this.mBackStackStates = new ArrayList<>();
+        this.mActive = parcel.createStringArrayList();
+        this.mAdded = parcel.createStringArrayList();
+        this.mBackStack = (BackStackRecordState[]) parcel.createTypedArray(BackStackRecordState.CREATOR);
+        this.mBackStackIndex = parcel.readInt();
+        this.mPrimaryNavActiveWho = parcel.readString();
+        this.mBackStackStateKeys = parcel.createStringArrayList();
+        this.mBackStackStates = parcel.createTypedArrayList(BackStackState.CREATOR);
+        this.mLaunchedFragments = parcel.createTypedArrayList(FragmentManager.LaunchedFragmentInfo.CREATOR);
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        parcel.writeStringList(this.mActive);
+        parcel.writeStringList(this.mAdded);
+        parcel.writeTypedArray(this.mBackStack, i);
+        parcel.writeInt(this.mBackStackIndex);
+        parcel.writeString(this.mPrimaryNavActiveWho);
+        parcel.writeStringList(this.mBackStackStateKeys);
+        parcel.writeTypedList(this.mBackStackStates);
+        parcel.writeTypedList(this.mLaunchedFragments);
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentManagerViewModel.java

@@ -0,0 +1,254 @@
+package androidx.fragment.app;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.ViewModel;
+import androidx.lifecycle.ViewModelProvider;
+import androidx.lifecycle.ViewModelStore;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+final class FragmentManagerViewModel extends ViewModel {
+    private static final ViewModelProvider.Factory FACTORY = new ViewModelProvider.Factory() { // from class: androidx.fragment.app.FragmentManagerViewModel.1
+        @Override // androidx.lifecycle.ViewModelProvider.Factory
+        @NonNull
+        public <T extends ViewModel> T create(@NonNull Class<T> cls) {
+            return new FragmentManagerViewModel(true);
+        }
+    };
+    private static final String TAG = "FragmentManager";
+    private final boolean mStateAutomaticallySaved;
+    private final HashMap<String, Fragment> mRetainedFragments = new HashMap<>();
+    private final HashMap<String, FragmentManagerViewModel> mChildNonConfigs = new HashMap<>();
+    private final HashMap<String, ViewModelStore> mViewModelStores = new HashMap<>();
+    private boolean mHasBeenCleared = false;
+    private boolean mHasSavedSnapshot = false;
+    private boolean mIsStateSaved = false;
+
+    public boolean isCleared() {
+        return this.mHasBeenCleared;
+    }
+
+    public void setIsStateSaved(boolean z) {
+        this.mIsStateSaved = z;
+    }
+
+    @NonNull
+    public static FragmentManagerViewModel getInstance(ViewModelStore viewModelStore) {
+        return (FragmentManagerViewModel) new ViewModelProvider(viewModelStore, FACTORY).get(FragmentManagerViewModel.class);
+    }
+
+    public FragmentManagerViewModel(boolean z) {
+        this.mStateAutomaticallySaved = z;
+    }
+
+    @Override // androidx.lifecycle.ViewModel
+    public void onCleared() {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("onCleared called for ");
+            sb.append(this);
+        }
+        this.mHasBeenCleared = true;
+    }
+
+    public void addRetainedFragment(@NonNull Fragment fragment) {
+        if (this.mIsStateSaved) {
+            FragmentManager.isLoggingEnabled(2);
+            return;
+        }
+        if (this.mRetainedFragments.containsKey(fragment.mWho)) {
+            return;
+        }
+        this.mRetainedFragments.put(fragment.mWho, fragment);
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Updating retained Fragments: Added ");
+            sb.append(fragment);
+        }
+    }
+
+    @Nullable
+    public Fragment findRetainedFragmentByWho(String str) {
+        return this.mRetainedFragments.get(str);
+    }
+
+    @NonNull
+    public Collection<Fragment> getRetainedFragments() {
+        return new ArrayList(this.mRetainedFragments.values());
+    }
+
+    public boolean shouldDestroy(@NonNull Fragment fragment) {
+        if (this.mRetainedFragments.containsKey(fragment.mWho)) {
+            return this.mStateAutomaticallySaved ? this.mHasBeenCleared : !this.mHasSavedSnapshot;
+        }
+        return true;
+    }
+
+    public void removeRetainedFragment(@NonNull Fragment fragment) {
+        if (this.mIsStateSaved) {
+            FragmentManager.isLoggingEnabled(2);
+        } else {
+            if (this.mRetainedFragments.remove(fragment.mWho) == null || !FragmentManager.isLoggingEnabled(2)) {
+                return;
+            }
+            StringBuilder sb = new StringBuilder();
+            sb.append("Updating retained Fragments: Removed ");
+            sb.append(fragment);
+        }
+    }
+
+    @NonNull
+    public FragmentManagerViewModel getChildNonConfig(@NonNull Fragment fragment) {
+        FragmentManagerViewModel fragmentManagerViewModel = this.mChildNonConfigs.get(fragment.mWho);
+        if (fragmentManagerViewModel != null) {
+            return fragmentManagerViewModel;
+        }
+        FragmentManagerViewModel fragmentManagerViewModel2 = new FragmentManagerViewModel(this.mStateAutomaticallySaved);
+        this.mChildNonConfigs.put(fragment.mWho, fragmentManagerViewModel2);
+        return fragmentManagerViewModel2;
+    }
+
+    @NonNull
+    public ViewModelStore getViewModelStore(@NonNull Fragment fragment) {
+        ViewModelStore viewModelStore = this.mViewModelStores.get(fragment.mWho);
+        if (viewModelStore != null) {
+            return viewModelStore;
+        }
+        ViewModelStore viewModelStore2 = new ViewModelStore();
+        this.mViewModelStores.put(fragment.mWho, viewModelStore2);
+        return viewModelStore2;
+    }
+
+    public void clearNonConfigState(@NonNull Fragment fragment) {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Clearing non-config state for ");
+            sb.append(fragment);
+        }
+        clearNonConfigStateInternal(fragment.mWho);
+    }
+
+    public void clearNonConfigState(@NonNull String str) {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Clearing non-config state for saved state of Fragment ");
+            sb.append(str);
+        }
+        clearNonConfigStateInternal(str);
+    }
+
+    private void clearNonConfigStateInternal(@NonNull String str) {
+        FragmentManagerViewModel fragmentManagerViewModel = this.mChildNonConfigs.get(str);
+        if (fragmentManagerViewModel != null) {
+            fragmentManagerViewModel.onCleared();
+            this.mChildNonConfigs.remove(str);
+        }
+        ViewModelStore viewModelStore = this.mViewModelStores.get(str);
+        if (viewModelStore != null) {
+            viewModelStore.clear();
+            this.mViewModelStores.remove(str);
+        }
+    }
+
+    @Deprecated
+    public void restoreFromSnapshot(@Nullable FragmentManagerNonConfig fragmentManagerNonConfig) {
+        this.mRetainedFragments.clear();
+        this.mChildNonConfigs.clear();
+        this.mViewModelStores.clear();
+        if (fragmentManagerNonConfig != null) {
+            Collection<Fragment> fragments = fragmentManagerNonConfig.getFragments();
+            if (fragments != null) {
+                for (Fragment fragment : fragments) {
+                    if (fragment != null) {
+                        this.mRetainedFragments.put(fragment.mWho, fragment);
+                    }
+                }
+            }
+            Map<String, FragmentManagerNonConfig> childNonConfigs = fragmentManagerNonConfig.getChildNonConfigs();
+            if (childNonConfigs != null) {
+                for (Map.Entry<String, FragmentManagerNonConfig> entry : childNonConfigs.entrySet()) {
+                    FragmentManagerViewModel fragmentManagerViewModel = new FragmentManagerViewModel(this.mStateAutomaticallySaved);
+                    fragmentManagerViewModel.restoreFromSnapshot(entry.getValue());
+                    this.mChildNonConfigs.put(entry.getKey(), fragmentManagerViewModel);
+                }
+            }
+            Map<String, ViewModelStore> viewModelStores = fragmentManagerNonConfig.getViewModelStores();
+            if (viewModelStores != null) {
+                this.mViewModelStores.putAll(viewModelStores);
+            }
+        }
+        this.mHasSavedSnapshot = false;
+    }
+
+    @Nullable
+    @Deprecated
+    public FragmentManagerNonConfig getSnapshot() {
+        if (this.mRetainedFragments.isEmpty() && this.mChildNonConfigs.isEmpty() && this.mViewModelStores.isEmpty()) {
+            return null;
+        }
+        HashMap hashMap = new HashMap();
+        for (Map.Entry<String, FragmentManagerViewModel> entry : this.mChildNonConfigs.entrySet()) {
+            FragmentManagerNonConfig snapshot = entry.getValue().getSnapshot();
+            if (snapshot != null) {
+                hashMap.put(entry.getKey(), snapshot);
+            }
+        }
+        this.mHasSavedSnapshot = true;
+        if (this.mRetainedFragments.isEmpty() && hashMap.isEmpty() && this.mViewModelStores.isEmpty()) {
+            return null;
+        }
+        return new FragmentManagerNonConfig(new ArrayList(this.mRetainedFragments.values()), hashMap, new HashMap(this.mViewModelStores));
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || FragmentManagerViewModel.class != obj.getClass()) {
+            return false;
+        }
+        FragmentManagerViewModel fragmentManagerViewModel = (FragmentManagerViewModel) obj;
+        return this.mRetainedFragments.equals(fragmentManagerViewModel.mRetainedFragments) && this.mChildNonConfigs.equals(fragmentManagerViewModel.mChildNonConfigs) && this.mViewModelStores.equals(fragmentManagerViewModel.mViewModelStores);
+    }
+
+    public int hashCode() {
+        return (((this.mRetainedFragments.hashCode() * 31) + this.mChildNonConfigs.hashCode()) * 31) + this.mViewModelStores.hashCode();
+    }
+
+    @NonNull
+    public String toString() {
+        StringBuilder sb = new StringBuilder("FragmentManagerViewModel{");
+        sb.append(Integer.toHexString(System.identityHashCode(this)));
+        sb.append("} Fragments (");
+        Iterator<Fragment> it = this.mRetainedFragments.values().iterator();
+        while (it.hasNext()) {
+            sb.append(it.next());
+            if (it.hasNext()) {
+                sb.append(", ");
+            }
+        }
+        sb.append(") Child Non Config (");
+        Iterator<String> it2 = this.mChildNonConfigs.keySet().iterator();
+        while (it2.hasNext()) {
+            sb.append(it2.next());
+            if (it2.hasNext()) {
+                sb.append(", ");
+            }
+        }
+        sb.append(") ViewModelStores (");
+        Iterator<String> it3 = this.mViewModelStores.keySet().iterator();
+        while (it3.hasNext()) {
+            sb.append(it3.next());
+            if (it3.hasNext()) {
+                sb.append(", ");
+            }
+        }
+        sb.append(')');
+        return sb.toString();
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentOnAttachListener.java

@@ -0,0 +1,10 @@
+package androidx.fragment.app;
+
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public interface FragmentOnAttachListener {
+    @MainThread
+    void onAttachFragment(@NonNull FragmentManager fragmentManager, @NonNull Fragment fragment);
+}

decompiled/sources/androidx/fragment/app/FragmentPagerAdapter.java

@@ -0,0 +1,154 @@
+package androidx.fragment.app;
+
+import android.os.Parcelable;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.Lifecycle;
+import androidx.viewpager.widget.PagerAdapter;
+import com.facebook.internal.security.CertificateUtil;
+
+@Deprecated
+/* loaded from: classes.dex */
+public abstract class FragmentPagerAdapter extends PagerAdapter {
+    public static final int BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT = 1;
+
+    @Deprecated
+    public static final int BEHAVIOR_SET_USER_VISIBLE_HINT = 0;
+    private static final boolean DEBUG = false;
+    private static final String TAG = "FragmentPagerAdapter";
+    private final int mBehavior;
+    private FragmentTransaction mCurTransaction;
+    private Fragment mCurrentPrimaryItem;
+    private boolean mExecutingFinishUpdate;
+    private final FragmentManager mFragmentManager;
+
+    @NonNull
+    public abstract Fragment getItem(int i);
+
+    public long getItemId(int i) {
+        return i;
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public void restoreState(@Nullable Parcelable parcelable, @Nullable ClassLoader classLoader) {
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    @Nullable
+    public Parcelable saveState() {
+        return null;
+    }
+
+    @Deprecated
+    public FragmentPagerAdapter(@NonNull FragmentManager fragmentManager) {
+        this(fragmentManager, 0);
+    }
+
+    public FragmentPagerAdapter(@NonNull FragmentManager fragmentManager, int i) {
+        this.mCurTransaction = null;
+        this.mCurrentPrimaryItem = null;
+        this.mFragmentManager = fragmentManager;
+        this.mBehavior = i;
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public void startUpdate(@NonNull ViewGroup viewGroup) {
+        if (viewGroup.getId() != -1) {
+            return;
+        }
+        throw new IllegalStateException("ViewPager with adapter " + this + " requires a view id");
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    @NonNull
+    public Object instantiateItem(@NonNull ViewGroup viewGroup, int i) {
+        if (this.mCurTransaction == null) {
+            this.mCurTransaction = this.mFragmentManager.beginTransaction();
+        }
+        long itemId = getItemId(i);
+        Fragment findFragmentByTag = this.mFragmentManager.findFragmentByTag(makeFragmentName(viewGroup.getId(), itemId));
+        if (findFragmentByTag != null) {
+            this.mCurTransaction.attach(findFragmentByTag);
+        } else {
+            findFragmentByTag = getItem(i);
+            this.mCurTransaction.add(viewGroup.getId(), findFragmentByTag, makeFragmentName(viewGroup.getId(), itemId));
+        }
+        if (findFragmentByTag != this.mCurrentPrimaryItem) {
+            findFragmentByTag.setMenuVisibility(false);
+            if (this.mBehavior == 1) {
+                this.mCurTransaction.setMaxLifecycle(findFragmentByTag, Lifecycle.State.STARTED);
+            } else {
+                findFragmentByTag.setUserVisibleHint(false);
+            }
+        }
+        return findFragmentByTag;
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public void destroyItem(@NonNull ViewGroup viewGroup, int i, @NonNull Object obj) {
+        Fragment fragment = (Fragment) obj;
+        if (this.mCurTransaction == null) {
+            this.mCurTransaction = this.mFragmentManager.beginTransaction();
+        }
+        this.mCurTransaction.detach(fragment);
+        if (fragment.equals(this.mCurrentPrimaryItem)) {
+            this.mCurrentPrimaryItem = null;
+        }
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public void setPrimaryItem(@NonNull ViewGroup viewGroup, int i, @NonNull Object obj) {
+        Fragment fragment = (Fragment) obj;
+        Fragment fragment2 = this.mCurrentPrimaryItem;
+        if (fragment != fragment2) {
+            if (fragment2 != null) {
+                fragment2.setMenuVisibility(false);
+                if (this.mBehavior == 1) {
+                    if (this.mCurTransaction == null) {
+                        this.mCurTransaction = this.mFragmentManager.beginTransaction();
+                    }
+                    this.mCurTransaction.setMaxLifecycle(this.mCurrentPrimaryItem, Lifecycle.State.STARTED);
+                } else {
+                    this.mCurrentPrimaryItem.setUserVisibleHint(false);
+                }
+            }
+            fragment.setMenuVisibility(true);
+            if (this.mBehavior == 1) {
+                if (this.mCurTransaction == null) {
+                    this.mCurTransaction = this.mFragmentManager.beginTransaction();
+                }
+                this.mCurTransaction.setMaxLifecycle(fragment, Lifecycle.State.RESUMED);
+            } else {
+                fragment.setUserVisibleHint(true);
+            }
+            this.mCurrentPrimaryItem = fragment;
+        }
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public void finishUpdate(@NonNull ViewGroup viewGroup) {
+        FragmentTransaction fragmentTransaction = this.mCurTransaction;
+        if (fragmentTransaction != null) {
+            if (!this.mExecutingFinishUpdate) {
+                try {
+                    this.mExecutingFinishUpdate = true;
+                    fragmentTransaction.commitNowAllowingStateLoss();
+                } finally {
+                    this.mExecutingFinishUpdate = false;
+                }
+            }
+            this.mCurTransaction = null;
+        }
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public boolean isViewFromObject(@NonNull View view, @NonNull Object obj) {
+        return ((Fragment) obj).getView() == view;
+    }
+
+    private static String makeFragmentName(int i, long j) {
+        return "android:switcher:" + i + CertificateUtil.DELIMITER + j;
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentResultListener.java

@@ -0,0 +1,9 @@
+package androidx.fragment.app;
+
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public interface FragmentResultListener {
+    void onFragmentResult(@NonNull String str, @NonNull Bundle bundle);
+}

decompiled/sources/androidx/fragment/app/FragmentResultOwner.java

@@ -0,0 +1,16 @@
+package androidx.fragment.app;
+
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LifecycleOwner;
+
+/* loaded from: classes.dex */
+public interface FragmentResultOwner {
+    void clearFragmentResult(@NonNull String str);
+
+    void clearFragmentResultListener(@NonNull String str);
+
+    void setFragmentResult(@NonNull String str, @NonNull Bundle bundle);
+
+    void setFragmentResultListener(@NonNull String str, @NonNull LifecycleOwner lifecycleOwner, @NonNull FragmentResultListener fragmentResultListener);
+}

decompiled/sources/androidx/fragment/app/FragmentState.java

@@ -0,0 +1,155 @@
+package androidx.fragment.app;
+
+import android.annotation.SuppressLint;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import androidx.lifecycle.Lifecycle;
+
+@SuppressLint({"BanParcelableUsage"})
+/* loaded from: classes.dex */
+final class FragmentState implements Parcelable {
+    public static final Parcelable.Creator<FragmentState> CREATOR = new Parcelable.Creator<FragmentState>() { // from class: androidx.fragment.app.FragmentState.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public FragmentState createFromParcel(Parcel parcel) {
+            return new FragmentState(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public FragmentState[] newArray(int i) {
+            return new FragmentState[i];
+        }
+    };
+    final Bundle mArguments;
+    final String mClassName;
+    final int mContainerId;
+    final boolean mDetached;
+    final int mFragmentId;
+    final boolean mFromLayout;
+    final boolean mHidden;
+    final int mMaxLifecycleState;
+    final boolean mRemoving;
+    final boolean mRetainInstance;
+    Bundle mSavedFragmentState;
+    final String mTag;
+    final String mWho;
+
+    @Override // android.os.Parcelable
+    public int describeContents() {
+        return 0;
+    }
+
+    public FragmentState(Fragment fragment) {
+        this.mClassName = fragment.getClass().getName();
+        this.mWho = fragment.mWho;
+        this.mFromLayout = fragment.mFromLayout;
+        this.mFragmentId = fragment.mFragmentId;
+        this.mContainerId = fragment.mContainerId;
+        this.mTag = fragment.mTag;
+        this.mRetainInstance = fragment.mRetainInstance;
+        this.mRemoving = fragment.mRemoving;
+        this.mDetached = fragment.mDetached;
+        this.mArguments = fragment.mArguments;
+        this.mHidden = fragment.mHidden;
+        this.mMaxLifecycleState = fragment.mMaxState.ordinal();
+    }
+
+    public FragmentState(Parcel parcel) {
+        this.mClassName = parcel.readString();
+        this.mWho = parcel.readString();
+        this.mFromLayout = parcel.readInt() != 0;
+        this.mFragmentId = parcel.readInt();
+        this.mContainerId = parcel.readInt();
+        this.mTag = parcel.readString();
+        this.mRetainInstance = parcel.readInt() != 0;
+        this.mRemoving = parcel.readInt() != 0;
+        this.mDetached = parcel.readInt() != 0;
+        this.mArguments = parcel.readBundle();
+        this.mHidden = parcel.readInt() != 0;
+        this.mSavedFragmentState = parcel.readBundle();
+        this.mMaxLifecycleState = parcel.readInt();
+    }
+
+    @NonNull
+    public Fragment instantiate(@NonNull FragmentFactory fragmentFactory, @NonNull ClassLoader classLoader) {
+        Fragment instantiate = fragmentFactory.instantiate(classLoader, this.mClassName);
+        Bundle bundle = this.mArguments;
+        if (bundle != null) {
+            bundle.setClassLoader(classLoader);
+        }
+        instantiate.setArguments(this.mArguments);
+        instantiate.mWho = this.mWho;
+        instantiate.mFromLayout = this.mFromLayout;
+        instantiate.mRestored = true;
+        instantiate.mFragmentId = this.mFragmentId;
+        instantiate.mContainerId = this.mContainerId;
+        instantiate.mTag = this.mTag;
+        instantiate.mRetainInstance = this.mRetainInstance;
+        instantiate.mRemoving = this.mRemoving;
+        instantiate.mDetached = this.mDetached;
+        instantiate.mHidden = this.mHidden;
+        instantiate.mMaxState = Lifecycle.State.values()[this.mMaxLifecycleState];
+        Bundle bundle2 = this.mSavedFragmentState;
+        if (bundle2 != null) {
+            instantiate.mSavedFragmentState = bundle2;
+        } else {
+            instantiate.mSavedFragmentState = new Bundle();
+        }
+        return instantiate;
+    }
+
+    @NonNull
+    public String toString() {
+        StringBuilder sb = new StringBuilder(128);
+        sb.append("FragmentState{");
+        sb.append(this.mClassName);
+        sb.append(" (");
+        sb.append(this.mWho);
+        sb.append(")}:");
+        if (this.mFromLayout) {
+            sb.append(" fromLayout");
+        }
+        if (this.mContainerId != 0) {
+            sb.append(" id=0x");
+            sb.append(Integer.toHexString(this.mContainerId));
+        }
+        String str = this.mTag;
+        if (str != null && !str.isEmpty()) {
+            sb.append(" tag=");
+            sb.append(this.mTag);
+        }
+        if (this.mRetainInstance) {
+            sb.append(" retainInstance");
+        }
+        if (this.mRemoving) {
+            sb.append(" removing");
+        }
+        if (this.mDetached) {
+            sb.append(" detached");
+        }
+        if (this.mHidden) {
+            sb.append(" hidden");
+        }
+        return sb.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        parcel.writeString(this.mClassName);
+        parcel.writeString(this.mWho);
+        parcel.writeInt(this.mFromLayout ? 1 : 0);
+        parcel.writeInt(this.mFragmentId);
+        parcel.writeInt(this.mContainerId);
+        parcel.writeString(this.mTag);
+        parcel.writeInt(this.mRetainInstance ? 1 : 0);
+        parcel.writeInt(this.mRemoving ? 1 : 0);
+        parcel.writeInt(this.mDetached ? 1 : 0);
+        parcel.writeBundle(this.mArguments);
+        parcel.writeInt(this.mHidden ? 1 : 0);
+        parcel.writeBundle(this.mSavedFragmentState);
+        parcel.writeInt(this.mMaxLifecycleState);
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentStateManager.java

@@ -0,0 +1,806 @@
+package androidx.fragment.app;
+
+import android.app.Activity;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.util.SparseArray;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.view.ViewCompat;
+import androidx.fragment.R;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.SpecialEffectsController;
+import androidx.fragment.app.strictmode.FragmentStrictMode;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.ViewModelStoreOwner;
+import com.facebook.internal.AnalyticsEvents;
+import com.ironsource.v8;
+
+/* loaded from: classes.dex */
+class FragmentStateManager {
+    private static final String TAG = "FragmentManager";
+    private static final String TARGET_REQUEST_CODE_STATE_TAG = "android:target_req_state";
+    private static final String TARGET_STATE_TAG = "android:target_state";
+    private static final String USER_VISIBLE_HINT_TAG = "android:user_visible_hint";
+    private static final String VIEW_REGISTRY_STATE_TAG = "android:view_registry_state";
+    private static final String VIEW_STATE_TAG = "android:view_state";
+    private final FragmentLifecycleCallbacksDispatcher mDispatcher;
+
+    @NonNull
+    private final Fragment mFragment;
+    private final FragmentStore mFragmentStore;
+    private boolean mMovingToState = false;
+    private int mFragmentManagerState = -1;
+
+    @NonNull
+    public Fragment getFragment() {
+        return this.mFragment;
+    }
+
+    public void setFragmentManagerState(int i) {
+        this.mFragmentManagerState = i;
+    }
+
+    public FragmentStateManager(@NonNull FragmentLifecycleCallbacksDispatcher fragmentLifecycleCallbacksDispatcher, @NonNull FragmentStore fragmentStore, @NonNull Fragment fragment) {
+        this.mDispatcher = fragmentLifecycleCallbacksDispatcher;
+        this.mFragmentStore = fragmentStore;
+        this.mFragment = fragment;
+    }
+
+    public FragmentStateManager(@NonNull FragmentLifecycleCallbacksDispatcher fragmentLifecycleCallbacksDispatcher, @NonNull FragmentStore fragmentStore, @NonNull ClassLoader classLoader, @NonNull FragmentFactory fragmentFactory, @NonNull FragmentState fragmentState) {
+        this.mDispatcher = fragmentLifecycleCallbacksDispatcher;
+        this.mFragmentStore = fragmentStore;
+        Fragment instantiate = fragmentState.instantiate(fragmentFactory, classLoader);
+        this.mFragment = instantiate;
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Instantiated fragment ");
+            sb.append(instantiate);
+        }
+    }
+
+    public FragmentStateManager(@NonNull FragmentLifecycleCallbacksDispatcher fragmentLifecycleCallbacksDispatcher, @NonNull FragmentStore fragmentStore, @NonNull Fragment fragment, @NonNull FragmentState fragmentState) {
+        this.mDispatcher = fragmentLifecycleCallbacksDispatcher;
+        this.mFragmentStore = fragmentStore;
+        this.mFragment = fragment;
+        fragment.mSavedViewState = null;
+        fragment.mSavedViewRegistryState = null;
+        fragment.mBackStackNesting = 0;
+        fragment.mInLayout = false;
+        fragment.mAdded = false;
+        Fragment fragment2 = fragment.mTarget;
+        fragment.mTargetWho = fragment2 != null ? fragment2.mWho : null;
+        fragment.mTarget = null;
+        Bundle bundle = fragmentState.mSavedFragmentState;
+        if (bundle != null) {
+            fragment.mSavedFragmentState = bundle;
+        } else {
+            fragment.mSavedFragmentState = new Bundle();
+        }
+    }
+
+    public int computeExpectedState() {
+        Fragment fragment = this.mFragment;
+        if (fragment.mFragmentManager == null) {
+            return fragment.mState;
+        }
+        int i = this.mFragmentManagerState;
+        int i2 = AnonymousClass2.$SwitchMap$androidx$lifecycle$Lifecycle$State[fragment.mMaxState.ordinal()];
+        if (i2 != 1) {
+            if (i2 == 2) {
+                i = Math.min(i, 5);
+            } else if (i2 == 3) {
+                i = Math.min(i, 1);
+            } else if (i2 == 4) {
+                i = Math.min(i, 0);
+            } else {
+                i = Math.min(i, -1);
+            }
+        }
+        Fragment fragment2 = this.mFragment;
+        if (fragment2.mFromLayout) {
+            if (fragment2.mInLayout) {
+                i = Math.max(this.mFragmentManagerState, 2);
+                View view = this.mFragment.mView;
+                if (view != null && view.getParent() == null) {
+                    i = Math.min(i, 2);
+                }
+            } else {
+                i = this.mFragmentManagerState < 4 ? Math.min(i, fragment2.mState) : Math.min(i, 1);
+            }
+        }
+        if (!this.mFragment.mAdded) {
+            i = Math.min(i, 1);
+        }
+        Fragment fragment3 = this.mFragment;
+        ViewGroup viewGroup = fragment3.mContainer;
+        SpecialEffectsController.Operation.LifecycleImpact awaitingCompletionLifecycleImpact = viewGroup != null ? SpecialEffectsController.getOrCreateController(viewGroup, fragment3.getParentFragmentManager()).getAwaitingCompletionLifecycleImpact(this) : null;
+        if (awaitingCompletionLifecycleImpact == SpecialEffectsController.Operation.LifecycleImpact.ADDING) {
+            i = Math.min(i, 6);
+        } else if (awaitingCompletionLifecycleImpact == SpecialEffectsController.Operation.LifecycleImpact.REMOVING) {
+            i = Math.max(i, 3);
+        } else {
+            Fragment fragment4 = this.mFragment;
+            if (fragment4.mRemoving) {
+                if (fragment4.isInBackStack()) {
+                    i = Math.min(i, 1);
+                } else {
+                    i = Math.min(i, -1);
+                }
+            }
+        }
+        Fragment fragment5 = this.mFragment;
+        if (fragment5.mDeferStart && fragment5.mState < 5) {
+            i = Math.min(i, 4);
+        }
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("computeExpectedState() of ");
+            sb.append(i);
+            sb.append(" for ");
+            sb.append(this.mFragment);
+        }
+        return i;
+    }
+
+    /* renamed from: androidx.fragment.app.FragmentStateManager$2, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass2 {
+        static final /* synthetic */ int[] $SwitchMap$androidx$lifecycle$Lifecycle$State;
+
+        static {
+            int[] iArr = new int[Lifecycle.State.values().length];
+            $SwitchMap$androidx$lifecycle$Lifecycle$State = iArr;
+            try {
+                iArr[Lifecycle.State.RESUMED.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$androidx$lifecycle$Lifecycle$State[Lifecycle.State.STARTED.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                $SwitchMap$androidx$lifecycle$Lifecycle$State[Lifecycle.State.CREATED.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                $SwitchMap$androidx$lifecycle$Lifecycle$State[Lifecycle.State.INITIALIZED.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+        }
+    }
+
+    public void moveToExpectedState() {
+        ViewGroup viewGroup;
+        ViewGroup viewGroup2;
+        ViewGroup viewGroup3;
+        if (this.mMovingToState) {
+            if (FragmentManager.isLoggingEnabled(2)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Ignoring re-entrant call to moveToExpectedState() for ");
+                sb.append(getFragment());
+                return;
+            }
+            return;
+        }
+        try {
+            this.mMovingToState = true;
+            boolean z = false;
+            while (true) {
+                int computeExpectedState = computeExpectedState();
+                Fragment fragment = this.mFragment;
+                int i = fragment.mState;
+                if (computeExpectedState == i) {
+                    if (!z && i == -1 && fragment.mRemoving && !fragment.isInBackStack() && !this.mFragment.mBeingSaved) {
+                        if (FragmentManager.isLoggingEnabled(3)) {
+                            StringBuilder sb2 = new StringBuilder();
+                            sb2.append("Cleaning up state of never attached fragment: ");
+                            sb2.append(this.mFragment);
+                        }
+                        this.mFragmentStore.getNonConfig().clearNonConfigState(this.mFragment);
+                        this.mFragmentStore.makeInactive(this);
+                        if (FragmentManager.isLoggingEnabled(3)) {
+                            StringBuilder sb3 = new StringBuilder();
+                            sb3.append("initState called for fragment: ");
+                            sb3.append(this.mFragment);
+                        }
+                        this.mFragment.initState();
+                    }
+                    Fragment fragment2 = this.mFragment;
+                    if (fragment2.mHiddenChanged) {
+                        if (fragment2.mView != null && (viewGroup = fragment2.mContainer) != null) {
+                            SpecialEffectsController orCreateController = SpecialEffectsController.getOrCreateController(viewGroup, fragment2.getParentFragmentManager());
+                            if (this.mFragment.mHidden) {
+                                orCreateController.enqueueHide(this);
+                            } else {
+                                orCreateController.enqueueShow(this);
+                            }
+                        }
+                        Fragment fragment3 = this.mFragment;
+                        FragmentManager fragmentManager = fragment3.mFragmentManager;
+                        if (fragmentManager != null) {
+                            fragmentManager.invalidateMenuForFragment(fragment3);
+                        }
+                        Fragment fragment4 = this.mFragment;
+                        fragment4.mHiddenChanged = false;
+                        fragment4.onHiddenChanged(fragment4.mHidden);
+                        this.mFragment.mChildFragmentManager.dispatchOnHiddenChanged();
+                    }
+                    this.mMovingToState = false;
+                    return;
+                }
+                if (computeExpectedState > i) {
+                    switch (i + 1) {
+                        case 0:
+                            attach();
+                            break;
+                        case 1:
+                            create();
+                            break;
+                        case 2:
+                            ensureInflatedView();
+                            createView();
+                            break;
+                        case 3:
+                            activityCreated();
+                            break;
+                        case 4:
+                            if (fragment.mView != null && (viewGroup3 = fragment.mContainer) != null) {
+                                SpecialEffectsController.getOrCreateController(viewGroup3, fragment.getParentFragmentManager()).enqueueAdd(SpecialEffectsController.Operation.State.from(this.mFragment.mView.getVisibility()), this);
+                            }
+                            this.mFragment.mState = 4;
+                            break;
+                        case 5:
+                            start();
+                            break;
+                        case 6:
+                            fragment.mState = 6;
+                            break;
+                        case 7:
+                            resume();
+                            break;
+                    }
+                } else {
+                    switch (i - 1) {
+                        case -1:
+                            detach();
+                            break;
+                        case 0:
+                            if (fragment.mBeingSaved && this.mFragmentStore.getSavedState(fragment.mWho) == null) {
+                                saveState();
+                            }
+                            destroy();
+                            break;
+                        case 1:
+                            destroyFragmentView();
+                            this.mFragment.mState = 1;
+                            break;
+                        case 2:
+                            fragment.mInLayout = false;
+                            fragment.mState = 2;
+                            break;
+                        case 3:
+                            if (FragmentManager.isLoggingEnabled(3)) {
+                                StringBuilder sb4 = new StringBuilder();
+                                sb4.append("movefrom ACTIVITY_CREATED: ");
+                                sb4.append(this.mFragment);
+                            }
+                            Fragment fragment5 = this.mFragment;
+                            if (fragment5.mBeingSaved) {
+                                saveState();
+                            } else if (fragment5.mView != null && fragment5.mSavedViewState == null) {
+                                saveViewState();
+                            }
+                            Fragment fragment6 = this.mFragment;
+                            if (fragment6.mView != null && (viewGroup2 = fragment6.mContainer) != null) {
+                                SpecialEffectsController.getOrCreateController(viewGroup2, fragment6.getParentFragmentManager()).enqueueRemove(this);
+                            }
+                            this.mFragment.mState = 3;
+                            break;
+                        case 4:
+                            stop();
+                            break;
+                        case 5:
+                            fragment.mState = 5;
+                            break;
+                        case 6:
+                            pause();
+                            break;
+                    }
+                }
+                z = true;
+            }
+        } catch (Throwable th) {
+            this.mMovingToState = false;
+            throw th;
+        }
+    }
+
+    public void ensureInflatedView() {
+        Fragment fragment = this.mFragment;
+        if (fragment.mFromLayout && fragment.mInLayout && !fragment.mPerformedCreateView) {
+            if (FragmentManager.isLoggingEnabled(3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("moveto CREATE_VIEW: ");
+                sb.append(this.mFragment);
+            }
+            Fragment fragment2 = this.mFragment;
+            fragment2.performCreateView(fragment2.performGetLayoutInflater(fragment2.mSavedFragmentState), null, this.mFragment.mSavedFragmentState);
+            View view = this.mFragment.mView;
+            if (view != null) {
+                view.setSaveFromParentEnabled(false);
+                Fragment fragment3 = this.mFragment;
+                fragment3.mView.setTag(R.id.fragment_container_view_tag, fragment3);
+                Fragment fragment4 = this.mFragment;
+                if (fragment4.mHidden) {
+                    fragment4.mView.setVisibility(8);
+                }
+                this.mFragment.performViewCreated();
+                FragmentLifecycleCallbacksDispatcher fragmentLifecycleCallbacksDispatcher = this.mDispatcher;
+                Fragment fragment5 = this.mFragment;
+                fragmentLifecycleCallbacksDispatcher.dispatchOnFragmentViewCreated(fragment5, fragment5.mView, fragment5.mSavedFragmentState, false);
+                this.mFragment.mState = 2;
+            }
+        }
+    }
+
+    public void restoreState(@NonNull ClassLoader classLoader) {
+        Bundle bundle = this.mFragment.mSavedFragmentState;
+        if (bundle == null) {
+            return;
+        }
+        bundle.setClassLoader(classLoader);
+        Fragment fragment = this.mFragment;
+        fragment.mSavedViewState = fragment.mSavedFragmentState.getSparseParcelableArray(VIEW_STATE_TAG);
+        Fragment fragment2 = this.mFragment;
+        fragment2.mSavedViewRegistryState = fragment2.mSavedFragmentState.getBundle(VIEW_REGISTRY_STATE_TAG);
+        Fragment fragment3 = this.mFragment;
+        fragment3.mTargetWho = fragment3.mSavedFragmentState.getString(TARGET_STATE_TAG);
+        Fragment fragment4 = this.mFragment;
+        if (fragment4.mTargetWho != null) {
+            fragment4.mTargetRequestCode = fragment4.mSavedFragmentState.getInt(TARGET_REQUEST_CODE_STATE_TAG, 0);
+        }
+        Fragment fragment5 = this.mFragment;
+        Boolean bool = fragment5.mSavedUserVisibleHint;
+        if (bool != null) {
+            fragment5.mUserVisibleHint = bool.booleanValue();
+            this.mFragment.mSavedUserVisibleHint = null;
+        } else {
+            fragment5.mUserVisibleHint = fragment5.mSavedFragmentState.getBoolean(USER_VISIBLE_HINT_TAG, true);
+        }
+        Fragment fragment6 = this.mFragment;
+        if (fragment6.mUserVisibleHint) {
+            return;
+        }
+        fragment6.mDeferStart = true;
+    }
+
+    public void attach() {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("moveto ATTACHED: ");
+            sb.append(this.mFragment);
+        }
+        Fragment fragment = this.mFragment;
+        Fragment fragment2 = fragment.mTarget;
+        FragmentStateManager fragmentStateManager = null;
+        if (fragment2 != null) {
+            FragmentStateManager fragmentStateManager2 = this.mFragmentStore.getFragmentStateManager(fragment2.mWho);
+            if (fragmentStateManager2 == null) {
+                throw new IllegalStateException("Fragment " + this.mFragment + " declared target fragment " + this.mFragment.mTarget + " that does not belong to this FragmentManager!");
+            }
+            Fragment fragment3 = this.mFragment;
+            fragment3.mTargetWho = fragment3.mTarget.mWho;
+            fragment3.mTarget = null;
+            fragmentStateManager = fragmentStateManager2;
+        } else {
+            String str = fragment.mTargetWho;
+            if (str != null && (fragmentStateManager = this.mFragmentStore.getFragmentStateManager(str)) == null) {
+                throw new IllegalStateException("Fragment " + this.mFragment + " declared target fragment " + this.mFragment.mTargetWho + " that does not belong to this FragmentManager!");
+            }
+        }
+        if (fragmentStateManager != null) {
+            fragmentStateManager.moveToExpectedState();
+        }
+        Fragment fragment4 = this.mFragment;
+        fragment4.mHost = fragment4.mFragmentManager.getHost();
+        Fragment fragment5 = this.mFragment;
+        fragment5.mParentFragment = fragment5.mFragmentManager.getParent();
+        this.mDispatcher.dispatchOnFragmentPreAttached(this.mFragment, false);
+        this.mFragment.performAttach();
+        this.mDispatcher.dispatchOnFragmentAttached(this.mFragment, false);
+    }
+
+    public void create() {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("moveto CREATED: ");
+            sb.append(this.mFragment);
+        }
+        Fragment fragment = this.mFragment;
+        if (!fragment.mIsCreated) {
+            this.mDispatcher.dispatchOnFragmentPreCreated(fragment, fragment.mSavedFragmentState, false);
+            Fragment fragment2 = this.mFragment;
+            fragment2.performCreate(fragment2.mSavedFragmentState);
+            FragmentLifecycleCallbacksDispatcher fragmentLifecycleCallbacksDispatcher = this.mDispatcher;
+            Fragment fragment3 = this.mFragment;
+            fragmentLifecycleCallbacksDispatcher.dispatchOnFragmentCreated(fragment3, fragment3.mSavedFragmentState, false);
+            return;
+        }
+        fragment.restoreChildFragmentState(fragment.mSavedFragmentState);
+        this.mFragment.mState = 1;
+    }
+
+    public void createView() {
+        String str;
+        if (this.mFragment.mFromLayout) {
+            return;
+        }
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("moveto CREATE_VIEW: ");
+            sb.append(this.mFragment);
+        }
+        Fragment fragment = this.mFragment;
+        LayoutInflater performGetLayoutInflater = fragment.performGetLayoutInflater(fragment.mSavedFragmentState);
+        Fragment fragment2 = this.mFragment;
+        ViewGroup viewGroup = fragment2.mContainer;
+        if (viewGroup == null) {
+            int i = fragment2.mContainerId;
+            if (i == 0) {
+                viewGroup = null;
+            } else {
+                if (i == -1) {
+                    throw new IllegalArgumentException("Cannot create fragment " + this.mFragment + " for a container view with no id");
+                }
+                viewGroup = (ViewGroup) fragment2.mFragmentManager.getContainer().onFindViewById(this.mFragment.mContainerId);
+                if (viewGroup == null) {
+                    Fragment fragment3 = this.mFragment;
+                    if (!fragment3.mRestored) {
+                        try {
+                            str = fragment3.getResources().getResourceName(this.mFragment.mContainerId);
+                        } catch (Resources.NotFoundException unused) {
+                            str = "unknown";
+                        }
+                        throw new IllegalArgumentException("No view found for id 0x" + Integer.toHexString(this.mFragment.mContainerId) + " (" + str + ") for fragment " + this.mFragment);
+                    }
+                } else if (!(viewGroup instanceof FragmentContainerView)) {
+                    FragmentStrictMode.onWrongFragmentContainer(this.mFragment, viewGroup);
+                }
+            }
+        }
+        Fragment fragment4 = this.mFragment;
+        fragment4.mContainer = viewGroup;
+        fragment4.performCreateView(performGetLayoutInflater, viewGroup, fragment4.mSavedFragmentState);
+        View view = this.mFragment.mView;
+        if (view != null) {
+            view.setSaveFromParentEnabled(false);
+            Fragment fragment5 = this.mFragment;
+            fragment5.mView.setTag(R.id.fragment_container_view_tag, fragment5);
+            if (viewGroup != null) {
+                addViewToContainer();
+            }
+            Fragment fragment6 = this.mFragment;
+            if (fragment6.mHidden) {
+                fragment6.mView.setVisibility(8);
+            }
+            if (ViewCompat.isAttachedToWindow(this.mFragment.mView)) {
+                ViewCompat.requestApplyInsets(this.mFragment.mView);
+            } else {
+                final View view2 = this.mFragment.mView;
+                view2.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() { // from class: androidx.fragment.app.FragmentStateManager.1
+                    @Override // android.view.View.OnAttachStateChangeListener
+                    public void onViewDetachedFromWindow(View view3) {
+                    }
+
+                    @Override // android.view.View.OnAttachStateChangeListener
+                    public void onViewAttachedToWindow(View view3) {
+                        view2.removeOnAttachStateChangeListener(this);
+                        ViewCompat.requestApplyInsets(view2);
+                    }
+                });
+            }
+            this.mFragment.performViewCreated();
+            FragmentLifecycleCallbacksDispatcher fragmentLifecycleCallbacksDispatcher = this.mDispatcher;
+            Fragment fragment7 = this.mFragment;
+            fragmentLifecycleCallbacksDispatcher.dispatchOnFragmentViewCreated(fragment7, fragment7.mView, fragment7.mSavedFragmentState, false);
+            int visibility = this.mFragment.mView.getVisibility();
+            this.mFragment.setPostOnViewCreatedAlpha(this.mFragment.mView.getAlpha());
+            Fragment fragment8 = this.mFragment;
+            if (fragment8.mContainer != null && visibility == 0) {
+                View findFocus = fragment8.mView.findFocus();
+                if (findFocus != null) {
+                    this.mFragment.setFocusedView(findFocus);
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb2 = new StringBuilder();
+                        sb2.append("requestFocus: Saved focused view ");
+                        sb2.append(findFocus);
+                        sb2.append(" for Fragment ");
+                        sb2.append(this.mFragment);
+                    }
+                }
+                this.mFragment.mView.setAlpha(0.0f);
+            }
+        }
+        this.mFragment.mState = 2;
+    }
+
+    public void activityCreated() {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("moveto ACTIVITY_CREATED: ");
+            sb.append(this.mFragment);
+        }
+        Fragment fragment = this.mFragment;
+        fragment.performActivityCreated(fragment.mSavedFragmentState);
+        FragmentLifecycleCallbacksDispatcher fragmentLifecycleCallbacksDispatcher = this.mDispatcher;
+        Fragment fragment2 = this.mFragment;
+        fragmentLifecycleCallbacksDispatcher.dispatchOnFragmentActivityCreated(fragment2, fragment2.mSavedFragmentState, false);
+    }
+
+    public void start() {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("moveto STARTED: ");
+            sb.append(this.mFragment);
+        }
+        this.mFragment.performStart();
+        this.mDispatcher.dispatchOnFragmentStarted(this.mFragment, false);
+    }
+
+    public void resume() {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("moveto RESUMED: ");
+            sb.append(this.mFragment);
+        }
+        View focusedView = this.mFragment.getFocusedView();
+        if (focusedView != null && isFragmentViewChild(focusedView)) {
+            boolean requestFocus = focusedView.requestFocus();
+            if (FragmentManager.isLoggingEnabled(2)) {
+                StringBuilder sb2 = new StringBuilder();
+                sb2.append("requestFocus: Restoring focused view ");
+                sb2.append(focusedView);
+                sb2.append(" ");
+                sb2.append(requestFocus ? AnalyticsEvents.PARAMETER_SHARE_OUTCOME_SUCCEEDED : v8.h.t);
+                sb2.append(" on Fragment ");
+                sb2.append(this.mFragment);
+                sb2.append(" resulting in focused view ");
+                sb2.append(this.mFragment.mView.findFocus());
+            }
+        }
+        this.mFragment.setFocusedView(null);
+        this.mFragment.performResume();
+        this.mDispatcher.dispatchOnFragmentResumed(this.mFragment, false);
+        Fragment fragment = this.mFragment;
+        fragment.mSavedFragmentState = null;
+        fragment.mSavedViewState = null;
+        fragment.mSavedViewRegistryState = null;
+    }
+
+    private boolean isFragmentViewChild(@NonNull View view) {
+        if (view == this.mFragment.mView) {
+            return true;
+        }
+        for (ViewParent parent = view.getParent(); parent != null; parent = parent.getParent()) {
+            if (parent == this.mFragment.mView) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void pause() {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("movefrom RESUMED: ");
+            sb.append(this.mFragment);
+        }
+        this.mFragment.performPause();
+        this.mDispatcher.dispatchOnFragmentPaused(this.mFragment, false);
+    }
+
+    public void stop() {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("movefrom STARTED: ");
+            sb.append(this.mFragment);
+        }
+        this.mFragment.performStop();
+        this.mDispatcher.dispatchOnFragmentStopped(this.mFragment, false);
+    }
+
+    public void saveState() {
+        FragmentState fragmentState = new FragmentState(this.mFragment);
+        Fragment fragment = this.mFragment;
+        if (fragment.mState > -1 && fragmentState.mSavedFragmentState == null) {
+            Bundle saveBasicState = saveBasicState();
+            fragmentState.mSavedFragmentState = saveBasicState;
+            if (this.mFragment.mTargetWho != null) {
+                if (saveBasicState == null) {
+                    fragmentState.mSavedFragmentState = new Bundle();
+                }
+                fragmentState.mSavedFragmentState.putString(TARGET_STATE_TAG, this.mFragment.mTargetWho);
+                int i = this.mFragment.mTargetRequestCode;
+                if (i != 0) {
+                    fragmentState.mSavedFragmentState.putInt(TARGET_REQUEST_CODE_STATE_TAG, i);
+                }
+            }
+        } else {
+            fragmentState.mSavedFragmentState = fragment.mSavedFragmentState;
+        }
+        this.mFragmentStore.setSavedState(this.mFragment.mWho, fragmentState);
+    }
+
+    @Nullable
+    public Fragment.SavedState saveInstanceState() {
+        Bundle saveBasicState;
+        if (this.mFragment.mState <= -1 || (saveBasicState = saveBasicState()) == null) {
+            return null;
+        }
+        return new Fragment.SavedState(saveBasicState);
+    }
+
+    private Bundle saveBasicState() {
+        Bundle bundle = new Bundle();
+        this.mFragment.performSaveInstanceState(bundle);
+        this.mDispatcher.dispatchOnFragmentSaveInstanceState(this.mFragment, bundle, false);
+        if (bundle.isEmpty()) {
+            bundle = null;
+        }
+        if (this.mFragment.mView != null) {
+            saveViewState();
+        }
+        if (this.mFragment.mSavedViewState != null) {
+            if (bundle == null) {
+                bundle = new Bundle();
+            }
+            bundle.putSparseParcelableArray(VIEW_STATE_TAG, this.mFragment.mSavedViewState);
+        }
+        if (this.mFragment.mSavedViewRegistryState != null) {
+            if (bundle == null) {
+                bundle = new Bundle();
+            }
+            bundle.putBundle(VIEW_REGISTRY_STATE_TAG, this.mFragment.mSavedViewRegistryState);
+        }
+        if (!this.mFragment.mUserVisibleHint) {
+            if (bundle == null) {
+                bundle = new Bundle();
+            }
+            bundle.putBoolean(USER_VISIBLE_HINT_TAG, this.mFragment.mUserVisibleHint);
+        }
+        return bundle;
+    }
+
+    public void saveViewState() {
+        if (this.mFragment.mView == null) {
+            return;
+        }
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Saving view state for fragment ");
+            sb.append(this.mFragment);
+            sb.append(" with view ");
+            sb.append(this.mFragment.mView);
+        }
+        SparseArray<Parcelable> sparseArray = new SparseArray<>();
+        this.mFragment.mView.saveHierarchyState(sparseArray);
+        if (sparseArray.size() > 0) {
+            this.mFragment.mSavedViewState = sparseArray;
+        }
+        Bundle bundle = new Bundle();
+        this.mFragment.mViewLifecycleOwner.performSave(bundle);
+        if (bundle.isEmpty()) {
+            return;
+        }
+        this.mFragment.mSavedViewRegistryState = bundle;
+    }
+
+    public void destroyFragmentView() {
+        View view;
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("movefrom CREATE_VIEW: ");
+            sb.append(this.mFragment);
+        }
+        Fragment fragment = this.mFragment;
+        ViewGroup viewGroup = fragment.mContainer;
+        if (viewGroup != null && (view = fragment.mView) != null) {
+            viewGroup.removeView(view);
+        }
+        this.mFragment.performDestroyView();
+        this.mDispatcher.dispatchOnFragmentViewDestroyed(this.mFragment, false);
+        Fragment fragment2 = this.mFragment;
+        fragment2.mContainer = null;
+        fragment2.mView = null;
+        fragment2.mViewLifecycleOwner = null;
+        fragment2.mViewLifecycleOwnerLiveData.setValue(null);
+        this.mFragment.mInLayout = false;
+    }
+
+    public void destroy() {
+        Fragment findActiveFragment;
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("movefrom CREATED: ");
+            sb.append(this.mFragment);
+        }
+        Fragment fragment = this.mFragment;
+        boolean z = true;
+        boolean z2 = fragment.mRemoving && !fragment.isInBackStack();
+        if (z2) {
+            Fragment fragment2 = this.mFragment;
+            if (!fragment2.mBeingSaved) {
+                this.mFragmentStore.setSavedState(fragment2.mWho, null);
+            }
+        }
+        if (z2 || this.mFragmentStore.getNonConfig().shouldDestroy(this.mFragment)) {
+            FragmentHostCallback<?> fragmentHostCallback = this.mFragment.mHost;
+            if (fragmentHostCallback instanceof ViewModelStoreOwner) {
+                z = this.mFragmentStore.getNonConfig().isCleared();
+            } else if (fragmentHostCallback.getContext() instanceof Activity) {
+                z = true ^ ((Activity) fragmentHostCallback.getContext()).isChangingConfigurations();
+            }
+            if ((z2 && !this.mFragment.mBeingSaved) || z) {
+                this.mFragmentStore.getNonConfig().clearNonConfigState(this.mFragment);
+            }
+            this.mFragment.performDestroy();
+            this.mDispatcher.dispatchOnFragmentDestroyed(this.mFragment, false);
+            for (FragmentStateManager fragmentStateManager : this.mFragmentStore.getActiveFragmentStateManagers()) {
+                if (fragmentStateManager != null) {
+                    Fragment fragment3 = fragmentStateManager.getFragment();
+                    if (this.mFragment.mWho.equals(fragment3.mTargetWho)) {
+                        fragment3.mTarget = this.mFragment;
+                        fragment3.mTargetWho = null;
+                    }
+                }
+            }
+            Fragment fragment4 = this.mFragment;
+            String str = fragment4.mTargetWho;
+            if (str != null) {
+                fragment4.mTarget = this.mFragmentStore.findActiveFragment(str);
+            }
+            this.mFragmentStore.makeInactive(this);
+            return;
+        }
+        String str2 = this.mFragment.mTargetWho;
+        if (str2 != null && (findActiveFragment = this.mFragmentStore.findActiveFragment(str2)) != null && findActiveFragment.mRetainInstance) {
+            this.mFragment.mTarget = findActiveFragment;
+        }
+        this.mFragment.mState = 0;
+    }
+
+    public void detach() {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("movefrom ATTACHED: ");
+            sb.append(this.mFragment);
+        }
+        this.mFragment.performDetach();
+        this.mDispatcher.dispatchOnFragmentDetached(this.mFragment, false);
+        Fragment fragment = this.mFragment;
+        fragment.mState = -1;
+        fragment.mHost = null;
+        fragment.mParentFragment = null;
+        fragment.mFragmentManager = null;
+        if ((!fragment.mRemoving || fragment.isInBackStack()) && !this.mFragmentStore.getNonConfig().shouldDestroy(this.mFragment)) {
+            return;
+        }
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb2 = new StringBuilder();
+            sb2.append("initState called for fragment: ");
+            sb2.append(this.mFragment);
+        }
+        this.mFragment.initState();
+    }
+
+    public void addViewToContainer() {
+        int findFragmentIndexInContainer = this.mFragmentStore.findFragmentIndexInContainer(this.mFragment);
+        Fragment fragment = this.mFragment;
+        fragment.mContainer.addView(fragment.mView, findFragmentIndexInContainer);
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentStatePagerAdapter.java

@@ -0,0 +1,209 @@
+package androidx.fragment.app;
+
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+import androidx.lifecycle.Lifecycle;
+import androidx.viewpager.widget.PagerAdapter;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import java.util.ArrayList;
+
+@Deprecated
+/* loaded from: classes.dex */
+public abstract class FragmentStatePagerAdapter extends PagerAdapter {
+    public static final int BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT = 1;
+
+    @Deprecated
+    public static final int BEHAVIOR_SET_USER_VISIBLE_HINT = 0;
+    private static final boolean DEBUG = false;
+    private static final String TAG = "FragmentStatePagerAdapt";
+    private final int mBehavior;
+    private FragmentTransaction mCurTransaction;
+    private Fragment mCurrentPrimaryItem;
+    private boolean mExecutingFinishUpdate;
+    private final FragmentManager mFragmentManager;
+    private ArrayList<Fragment> mFragments;
+    private ArrayList<Fragment.SavedState> mSavedState;
+
+    @NonNull
+    public abstract Fragment getItem(int i);
+
+    @Deprecated
+    public FragmentStatePagerAdapter(@NonNull FragmentManager fragmentManager) {
+        this(fragmentManager, 0);
+    }
+
+    public FragmentStatePagerAdapter(@NonNull FragmentManager fragmentManager, int i) {
+        this.mCurTransaction = null;
+        this.mSavedState = new ArrayList<>();
+        this.mFragments = new ArrayList<>();
+        this.mCurrentPrimaryItem = null;
+        this.mFragmentManager = fragmentManager;
+        this.mBehavior = i;
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public void startUpdate(@NonNull ViewGroup viewGroup) {
+        if (viewGroup.getId() != -1) {
+            return;
+        }
+        throw new IllegalStateException("ViewPager with adapter " + this + " requires a view id");
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    @NonNull
+    public Object instantiateItem(@NonNull ViewGroup viewGroup, int i) {
+        Fragment.SavedState savedState;
+        Fragment fragment;
+        if (this.mFragments.size() > i && (fragment = this.mFragments.get(i)) != null) {
+            return fragment;
+        }
+        if (this.mCurTransaction == null) {
+            this.mCurTransaction = this.mFragmentManager.beginTransaction();
+        }
+        Fragment item = getItem(i);
+        if (this.mSavedState.size() > i && (savedState = this.mSavedState.get(i)) != null) {
+            item.setInitialSavedState(savedState);
+        }
+        while (this.mFragments.size() <= i) {
+            this.mFragments.add(null);
+        }
+        item.setMenuVisibility(false);
+        if (this.mBehavior == 0) {
+            item.setUserVisibleHint(false);
+        }
+        this.mFragments.set(i, item);
+        this.mCurTransaction.add(viewGroup.getId(), item);
+        if (this.mBehavior == 1) {
+            this.mCurTransaction.setMaxLifecycle(item, Lifecycle.State.STARTED);
+        }
+        return item;
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public void destroyItem(@NonNull ViewGroup viewGroup, int i, @NonNull Object obj) {
+        Fragment fragment = (Fragment) obj;
+        if (this.mCurTransaction == null) {
+            this.mCurTransaction = this.mFragmentManager.beginTransaction();
+        }
+        while (this.mSavedState.size() <= i) {
+            this.mSavedState.add(null);
+        }
+        this.mSavedState.set(i, fragment.isAdded() ? this.mFragmentManager.saveFragmentInstanceState(fragment) : null);
+        this.mFragments.set(i, null);
+        this.mCurTransaction.remove(fragment);
+        if (fragment.equals(this.mCurrentPrimaryItem)) {
+            this.mCurrentPrimaryItem = null;
+        }
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public void setPrimaryItem(@NonNull ViewGroup viewGroup, int i, @NonNull Object obj) {
+        Fragment fragment = (Fragment) obj;
+        Fragment fragment2 = this.mCurrentPrimaryItem;
+        if (fragment != fragment2) {
+            if (fragment2 != null) {
+                fragment2.setMenuVisibility(false);
+                if (this.mBehavior == 1) {
+                    if (this.mCurTransaction == null) {
+                        this.mCurTransaction = this.mFragmentManager.beginTransaction();
+                    }
+                    this.mCurTransaction.setMaxLifecycle(this.mCurrentPrimaryItem, Lifecycle.State.STARTED);
+                } else {
+                    this.mCurrentPrimaryItem.setUserVisibleHint(false);
+                }
+            }
+            fragment.setMenuVisibility(true);
+            if (this.mBehavior == 1) {
+                if (this.mCurTransaction == null) {
+                    this.mCurTransaction = this.mFragmentManager.beginTransaction();
+                }
+                this.mCurTransaction.setMaxLifecycle(fragment, Lifecycle.State.RESUMED);
+            } else {
+                fragment.setUserVisibleHint(true);
+            }
+            this.mCurrentPrimaryItem = fragment;
+        }
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public void finishUpdate(@NonNull ViewGroup viewGroup) {
+        FragmentTransaction fragmentTransaction = this.mCurTransaction;
+        if (fragmentTransaction != null) {
+            if (!this.mExecutingFinishUpdate) {
+                try {
+                    this.mExecutingFinishUpdate = true;
+                    fragmentTransaction.commitNowAllowingStateLoss();
+                } finally {
+                    this.mExecutingFinishUpdate = false;
+                }
+            }
+            this.mCurTransaction = null;
+        }
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public boolean isViewFromObject(@NonNull View view, @NonNull Object obj) {
+        return ((Fragment) obj).getView() == view;
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    @Nullable
+    public Parcelable saveState() {
+        Bundle bundle;
+        if (this.mSavedState.size() > 0) {
+            bundle = new Bundle();
+            Fragment.SavedState[] savedStateArr = new Fragment.SavedState[this.mSavedState.size()];
+            this.mSavedState.toArray(savedStateArr);
+            bundle.putParcelableArray("states", savedStateArr);
+        } else {
+            bundle = null;
+        }
+        for (int i = 0; i < this.mFragments.size(); i++) {
+            Fragment fragment = this.mFragments.get(i);
+            if (fragment != null && fragment.isAdded()) {
+                if (bundle == null) {
+                    bundle = new Bundle();
+                }
+                this.mFragmentManager.putFragment(bundle, InneractiveMediationDefs.GENDER_FEMALE + i, fragment);
+            }
+        }
+        return bundle;
+    }
+
+    @Override // androidx.viewpager.widget.PagerAdapter
+    public void restoreState(@Nullable Parcelable parcelable, @Nullable ClassLoader classLoader) {
+        if (parcelable != null) {
+            Bundle bundle = (Bundle) parcelable;
+            bundle.setClassLoader(classLoader);
+            Parcelable[] parcelableArray = bundle.getParcelableArray("states");
+            this.mSavedState.clear();
+            this.mFragments.clear();
+            if (parcelableArray != null) {
+                for (Parcelable parcelable2 : parcelableArray) {
+                    this.mSavedState.add((Fragment.SavedState) parcelable2);
+                }
+            }
+            for (String str : bundle.keySet()) {
+                if (str.startsWith(InneractiveMediationDefs.GENDER_FEMALE)) {
+                    int parseInt = Integer.parseInt(str.substring(1));
+                    Fragment fragment = this.mFragmentManager.getFragment(bundle, str);
+                    if (fragment != null) {
+                        while (this.mFragments.size() <= parseInt) {
+                            this.mFragments.add(null);
+                        }
+                        fragment.setMenuVisibility(false);
+                        this.mFragments.set(parseInt, fragment);
+                    } else {
+                        Log.w(TAG, "Bad fragment at key " + str);
+                    }
+                }
+            }
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentStore.java

@@ -0,0 +1,382 @@
+package androidx.fragment.app;
+
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.IdRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes.dex */
+class FragmentStore {
+    private static final String TAG = "FragmentManager";
+    private FragmentManagerViewModel mNonConfig;
+    private final ArrayList<Fragment> mAdded = new ArrayList<>();
+    private final HashMap<String, FragmentStateManager> mActive = new HashMap<>();
+    private final HashMap<String, FragmentState> mSavedState = new HashMap<>();
+
+    public FragmentManagerViewModel getNonConfig() {
+        return this.mNonConfig;
+    }
+
+    public void setNonConfig(@NonNull FragmentManagerViewModel fragmentManagerViewModel) {
+        this.mNonConfig = fragmentManagerViewModel;
+    }
+
+    public void resetActiveFragments() {
+        this.mActive.clear();
+    }
+
+    public void restoreAddedFragments(@Nullable List<String> list) {
+        this.mAdded.clear();
+        if (list != null) {
+            for (String str : list) {
+                Fragment findActiveFragment = findActiveFragment(str);
+                if (findActiveFragment == null) {
+                    throw new IllegalStateException("No instantiated fragment for (" + str + ")");
+                }
+                if (FragmentManager.isLoggingEnabled(2)) {
+                    StringBuilder sb = new StringBuilder();
+                    sb.append("restoreSaveState: added (");
+                    sb.append(str);
+                    sb.append("): ");
+                    sb.append(findActiveFragment);
+                }
+                addFragment(findActiveFragment);
+            }
+        }
+    }
+
+    public void makeActive(@NonNull FragmentStateManager fragmentStateManager) {
+        Fragment fragment = fragmentStateManager.getFragment();
+        if (containsActiveFragment(fragment.mWho)) {
+            return;
+        }
+        this.mActive.put(fragment.mWho, fragmentStateManager);
+        if (fragment.mRetainInstanceChangedWhileDetached) {
+            if (fragment.mRetainInstance) {
+                this.mNonConfig.addRetainedFragment(fragment);
+            } else {
+                this.mNonConfig.removeRetainedFragment(fragment);
+            }
+            fragment.mRetainInstanceChangedWhileDetached = false;
+        }
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Added fragment to active set ");
+            sb.append(fragment);
+        }
+    }
+
+    public void addFragment(@NonNull Fragment fragment) {
+        if (this.mAdded.contains(fragment)) {
+            throw new IllegalStateException("Fragment already added: " + fragment);
+        }
+        synchronized (this.mAdded) {
+            this.mAdded.add(fragment);
+        }
+        fragment.mAdded = true;
+    }
+
+    public void dispatchStateChange(int i) {
+        for (FragmentStateManager fragmentStateManager : this.mActive.values()) {
+            if (fragmentStateManager != null) {
+                fragmentStateManager.setFragmentManagerState(i);
+            }
+        }
+    }
+
+    public void moveToExpectedState() {
+        Iterator<Fragment> it = this.mAdded.iterator();
+        while (it.hasNext()) {
+            FragmentStateManager fragmentStateManager = this.mActive.get(it.next().mWho);
+            if (fragmentStateManager != null) {
+                fragmentStateManager.moveToExpectedState();
+            }
+        }
+        for (FragmentStateManager fragmentStateManager2 : this.mActive.values()) {
+            if (fragmentStateManager2 != null) {
+                fragmentStateManager2.moveToExpectedState();
+                Fragment fragment = fragmentStateManager2.getFragment();
+                if (fragment.mRemoving && !fragment.isInBackStack()) {
+                    if (fragment.mBeingSaved && !this.mSavedState.containsKey(fragment.mWho)) {
+                        fragmentStateManager2.saveState();
+                    }
+                    makeInactive(fragmentStateManager2);
+                }
+            }
+        }
+    }
+
+    public void removeFragment(@NonNull Fragment fragment) {
+        synchronized (this.mAdded) {
+            this.mAdded.remove(fragment);
+        }
+        fragment.mAdded = false;
+    }
+
+    public void makeInactive(@NonNull FragmentStateManager fragmentStateManager) {
+        Fragment fragment = fragmentStateManager.getFragment();
+        if (fragment.mRetainInstance) {
+            this.mNonConfig.removeRetainedFragment(fragment);
+        }
+        if (this.mActive.put(fragment.mWho, null) != null && FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Removed fragment from active set ");
+            sb.append(fragment);
+        }
+    }
+
+    public void burpActive() {
+        this.mActive.values().removeAll(Collections.singleton(null));
+    }
+
+    @Nullable
+    public FragmentState getSavedState(@NonNull String str) {
+        return this.mSavedState.get(str);
+    }
+
+    @Nullable
+    public FragmentState setSavedState(@NonNull String str, @Nullable FragmentState fragmentState) {
+        if (fragmentState != null) {
+            return this.mSavedState.put(str, fragmentState);
+        }
+        return this.mSavedState.remove(str);
+    }
+
+    public void restoreSaveState(@NonNull ArrayList<FragmentState> arrayList) {
+        this.mSavedState.clear();
+        Iterator<FragmentState> it = arrayList.iterator();
+        while (it.hasNext()) {
+            FragmentState next = it.next();
+            this.mSavedState.put(next.mWho, next);
+        }
+    }
+
+    @NonNull
+    public ArrayList<FragmentState> getAllSavedState() {
+        return new ArrayList<>(this.mSavedState.values());
+    }
+
+    @NonNull
+    public ArrayList<String> saveActiveFragments() {
+        ArrayList<String> arrayList = new ArrayList<>(this.mActive.size());
+        for (FragmentStateManager fragmentStateManager : this.mActive.values()) {
+            if (fragmentStateManager != null) {
+                Fragment fragment = fragmentStateManager.getFragment();
+                fragmentStateManager.saveState();
+                arrayList.add(fragment.mWho);
+                if (FragmentManager.isLoggingEnabled(2)) {
+                    StringBuilder sb = new StringBuilder();
+                    sb.append("Saved state of ");
+                    sb.append(fragment);
+                    sb.append(": ");
+                    sb.append(fragment.mSavedFragmentState);
+                }
+            }
+        }
+        return arrayList;
+    }
+
+    @Nullable
+    public ArrayList<String> saveAddedFragments() {
+        synchronized (this.mAdded) {
+            try {
+                if (this.mAdded.isEmpty()) {
+                    return null;
+                }
+                ArrayList<String> arrayList = new ArrayList<>(this.mAdded.size());
+                Iterator<Fragment> it = this.mAdded.iterator();
+                while (it.hasNext()) {
+                    Fragment next = it.next();
+                    arrayList.add(next.mWho);
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb = new StringBuilder();
+                        sb.append("saveAllState: adding fragment (");
+                        sb.append(next.mWho);
+                        sb.append("): ");
+                        sb.append(next);
+                    }
+                }
+                return arrayList;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @NonNull
+    public List<FragmentStateManager> getActiveFragmentStateManagers() {
+        ArrayList arrayList = new ArrayList();
+        for (FragmentStateManager fragmentStateManager : this.mActive.values()) {
+            if (fragmentStateManager != null) {
+                arrayList.add(fragmentStateManager);
+            }
+        }
+        return arrayList;
+    }
+
+    @NonNull
+    public List<Fragment> getFragments() {
+        ArrayList arrayList;
+        if (this.mAdded.isEmpty()) {
+            return Collections.emptyList();
+        }
+        synchronized (this.mAdded) {
+            arrayList = new ArrayList(this.mAdded);
+        }
+        return arrayList;
+    }
+
+    @NonNull
+    public List<Fragment> getActiveFragments() {
+        ArrayList arrayList = new ArrayList();
+        for (FragmentStateManager fragmentStateManager : this.mActive.values()) {
+            if (fragmentStateManager != null) {
+                arrayList.add(fragmentStateManager.getFragment());
+            } else {
+                arrayList.add(null);
+            }
+        }
+        return arrayList;
+    }
+
+    public int getActiveFragmentCount() {
+        return this.mActive.size();
+    }
+
+    @Nullable
+    public Fragment findFragmentById(@IdRes int i) {
+        for (int size = this.mAdded.size() - 1; size >= 0; size--) {
+            Fragment fragment = this.mAdded.get(size);
+            if (fragment != null && fragment.mFragmentId == i) {
+                return fragment;
+            }
+        }
+        for (FragmentStateManager fragmentStateManager : this.mActive.values()) {
+            if (fragmentStateManager != null) {
+                Fragment fragment2 = fragmentStateManager.getFragment();
+                if (fragment2.mFragmentId == i) {
+                    return fragment2;
+                }
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    public Fragment findFragmentByTag(@Nullable String str) {
+        if (str != null) {
+            for (int size = this.mAdded.size() - 1; size >= 0; size--) {
+                Fragment fragment = this.mAdded.get(size);
+                if (fragment != null && str.equals(fragment.mTag)) {
+                    return fragment;
+                }
+            }
+        }
+        if (str == null) {
+            return null;
+        }
+        for (FragmentStateManager fragmentStateManager : this.mActive.values()) {
+            if (fragmentStateManager != null) {
+                Fragment fragment2 = fragmentStateManager.getFragment();
+                if (str.equals(fragment2.mTag)) {
+                    return fragment2;
+                }
+            }
+        }
+        return null;
+    }
+
+    public boolean containsActiveFragment(@NonNull String str) {
+        return this.mActive.get(str) != null;
+    }
+
+    @Nullable
+    public FragmentStateManager getFragmentStateManager(@NonNull String str) {
+        return this.mActive.get(str);
+    }
+
+    @Nullable
+    public Fragment findFragmentByWho(@NonNull String str) {
+        Fragment findFragmentByWho;
+        for (FragmentStateManager fragmentStateManager : this.mActive.values()) {
+            if (fragmentStateManager != null && (findFragmentByWho = fragmentStateManager.getFragment().findFragmentByWho(str)) != null) {
+                return findFragmentByWho;
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    public Fragment findActiveFragment(@NonNull String str) {
+        FragmentStateManager fragmentStateManager = this.mActive.get(str);
+        if (fragmentStateManager != null) {
+            return fragmentStateManager.getFragment();
+        }
+        return null;
+    }
+
+    public int findFragmentIndexInContainer(@NonNull Fragment fragment) {
+        View view;
+        View view2;
+        ViewGroup viewGroup = fragment.mContainer;
+        if (viewGroup == null) {
+            return -1;
+        }
+        int indexOf = this.mAdded.indexOf(fragment);
+        for (int i = indexOf - 1; i >= 0; i--) {
+            Fragment fragment2 = this.mAdded.get(i);
+            if (fragment2.mContainer == viewGroup && (view2 = fragment2.mView) != null) {
+                return viewGroup.indexOfChild(view2) + 1;
+            }
+        }
+        while (true) {
+            indexOf++;
+            if (indexOf >= this.mAdded.size()) {
+                return -1;
+            }
+            Fragment fragment3 = this.mAdded.get(indexOf);
+            if (fragment3.mContainer == viewGroup && (view = fragment3.mView) != null) {
+                return viewGroup.indexOfChild(view);
+            }
+        }
+    }
+
+    public void dump(@NonNull String str, @Nullable FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @Nullable String[] strArr) {
+        String str2 = str + "    ";
+        if (!this.mActive.isEmpty()) {
+            printWriter.print(str);
+            printWriter.println("Active Fragments:");
+            for (FragmentStateManager fragmentStateManager : this.mActive.values()) {
+                printWriter.print(str);
+                if (fragmentStateManager != null) {
+                    Fragment fragment = fragmentStateManager.getFragment();
+                    printWriter.println(fragment);
+                    fragment.dump(str2, fileDescriptor, printWriter, strArr);
+                } else {
+                    printWriter.println("null");
+                }
+            }
+        }
+        int size = this.mAdded.size();
+        if (size > 0) {
+            printWriter.print(str);
+            printWriter.println("Added Fragments:");
+            for (int i = 0; i < size; i++) {
+                Fragment fragment2 = this.mAdded.get(i);
+                printWriter.print(str);
+                printWriter.print("  #");
+                printWriter.print(i);
+                printWriter.print(": ");
+                printWriter.println(fragment2.toString());
+            }
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentTabHost.java

@@ -0,0 +1,318 @@
+package androidx.fragment.app;
+
+import android.R;
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.TabHost;
+import android.widget.TabWidget;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+
+@Deprecated
+/* loaded from: classes.dex */
+public class FragmentTabHost extends TabHost implements TabHost.OnTabChangeListener {
+    private boolean mAttached;
+    private int mContainerId;
+    private Context mContext;
+    private FragmentManager mFragmentManager;
+    private TabInfo mLastTab;
+    private TabHost.OnTabChangeListener mOnTabChangeListener;
+    private FrameLayout mRealTabContent;
+    private final ArrayList<TabInfo> mTabs;
+
+    @Override // android.widget.TabHost
+    @Deprecated
+    public void setOnTabChangedListener(@Nullable TabHost.OnTabChangeListener onTabChangeListener) {
+        this.mOnTabChangeListener = onTabChangeListener;
+    }
+
+    public static final class TabInfo {
+
+        @Nullable
+        final Bundle args;
+
+        @NonNull
+        final Class<?> clss;
+        Fragment fragment;
+
+        @NonNull
+        final String tag;
+
+        public TabInfo(@NonNull String str, @NonNull Class<?> cls, @Nullable Bundle bundle) {
+            this.tag = str;
+            this.clss = cls;
+            this.args = bundle;
+        }
+    }
+
+    public static class DummyTabFactory implements TabHost.TabContentFactory {
+        private final Context mContext;
+
+        public DummyTabFactory(Context context) {
+            this.mContext = context;
+        }
+
+        @Override // android.widget.TabHost.TabContentFactory
+        public View createTabContent(String str) {
+            View view = new View(this.mContext);
+            view.setMinimumWidth(0);
+            view.setMinimumHeight(0);
+            return view;
+        }
+    }
+
+    public static class SavedState extends View.BaseSavedState {
+        public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() { // from class: androidx.fragment.app.FragmentTabHost.SavedState.1
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // android.os.Parcelable.Creator
+            public SavedState createFromParcel(Parcel parcel) {
+                return new SavedState(parcel);
+            }
+
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // android.os.Parcelable.Creator
+            public SavedState[] newArray(int i) {
+                return new SavedState[i];
+            }
+        };
+        String curTab;
+
+        public SavedState(Parcelable parcelable) {
+            super(parcelable);
+        }
+
+        public SavedState(Parcel parcel) {
+            super(parcel);
+            this.curTab = parcel.readString();
+        }
+
+        @Override // android.view.View.BaseSavedState, android.view.AbsSavedState, android.os.Parcelable
+        public void writeToParcel(Parcel parcel, int i) {
+            super.writeToParcel(parcel, i);
+            parcel.writeString(this.curTab);
+        }
+
+        @NonNull
+        public String toString() {
+            return "FragmentTabHost.SavedState{" + Integer.toHexString(System.identityHashCode(this)) + " curTab=" + this.curTab + "}";
+        }
+    }
+
+    @Deprecated
+    public FragmentTabHost(@NonNull Context context) {
+        super(context, null);
+        this.mTabs = new ArrayList<>();
+        initFragmentTabHost(context, null);
+    }
+
+    @Deprecated
+    public FragmentTabHost(@NonNull Context context, @Nullable AttributeSet attributeSet) {
+        super(context, attributeSet);
+        this.mTabs = new ArrayList<>();
+        initFragmentTabHost(context, attributeSet);
+    }
+
+    private void initFragmentTabHost(Context context, AttributeSet attributeSet) {
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, new int[]{R.attr.inflatedId}, 0, 0);
+        this.mContainerId = obtainStyledAttributes.getResourceId(0, 0);
+        obtainStyledAttributes.recycle();
+        super.setOnTabChangedListener(this);
+    }
+
+    private void ensureHierarchy(Context context) {
+        if (findViewById(R.id.tabs) == null) {
+            LinearLayout linearLayout = new LinearLayout(context);
+            linearLayout.setOrientation(1);
+            addView(linearLayout, new FrameLayout.LayoutParams(-1, -1));
+            TabWidget tabWidget = new TabWidget(context);
+            tabWidget.setId(R.id.tabs);
+            tabWidget.setOrientation(0);
+            linearLayout.addView(tabWidget, new LinearLayout.LayoutParams(-1, -2, 0.0f));
+            FrameLayout frameLayout = new FrameLayout(context);
+            frameLayout.setId(R.id.tabcontent);
+            linearLayout.addView(frameLayout, new LinearLayout.LayoutParams(0, 0, 0.0f));
+            FrameLayout frameLayout2 = new FrameLayout(context);
+            this.mRealTabContent = frameLayout2;
+            frameLayout2.setId(this.mContainerId);
+            linearLayout.addView(frameLayout2, new LinearLayout.LayoutParams(-1, 0, 1.0f));
+        }
+    }
+
+    @Override // android.widget.TabHost
+    @Deprecated
+    public void setup() {
+        throw new IllegalStateException("Must call setup() that takes a Context and FragmentManager");
+    }
+
+    @Deprecated
+    public void setup(@NonNull Context context, @NonNull FragmentManager fragmentManager) {
+        ensureHierarchy(context);
+        super.setup();
+        this.mContext = context;
+        this.mFragmentManager = fragmentManager;
+        ensureContent();
+    }
+
+    @Deprecated
+    public void setup(@NonNull Context context, @NonNull FragmentManager fragmentManager, int i) {
+        ensureHierarchy(context);
+        super.setup();
+        this.mContext = context;
+        this.mFragmentManager = fragmentManager;
+        this.mContainerId = i;
+        ensureContent();
+        this.mRealTabContent.setId(i);
+        if (getId() == -1) {
+            setId(R.id.tabhost);
+        }
+    }
+
+    private void ensureContent() {
+        if (this.mRealTabContent == null) {
+            FrameLayout frameLayout = (FrameLayout) findViewById(this.mContainerId);
+            this.mRealTabContent = frameLayout;
+            if (frameLayout != null) {
+                return;
+            }
+            throw new IllegalStateException("No tab content FrameLayout found for id " + this.mContainerId);
+        }
+    }
+
+    @Deprecated
+    public void addTab(@NonNull TabHost.TabSpec tabSpec, @NonNull Class<?> cls, @Nullable Bundle bundle) {
+        tabSpec.setContent(new DummyTabFactory(this.mContext));
+        String tag = tabSpec.getTag();
+        TabInfo tabInfo = new TabInfo(tag, cls, bundle);
+        if (this.mAttached) {
+            Fragment findFragmentByTag = this.mFragmentManager.findFragmentByTag(tag);
+            tabInfo.fragment = findFragmentByTag;
+            if (findFragmentByTag != null && !findFragmentByTag.isDetached()) {
+                FragmentTransaction beginTransaction = this.mFragmentManager.beginTransaction();
+                beginTransaction.detach(tabInfo.fragment);
+                beginTransaction.commit();
+            }
+        }
+        this.mTabs.add(tabInfo);
+        addTab(tabSpec);
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    @Deprecated
+    public void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        String currentTabTag = getCurrentTabTag();
+        int size = this.mTabs.size();
+        FragmentTransaction fragmentTransaction = null;
+        for (int i = 0; i < size; i++) {
+            TabInfo tabInfo = this.mTabs.get(i);
+            Fragment findFragmentByTag = this.mFragmentManager.findFragmentByTag(tabInfo.tag);
+            tabInfo.fragment = findFragmentByTag;
+            if (findFragmentByTag != null && !findFragmentByTag.isDetached()) {
+                if (tabInfo.tag.equals(currentTabTag)) {
+                    this.mLastTab = tabInfo;
+                } else {
+                    if (fragmentTransaction == null) {
+                        fragmentTransaction = this.mFragmentManager.beginTransaction();
+                    }
+                    fragmentTransaction.detach(tabInfo.fragment);
+                }
+            }
+        }
+        this.mAttached = true;
+        FragmentTransaction doTabChanged = doTabChanged(currentTabTag, fragmentTransaction);
+        if (doTabChanged != null) {
+            doTabChanged.commit();
+            this.mFragmentManager.executePendingTransactions();
+        }
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    @Deprecated
+    public void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        this.mAttached = false;
+    }
+
+    @Override // android.view.View
+    @NonNull
+    @Deprecated
+    public Parcelable onSaveInstanceState() {
+        SavedState savedState = new SavedState(super.onSaveInstanceState());
+        savedState.curTab = getCurrentTabTag();
+        return savedState;
+    }
+
+    @Override // android.view.View
+    @Deprecated
+    public void onRestoreInstanceState(@SuppressLint({"UnknownNullness"}) Parcelable parcelable) {
+        if (!(parcelable instanceof SavedState)) {
+            super.onRestoreInstanceState(parcelable);
+            return;
+        }
+        SavedState savedState = (SavedState) parcelable;
+        super.onRestoreInstanceState(savedState.getSuperState());
+        setCurrentTabByTag(savedState.curTab);
+    }
+
+    @Override // android.widget.TabHost.OnTabChangeListener
+    @Deprecated
+    public void onTabChanged(@Nullable String str) {
+        FragmentTransaction doTabChanged;
+        if (this.mAttached && (doTabChanged = doTabChanged(str, null)) != null) {
+            doTabChanged.commit();
+        }
+        TabHost.OnTabChangeListener onTabChangeListener = this.mOnTabChangeListener;
+        if (onTabChangeListener != null) {
+            onTabChangeListener.onTabChanged(str);
+        }
+    }
+
+    @Nullable
+    private FragmentTransaction doTabChanged(@Nullable String str, @Nullable FragmentTransaction fragmentTransaction) {
+        Fragment fragment;
+        TabInfo tabInfoForTag = getTabInfoForTag(str);
+        if (this.mLastTab != tabInfoForTag) {
+            if (fragmentTransaction == null) {
+                fragmentTransaction = this.mFragmentManager.beginTransaction();
+            }
+            TabInfo tabInfo = this.mLastTab;
+            if (tabInfo != null && (fragment = tabInfo.fragment) != null) {
+                fragmentTransaction.detach(fragment);
+            }
+            if (tabInfoForTag != null) {
+                Fragment fragment2 = tabInfoForTag.fragment;
+                if (fragment2 == null) {
+                    Fragment instantiate = this.mFragmentManager.getFragmentFactory().instantiate(this.mContext.getClassLoader(), tabInfoForTag.clss.getName());
+                    tabInfoForTag.fragment = instantiate;
+                    instantiate.setArguments(tabInfoForTag.args);
+                    fragmentTransaction.add(this.mContainerId, tabInfoForTag.fragment, tabInfoForTag.tag);
+                } else {
+                    fragmentTransaction.attach(fragment2);
+                }
+            }
+            this.mLastTab = tabInfoForTag;
+        }
+        return fragmentTransaction;
+    }
+
+    @Nullable
+    private TabInfo getTabInfoForTag(String str) {
+        int size = this.mTabs.size();
+        for (int i = 0; i < size; i++) {
+            TabInfo tabInfo = this.mTabs.get(i);
+            if (tabInfo.tag.equals(str)) {
+                return tabInfo;
+            }
+        }
+        return null;
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentTransaction.java

@@ -0,0 +1,463 @@
+package androidx.fragment.app;
+
+import android.os.Bundle;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.AnimRes;
+import androidx.annotation.AnimatorRes;
+import androidx.annotation.IdRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.StringRes;
+import androidx.annotation.StyleRes;
+import androidx.core.view.ViewCompat;
+import androidx.fragment.app.strictmode.FragmentStrictMode;
+import androidx.lifecycle.Lifecycle;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public abstract class FragmentTransaction {
+    static final int OP_ADD = 1;
+    static final int OP_ATTACH = 7;
+    static final int OP_DETACH = 6;
+    static final int OP_HIDE = 4;
+    static final int OP_NULL = 0;
+    static final int OP_REMOVE = 3;
+    static final int OP_REPLACE = 2;
+    static final int OP_SET_MAX_LIFECYCLE = 10;
+    static final int OP_SET_PRIMARY_NAV = 8;
+    static final int OP_SHOW = 5;
+    static final int OP_UNSET_PRIMARY_NAV = 9;
+    public static final int TRANSIT_ENTER_MASK = 4096;
+    public static final int TRANSIT_EXIT_MASK = 8192;
+    public static final int TRANSIT_FRAGMENT_CLOSE = 8194;
+    public static final int TRANSIT_FRAGMENT_FADE = 4099;
+    public static final int TRANSIT_FRAGMENT_MATCH_ACTIVITY_CLOSE = 8197;
+    public static final int TRANSIT_FRAGMENT_MATCH_ACTIVITY_OPEN = 4100;
+    public static final int TRANSIT_FRAGMENT_OPEN = 4097;
+    public static final int TRANSIT_NONE = 0;
+    public static final int TRANSIT_UNSET = -1;
+    boolean mAddToBackStack;
+    boolean mAllowAddToBackStack;
+    int mBreadCrumbShortTitleRes;
+    CharSequence mBreadCrumbShortTitleText;
+    int mBreadCrumbTitleRes;
+    CharSequence mBreadCrumbTitleText;
+    private final ClassLoader mClassLoader;
+    ArrayList<Runnable> mCommitRunnables;
+    int mEnterAnim;
+    int mExitAnim;
+    private final FragmentFactory mFragmentFactory;
+
+    @Nullable
+    String mName;
+    ArrayList<Op> mOps;
+    int mPopEnterAnim;
+    int mPopExitAnim;
+    boolean mReorderingAllowed;
+    ArrayList<String> mSharedElementSourceNames;
+    ArrayList<String> mSharedElementTargetNames;
+    int mTransition;
+
+    public abstract int commit();
+
+    public abstract int commitAllowingStateLoss();
+
+    public abstract void commitNow();
+
+    public abstract void commitNowAllowingStateLoss();
+
+    public boolean isAddToBackStackAllowed() {
+        return this.mAllowAddToBackStack;
+    }
+
+    @NonNull
+    @Deprecated
+    public FragmentTransaction setBreadCrumbShortTitle(@StringRes int i) {
+        this.mBreadCrumbShortTitleRes = i;
+        this.mBreadCrumbShortTitleText = null;
+        return this;
+    }
+
+    @NonNull
+    @Deprecated
+    public FragmentTransaction setBreadCrumbShortTitle(@Nullable CharSequence charSequence) {
+        this.mBreadCrumbShortTitleRes = 0;
+        this.mBreadCrumbShortTitleText = charSequence;
+        return this;
+    }
+
+    @NonNull
+    @Deprecated
+    public FragmentTransaction setBreadCrumbTitle(@StringRes int i) {
+        this.mBreadCrumbTitleRes = i;
+        this.mBreadCrumbTitleText = null;
+        return this;
+    }
+
+    @NonNull
+    @Deprecated
+    public FragmentTransaction setBreadCrumbTitle(@Nullable CharSequence charSequence) {
+        this.mBreadCrumbTitleRes = 0;
+        this.mBreadCrumbTitleText = charSequence;
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction setCustomAnimations(@AnimRes @AnimatorRes int i, @AnimRes @AnimatorRes int i2, @AnimRes @AnimatorRes int i3, @AnimRes @AnimatorRes int i4) {
+        this.mEnterAnim = i;
+        this.mExitAnim = i2;
+        this.mPopEnterAnim = i3;
+        this.mPopExitAnim = i4;
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction setReorderingAllowed(boolean z) {
+        this.mReorderingAllowed = z;
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction setTransition(int i) {
+        this.mTransition = i;
+        return this;
+    }
+
+    @NonNull
+    @Deprecated
+    public FragmentTransaction setTransitionStyle(@StyleRes int i) {
+        return this;
+    }
+
+    public static final class Op {
+        int mCmd;
+        Lifecycle.State mCurrentMaxState;
+        int mEnterAnim;
+        int mExitAnim;
+        Fragment mFragment;
+        boolean mFromExpandedOp;
+        Lifecycle.State mOldMaxState;
+        int mPopEnterAnim;
+        int mPopExitAnim;
+
+        public Op() {
+        }
+
+        public Op(int i, Fragment fragment) {
+            this.mCmd = i;
+            this.mFragment = fragment;
+            this.mFromExpandedOp = false;
+            Lifecycle.State state = Lifecycle.State.RESUMED;
+            this.mOldMaxState = state;
+            this.mCurrentMaxState = state;
+        }
+
+        public Op(int i, Fragment fragment, boolean z) {
+            this.mCmd = i;
+            this.mFragment = fragment;
+            this.mFromExpandedOp = z;
+            Lifecycle.State state = Lifecycle.State.RESUMED;
+            this.mOldMaxState = state;
+            this.mCurrentMaxState = state;
+        }
+
+        public Op(int i, @NonNull Fragment fragment, Lifecycle.State state) {
+            this.mCmd = i;
+            this.mFragment = fragment;
+            this.mFromExpandedOp = false;
+            this.mOldMaxState = fragment.mMaxState;
+            this.mCurrentMaxState = state;
+        }
+
+        public Op(Op op) {
+            this.mCmd = op.mCmd;
+            this.mFragment = op.mFragment;
+            this.mFromExpandedOp = op.mFromExpandedOp;
+            this.mEnterAnim = op.mEnterAnim;
+            this.mExitAnim = op.mExitAnim;
+            this.mPopEnterAnim = op.mPopEnterAnim;
+            this.mPopExitAnim = op.mPopExitAnim;
+            this.mOldMaxState = op.mOldMaxState;
+            this.mCurrentMaxState = op.mCurrentMaxState;
+        }
+    }
+
+    @Deprecated
+    public FragmentTransaction() {
+        this.mOps = new ArrayList<>();
+        this.mAllowAddToBackStack = true;
+        this.mReorderingAllowed = false;
+        this.mFragmentFactory = null;
+        this.mClassLoader = null;
+    }
+
+    public FragmentTransaction(@NonNull FragmentFactory fragmentFactory, @Nullable ClassLoader classLoader) {
+        this.mOps = new ArrayList<>();
+        this.mAllowAddToBackStack = true;
+        this.mReorderingAllowed = false;
+        this.mFragmentFactory = fragmentFactory;
+        this.mClassLoader = classLoader;
+    }
+
+    public FragmentTransaction(@NonNull FragmentFactory fragmentFactory, @Nullable ClassLoader classLoader, @NonNull FragmentTransaction fragmentTransaction) {
+        this(fragmentFactory, classLoader);
+        Iterator<Op> it = fragmentTransaction.mOps.iterator();
+        while (it.hasNext()) {
+            this.mOps.add(new Op(it.next()));
+        }
+        this.mEnterAnim = fragmentTransaction.mEnterAnim;
+        this.mExitAnim = fragmentTransaction.mExitAnim;
+        this.mPopEnterAnim = fragmentTransaction.mPopEnterAnim;
+        this.mPopExitAnim = fragmentTransaction.mPopExitAnim;
+        this.mTransition = fragmentTransaction.mTransition;
+        this.mAddToBackStack = fragmentTransaction.mAddToBackStack;
+        this.mAllowAddToBackStack = fragmentTransaction.mAllowAddToBackStack;
+        this.mName = fragmentTransaction.mName;
+        this.mBreadCrumbShortTitleRes = fragmentTransaction.mBreadCrumbShortTitleRes;
+        this.mBreadCrumbShortTitleText = fragmentTransaction.mBreadCrumbShortTitleText;
+        this.mBreadCrumbTitleRes = fragmentTransaction.mBreadCrumbTitleRes;
+        this.mBreadCrumbTitleText = fragmentTransaction.mBreadCrumbTitleText;
+        if (fragmentTransaction.mSharedElementSourceNames != null) {
+            ArrayList<String> arrayList = new ArrayList<>();
+            this.mSharedElementSourceNames = arrayList;
+            arrayList.addAll(fragmentTransaction.mSharedElementSourceNames);
+        }
+        if (fragmentTransaction.mSharedElementTargetNames != null) {
+            ArrayList<String> arrayList2 = new ArrayList<>();
+            this.mSharedElementTargetNames = arrayList2;
+            arrayList2.addAll(fragmentTransaction.mSharedElementTargetNames);
+        }
+        this.mReorderingAllowed = fragmentTransaction.mReorderingAllowed;
+    }
+
+    public void addOp(Op op) {
+        this.mOps.add(op);
+        op.mEnterAnim = this.mEnterAnim;
+        op.mExitAnim = this.mExitAnim;
+        op.mPopEnterAnim = this.mPopEnterAnim;
+        op.mPopExitAnim = this.mPopExitAnim;
+    }
+
+    @NonNull
+    private Fragment createFragment(@NonNull Class<? extends Fragment> cls, @Nullable Bundle bundle) {
+        FragmentFactory fragmentFactory = this.mFragmentFactory;
+        if (fragmentFactory == null) {
+            throw new IllegalStateException("Creating a Fragment requires that this FragmentTransaction was built with FragmentManager.beginTransaction()");
+        }
+        ClassLoader classLoader = this.mClassLoader;
+        if (classLoader == null) {
+            throw new IllegalStateException("The FragmentManager must be attached to itshost to create a Fragment");
+        }
+        Fragment instantiate = fragmentFactory.instantiate(classLoader, cls.getName());
+        if (bundle != null) {
+            instantiate.setArguments(bundle);
+        }
+        return instantiate;
+    }
+
+    @NonNull
+    public final FragmentTransaction add(@NonNull Class<? extends Fragment> cls, @Nullable Bundle bundle, @Nullable String str) {
+        return add(createFragment(cls, bundle), str);
+    }
+
+    @NonNull
+    public FragmentTransaction add(@NonNull Fragment fragment, @Nullable String str) {
+        doAddOp(0, fragment, str, 1);
+        return this;
+    }
+
+    @NonNull
+    public final FragmentTransaction add(@IdRes int i, @NonNull Class<? extends Fragment> cls, @Nullable Bundle bundle) {
+        return add(i, createFragment(cls, bundle));
+    }
+
+    @NonNull
+    public FragmentTransaction add(@IdRes int i, @NonNull Fragment fragment) {
+        doAddOp(i, fragment, null, 1);
+        return this;
+    }
+
+    @NonNull
+    public final FragmentTransaction add(@IdRes int i, @NonNull Class<? extends Fragment> cls, @Nullable Bundle bundle, @Nullable String str) {
+        return add(i, createFragment(cls, bundle), str);
+    }
+
+    @NonNull
+    public FragmentTransaction add(@IdRes int i, @NonNull Fragment fragment, @Nullable String str) {
+        doAddOp(i, fragment, str, 1);
+        return this;
+    }
+
+    public FragmentTransaction add(@NonNull ViewGroup viewGroup, @NonNull Fragment fragment, @Nullable String str) {
+        fragment.mContainer = viewGroup;
+        return add(viewGroup.getId(), fragment, str);
+    }
+
+    public void doAddOp(int i, Fragment fragment, @Nullable String str, int i2) {
+        String str2 = fragment.mPreviousWho;
+        if (str2 != null) {
+            FragmentStrictMode.onFragmentReuse(fragment, str2);
+        }
+        Class<?> cls = fragment.getClass();
+        int modifiers = cls.getModifiers();
+        if (cls.isAnonymousClass() || !Modifier.isPublic(modifiers) || (cls.isMemberClass() && !Modifier.isStatic(modifiers))) {
+            throw new IllegalStateException("Fragment " + cls.getCanonicalName() + " must be a public static class to be  properly recreated from instance state.");
+        }
+        if (str != null) {
+            String str3 = fragment.mTag;
+            if (str3 != null && !str.equals(str3)) {
+                throw new IllegalStateException("Can't change tag of fragment " + fragment + ": was " + fragment.mTag + " now " + str);
+            }
+            fragment.mTag = str;
+        }
+        if (i != 0) {
+            if (i == -1) {
+                throw new IllegalArgumentException("Can't add fragment " + fragment + " with tag " + str + " to container view with no id");
+            }
+            int i3 = fragment.mFragmentId;
+            if (i3 != 0 && i3 != i) {
+                throw new IllegalStateException("Can't change container ID of fragment " + fragment + ": was " + fragment.mFragmentId + " now " + i);
+            }
+            fragment.mFragmentId = i;
+            fragment.mContainerId = i;
+        }
+        addOp(new Op(i2, fragment));
+    }
+
+    @NonNull
+    public final FragmentTransaction replace(@IdRes int i, @NonNull Class<? extends Fragment> cls, @Nullable Bundle bundle) {
+        return replace(i, cls, bundle, null);
+    }
+
+    @NonNull
+    public FragmentTransaction replace(@IdRes int i, @NonNull Fragment fragment) {
+        return replace(i, fragment, (String) null);
+    }
+
+    @NonNull
+    public final FragmentTransaction replace(@IdRes int i, @NonNull Class<? extends Fragment> cls, @Nullable Bundle bundle, @Nullable String str) {
+        return replace(i, createFragment(cls, bundle), str);
+    }
+
+    @NonNull
+    public FragmentTransaction replace(@IdRes int i, @NonNull Fragment fragment, @Nullable String str) {
+        if (i == 0) {
+            throw new IllegalArgumentException("Must use non-zero containerViewId");
+        }
+        doAddOp(i, fragment, str, 2);
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction remove(@NonNull Fragment fragment) {
+        addOp(new Op(3, fragment));
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction hide(@NonNull Fragment fragment) {
+        addOp(new Op(4, fragment));
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction show(@NonNull Fragment fragment) {
+        addOp(new Op(5, fragment));
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction detach(@NonNull Fragment fragment) {
+        addOp(new Op(6, fragment));
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction attach(@NonNull Fragment fragment) {
+        addOp(new Op(7, fragment));
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction setPrimaryNavigationFragment(@Nullable Fragment fragment) {
+        addOp(new Op(8, fragment));
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction setMaxLifecycle(@NonNull Fragment fragment, @NonNull Lifecycle.State state) {
+        addOp(new Op(10, fragment, state));
+        return this;
+    }
+
+    public boolean isEmpty() {
+        return this.mOps.isEmpty();
+    }
+
+    @NonNull
+    public FragmentTransaction setCustomAnimations(@AnimRes @AnimatorRes int i, @AnimRes @AnimatorRes int i2) {
+        return setCustomAnimations(i, i2, 0, 0);
+    }
+
+    @NonNull
+    public FragmentTransaction addSharedElement(@NonNull View view, @NonNull String str) {
+        if (FragmentTransition.supportsTransition()) {
+            String transitionName = ViewCompat.getTransitionName(view);
+            if (transitionName == null) {
+                throw new IllegalArgumentException("Unique transitionNames are required for all sharedElements");
+            }
+            if (this.mSharedElementSourceNames == null) {
+                this.mSharedElementSourceNames = new ArrayList<>();
+                this.mSharedElementTargetNames = new ArrayList<>();
+            } else {
+                if (this.mSharedElementTargetNames.contains(str)) {
+                    throw new IllegalArgumentException("A shared element with the target name '" + str + "' has already been added to the transaction.");
+                }
+                if (this.mSharedElementSourceNames.contains(transitionName)) {
+                    throw new IllegalArgumentException("A shared element with the source name '" + transitionName + "' has already been added to the transaction.");
+                }
+            }
+            this.mSharedElementSourceNames.add(transitionName);
+            this.mSharedElementTargetNames.add(str);
+        }
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction addToBackStack(@Nullable String str) {
+        if (!this.mAllowAddToBackStack) {
+            throw new IllegalStateException("This FragmentTransaction is not allowed to be added to the back stack.");
+        }
+        this.mAddToBackStack = true;
+        this.mName = str;
+        return this;
+    }
+
+    @NonNull
+    public FragmentTransaction disallowAddToBackStack() {
+        if (this.mAddToBackStack) {
+            throw new IllegalStateException("This transaction is already being added to the back stack");
+        }
+        this.mAllowAddToBackStack = false;
+        return this;
+    }
+
+    @NonNull
+    @Deprecated
+    public FragmentTransaction setAllowOptimization(boolean z) {
+        return setReorderingAllowed(z);
+    }
+
+    @NonNull
+    public FragmentTransaction runOnCommit(@NonNull Runnable runnable) {
+        disallowAddToBackStack();
+        if (this.mCommitRunnables == null) {
+            this.mCommitRunnables = new ArrayList<>();
+        }
+        this.mCommitRunnables.add(runnable);
+        return this;
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentTransition.java

@@ -0,0 +1,78 @@
+package androidx.fragment.app;
+
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.collection.ArrayMap;
+import androidx.core.app.SharedElementCallback;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+class FragmentTransition {
+    static final FragmentTransitionImpl PLATFORM_IMPL = new FragmentTransitionCompat21();
+    static final FragmentTransitionImpl SUPPORT_IMPL = resolveSupportImpl();
+
+    public static boolean supportsTransition() {
+        return (PLATFORM_IMPL == null && SUPPORT_IMPL == null) ? false : true;
+    }
+
+    private static FragmentTransitionImpl resolveSupportImpl() {
+        try {
+            return (FragmentTransitionImpl) Class.forName("androidx.transition.FragmentTransitionSupport").getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (Exception unused) {
+            return null;
+        }
+    }
+
+    public static String findKeyForValue(ArrayMap<String, String> arrayMap, String str) {
+        int size = arrayMap.size();
+        for (int i = 0; i < size; i++) {
+            if (str.equals(arrayMap.valueAt(i))) {
+                return arrayMap.keyAt(i);
+            }
+        }
+        return null;
+    }
+
+    public static void retainValues(@NonNull ArrayMap<String, String> arrayMap, @NonNull ArrayMap<String, View> arrayMap2) {
+        for (int size = arrayMap.size() - 1; size >= 0; size--) {
+            if (!arrayMap2.containsKey(arrayMap.valueAt(size))) {
+                arrayMap.removeAt(size);
+            }
+        }
+    }
+
+    public static void callSharedElementStartEnd(Fragment fragment, Fragment fragment2, boolean z, ArrayMap<String, View> arrayMap, boolean z2) {
+        SharedElementCallback enterTransitionCallback;
+        if (z) {
+            enterTransitionCallback = fragment2.getEnterTransitionCallback();
+        } else {
+            enterTransitionCallback = fragment.getEnterTransitionCallback();
+        }
+        if (enterTransitionCallback != null) {
+            ArrayList arrayList = new ArrayList();
+            ArrayList arrayList2 = new ArrayList();
+            int size = arrayMap == null ? 0 : arrayMap.size();
+            for (int i = 0; i < size; i++) {
+                arrayList2.add(arrayMap.keyAt(i));
+                arrayList.add(arrayMap.valueAt(i));
+            }
+            if (z2) {
+                enterTransitionCallback.onSharedElementStart(arrayList2, arrayList, null);
+            } else {
+                enterTransitionCallback.onSharedElementEnd(arrayList2, arrayList, null);
+            }
+        }
+    }
+
+    public static void setViewVisibility(ArrayList<View> arrayList, int i) {
+        if (arrayList == null) {
+            return;
+        }
+        for (int size = arrayList.size() - 1; size >= 0; size--) {
+            arrayList.get(size).setVisibility(i);
+        }
+    }
+
+    private FragmentTransition() {
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentTransitionCompat21.java

@@ -0,0 +1,317 @@
+package androidx.fragment.app;
+
+import android.graphics.Rect;
+import android.transition.Transition;
+import android.transition.TransitionManager;
+import android.transition.TransitionSet;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.core.os.CancellationSignal;
+import java.util.ArrayList;
+import java.util.List;
+
+@RequiresApi(21)
+/* loaded from: classes.dex */
+class FragmentTransitionCompat21 extends FragmentTransitionImpl {
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public boolean canHandle(Object obj) {
+        return obj instanceof Transition;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public Object cloneTransition(Object obj) {
+        if (obj != null) {
+            return ((Transition) obj).clone();
+        }
+        return null;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public Object wrapTransitionInSet(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        TransitionSet transitionSet = new TransitionSet();
+        transitionSet.addTransition((Transition) obj);
+        return transitionSet;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void setSharedElementTargets(Object obj, View view, ArrayList<View> arrayList) {
+        TransitionSet transitionSet = (TransitionSet) obj;
+        List<View> targets = transitionSet.getTargets();
+        targets.clear();
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            FragmentTransitionImpl.bfsAddViewChildren(targets, arrayList.get(i));
+        }
+        targets.add(view);
+        arrayList.add(view);
+        addTargets(transitionSet, arrayList);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void setEpicenter(Object obj, View view) {
+        if (view != null) {
+            final Rect rect = new Rect();
+            getBoundsOnScreen(view, rect);
+            ((Transition) obj).setEpicenterCallback(new Transition.EpicenterCallback() { // from class: androidx.fragment.app.FragmentTransitionCompat21.1
+                @Override // android.transition.Transition.EpicenterCallback
+                public Rect onGetEpicenter(Transition transition) {
+                    return rect;
+                }
+            });
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void addTargets(Object obj, ArrayList<View> arrayList) {
+        Transition transition = (Transition) obj;
+        if (transition == null) {
+            return;
+        }
+        int i = 0;
+        if (transition instanceof TransitionSet) {
+            TransitionSet transitionSet = (TransitionSet) transition;
+            int transitionCount = transitionSet.getTransitionCount();
+            while (i < transitionCount) {
+                addTargets(transitionSet.getTransitionAt(i), arrayList);
+                i++;
+            }
+            return;
+        }
+        if (hasSimpleTarget(transition) || !FragmentTransitionImpl.isNullOrEmpty(transition.getTargets())) {
+            return;
+        }
+        int size = arrayList.size();
+        while (i < size) {
+            transition.addTarget(arrayList.get(i));
+            i++;
+        }
+    }
+
+    private static boolean hasSimpleTarget(Transition transition) {
+        return (FragmentTransitionImpl.isNullOrEmpty(transition.getTargetIds()) && FragmentTransitionImpl.isNullOrEmpty(transition.getTargetNames()) && FragmentTransitionImpl.isNullOrEmpty(transition.getTargetTypes())) ? false : true;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public Object mergeTransitionsTogether(Object obj, Object obj2, Object obj3) {
+        TransitionSet transitionSet = new TransitionSet();
+        if (obj != null) {
+            transitionSet.addTransition((Transition) obj);
+        }
+        if (obj2 != null) {
+            transitionSet.addTransition((Transition) obj2);
+        }
+        if (obj3 != null) {
+            transitionSet.addTransition((Transition) obj3);
+        }
+        return transitionSet;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void scheduleHideFragmentView(Object obj, final View view, final ArrayList<View> arrayList) {
+        ((Transition) obj).addListener(new Transition.TransitionListener() { // from class: androidx.fragment.app.FragmentTransitionCompat21.2
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionCancel(Transition transition) {
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionPause(Transition transition) {
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionResume(Transition transition) {
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionStart(Transition transition) {
+                Api19Impl.removeListener(transition, this);
+                Api19Impl.addListener(transition, this);
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionEnd(Transition transition) {
+                Api19Impl.removeListener(transition, this);
+                view.setVisibility(8);
+                int size = arrayList.size();
+                for (int i = 0; i < size; i++) {
+                    ((View) arrayList.get(i)).setVisibility(0);
+                }
+            }
+        });
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public Object mergeTransitionsInSequence(Object obj, Object obj2, Object obj3) {
+        Transition transition = (Transition) obj;
+        Transition transition2 = (Transition) obj2;
+        Transition transition3 = (Transition) obj3;
+        if (transition != null && transition2 != null) {
+            transition = new TransitionSet().addTransition(transition).addTransition(transition2).setOrdering(1);
+        } else if (transition == null) {
+            transition = transition2 != null ? transition2 : null;
+        }
+        if (transition3 == null) {
+            return transition;
+        }
+        TransitionSet transitionSet = new TransitionSet();
+        if (transition != null) {
+            transitionSet.addTransition(transition);
+        }
+        transitionSet.addTransition(transition3);
+        return transitionSet;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void beginDelayedTransition(ViewGroup viewGroup, Object obj) {
+        TransitionManager.beginDelayedTransition(viewGroup, (Transition) obj);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void scheduleRemoveTargets(Object obj, final Object obj2, final ArrayList<View> arrayList, final Object obj3, final ArrayList<View> arrayList2, final Object obj4, final ArrayList<View> arrayList3) {
+        ((Transition) obj).addListener(new Transition.TransitionListener() { // from class: androidx.fragment.app.FragmentTransitionCompat21.3
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionCancel(Transition transition) {
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionPause(Transition transition) {
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionResume(Transition transition) {
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionStart(Transition transition) {
+                Object obj5 = obj2;
+                if (obj5 != null) {
+                    FragmentTransitionCompat21.this.replaceTargets(obj5, arrayList, null);
+                }
+                Object obj6 = obj3;
+                if (obj6 != null) {
+                    FragmentTransitionCompat21.this.replaceTargets(obj6, arrayList2, null);
+                }
+                Object obj7 = obj4;
+                if (obj7 != null) {
+                    FragmentTransitionCompat21.this.replaceTargets(obj7, arrayList3, null);
+                }
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionEnd(Transition transition) {
+                Api19Impl.removeListener(transition, this);
+            }
+        });
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void setListenerForTransitionEnd(@NonNull Fragment fragment, @NonNull Object obj, @NonNull CancellationSignal cancellationSignal, @NonNull final Runnable runnable) {
+        ((Transition) obj).addListener(new Transition.TransitionListener() { // from class: androidx.fragment.app.FragmentTransitionCompat21.4
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionCancel(Transition transition) {
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionPause(Transition transition) {
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionResume(Transition transition) {
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionStart(Transition transition) {
+            }
+
+            @Override // android.transition.Transition.TransitionListener
+            public void onTransitionEnd(Transition transition) {
+                runnable.run();
+            }
+        });
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void swapSharedElementTargets(Object obj, ArrayList<View> arrayList, ArrayList<View> arrayList2) {
+        TransitionSet transitionSet = (TransitionSet) obj;
+        if (transitionSet != null) {
+            transitionSet.getTargets().clear();
+            transitionSet.getTargets().addAll(arrayList2);
+            replaceTargets(transitionSet, arrayList, arrayList2);
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void replaceTargets(Object obj, ArrayList<View> arrayList, ArrayList<View> arrayList2) {
+        List<View> targets;
+        Transition transition = (Transition) obj;
+        int i = 0;
+        if (transition instanceof TransitionSet) {
+            TransitionSet transitionSet = (TransitionSet) transition;
+            int transitionCount = transitionSet.getTransitionCount();
+            while (i < transitionCount) {
+                replaceTargets(transitionSet.getTransitionAt(i), arrayList, arrayList2);
+                i++;
+            }
+            return;
+        }
+        if (hasSimpleTarget(transition) || (targets = transition.getTargets()) == null || targets.size() != arrayList.size() || !targets.containsAll(arrayList)) {
+            return;
+        }
+        int size = arrayList2 == null ? 0 : arrayList2.size();
+        while (i < size) {
+            transition.addTarget(arrayList2.get(i));
+            i++;
+        }
+        for (int size2 = arrayList.size() - 1; size2 >= 0; size2--) {
+            transition.removeTarget(arrayList.get(size2));
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void addTarget(Object obj, View view) {
+        if (obj != null) {
+            ((Transition) obj).addTarget(view);
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void removeTarget(Object obj, View view) {
+        if (obj != null) {
+            ((Transition) obj).removeTarget(view);
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void setEpicenter(Object obj, final Rect rect) {
+        if (obj != null) {
+            ((Transition) obj).setEpicenterCallback(new Transition.EpicenterCallback() { // from class: androidx.fragment.app.FragmentTransitionCompat21.5
+                @Override // android.transition.Transition.EpicenterCallback
+                public Rect onGetEpicenter(Transition transition) {
+                    Rect rect2 = rect;
+                    if (rect2 == null || rect2.isEmpty()) {
+                        return null;
+                    }
+                    return rect;
+                }
+            });
+        }
+    }
+
+    @RequiresApi(19)
+    public static class Api19Impl {
+        private Api19Impl() {
+        }
+
+        public static void addListener(@NonNull Transition transition, @NonNull Transition.TransitionListener transitionListener) {
+            transition.addListener(transitionListener);
+        }
+
+        public static void removeListener(@NonNull Transition transition, @NonNull Transition.TransitionListener transitionListener) {
+            transition.removeListener(transitionListener);
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentTransitionImpl.java

@@ -0,0 +1,157 @@
+package androidx.fragment.app;
+
+import android.annotation.SuppressLint;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.core.os.CancellationSignal;
+import androidx.core.view.OneShotPreDrawListener;
+import androidx.core.view.ViewCompat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@SuppressLint({"UnknownNullness"})
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public abstract class FragmentTransitionImpl {
+    public abstract void addTarget(Object obj, View view);
+
+    public abstract void addTargets(Object obj, ArrayList<View> arrayList);
+
+    public abstract void beginDelayedTransition(ViewGroup viewGroup, Object obj);
+
+    public abstract boolean canHandle(Object obj);
+
+    public abstract Object cloneTransition(Object obj);
+
+    public abstract Object mergeTransitionsInSequence(Object obj, Object obj2, Object obj3);
+
+    public abstract Object mergeTransitionsTogether(Object obj, Object obj2, Object obj3);
+
+    public abstract void removeTarget(Object obj, View view);
+
+    public abstract void replaceTargets(Object obj, ArrayList<View> arrayList, ArrayList<View> arrayList2);
+
+    public abstract void scheduleHideFragmentView(Object obj, View view, ArrayList<View> arrayList);
+
+    public abstract void scheduleRemoveTargets(Object obj, Object obj2, ArrayList<View> arrayList, Object obj3, ArrayList<View> arrayList2, Object obj4, ArrayList<View> arrayList3);
+
+    public abstract void setEpicenter(Object obj, Rect rect);
+
+    public abstract void setEpicenter(Object obj, View view);
+
+    public abstract void setSharedElementTargets(Object obj, View view, ArrayList<View> arrayList);
+
+    public abstract void swapSharedElementTargets(Object obj, ArrayList<View> arrayList, ArrayList<View> arrayList2);
+
+    public abstract Object wrapTransitionInSet(Object obj);
+
+    public void getBoundsOnScreen(View view, Rect rect) {
+        if (ViewCompat.isAttachedToWindow(view)) {
+            RectF rectF = new RectF();
+            rectF.set(0.0f, 0.0f, view.getWidth(), view.getHeight());
+            view.getMatrix().mapRect(rectF);
+            rectF.offset(view.getLeft(), view.getTop());
+            Object parent = view.getParent();
+            while (parent instanceof View) {
+                View view2 = (View) parent;
+                rectF.offset(-view2.getScrollX(), -view2.getScrollY());
+                view2.getMatrix().mapRect(rectF);
+                rectF.offset(view2.getLeft(), view2.getTop());
+                parent = view2.getParent();
+            }
+            view.getRootView().getLocationOnScreen(new int[2]);
+            rectF.offset(r1[0], r1[1]);
+            rect.set(Math.round(rectF.left), Math.round(rectF.top), Math.round(rectF.right), Math.round(rectF.bottom));
+        }
+    }
+
+    public ArrayList<String> prepareSetNameOverridesReordered(ArrayList<View> arrayList) {
+        ArrayList<String> arrayList2 = new ArrayList<>();
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            View view = arrayList.get(i);
+            arrayList2.add(ViewCompat.getTransitionName(view));
+            ViewCompat.setTransitionName(view, null);
+        }
+        return arrayList2;
+    }
+
+    public void setNameOverridesReordered(View view, final ArrayList<View> arrayList, final ArrayList<View> arrayList2, final ArrayList<String> arrayList3, Map<String, String> map) {
+        final int size = arrayList2.size();
+        final ArrayList arrayList4 = new ArrayList();
+        for (int i = 0; i < size; i++) {
+            View view2 = arrayList.get(i);
+            String transitionName = ViewCompat.getTransitionName(view2);
+            arrayList4.add(transitionName);
+            if (transitionName != null) {
+                ViewCompat.setTransitionName(view2, null);
+                String str = map.get(transitionName);
+                int i2 = 0;
+                while (true) {
+                    if (i2 >= size) {
+                        break;
+                    }
+                    if (str.equals(arrayList3.get(i2))) {
+                        ViewCompat.setTransitionName(arrayList2.get(i2), transitionName);
+                        break;
+                    }
+                    i2++;
+                }
+            }
+        }
+        OneShotPreDrawListener.add(view, new Runnable() { // from class: androidx.fragment.app.FragmentTransitionImpl.1
+            @Override // java.lang.Runnable
+            public void run() {
+                for (int i3 = 0; i3 < size; i3++) {
+                    ViewCompat.setTransitionName((View) arrayList2.get(i3), (String) arrayList3.get(i3));
+                    ViewCompat.setTransitionName((View) arrayList.get(i3), (String) arrayList4.get(i3));
+                }
+            }
+        });
+    }
+
+    public void setListenerForTransitionEnd(@NonNull Fragment fragment, @NonNull Object obj, @NonNull CancellationSignal cancellationSignal, @NonNull Runnable runnable) {
+        runnable.run();
+    }
+
+    public static void bfsAddViewChildren(List<View> list, View view) {
+        int size = list.size();
+        if (containedBeforeIndex(list, view, size)) {
+            return;
+        }
+        if (ViewCompat.getTransitionName(view) != null) {
+            list.add(view);
+        }
+        for (int i = size; i < list.size(); i++) {
+            View view2 = list.get(i);
+            if (view2 instanceof ViewGroup) {
+                ViewGroup viewGroup = (ViewGroup) view2;
+                int childCount = viewGroup.getChildCount();
+                for (int i2 = 0; i2 < childCount; i2++) {
+                    View childAt = viewGroup.getChildAt(i2);
+                    if (!containedBeforeIndex(list, childAt, size) && ViewCompat.getTransitionName(childAt) != null) {
+                        list.add(childAt);
+                    }
+                }
+            }
+        }
+    }
+
+    private static boolean containedBeforeIndex(List<View> list, View view, int i) {
+        for (int i2 = 0; i2 < i; i2++) {
+            if (list.get(i2) == view) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isNullOrEmpty(List list) {
+        return list == null || list.isEmpty();
+    }
+}

decompiled/sources/androidx/fragment/app/FragmentViewLifecycleOwner.java

@@ -0,0 +1,143 @@
+package androidx.fragment.app;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import androidx.annotation.CallSuper;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.HasDefaultViewModelProviderFactory;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleRegistry;
+import androidx.lifecycle.SavedStateHandleSupport;
+import androidx.lifecycle.SavedStateViewModelFactory;
+import androidx.lifecycle.ViewModelProvider;
+import androidx.lifecycle.ViewModelStore;
+import androidx.lifecycle.ViewModelStoreOwner;
+import androidx.lifecycle.viewmodel.CreationExtras;
+import androidx.lifecycle.viewmodel.MutableCreationExtras;
+import androidx.savedstate.SavedStateRegistry;
+import androidx.savedstate.SavedStateRegistryController;
+import androidx.savedstate.SavedStateRegistryOwner;
+
+/* loaded from: classes.dex */
+class FragmentViewLifecycleOwner implements HasDefaultViewModelProviderFactory, SavedStateRegistryOwner, ViewModelStoreOwner {
+    private ViewModelProvider.Factory mDefaultFactory;
+    private final Fragment mFragment;
+    private LifecycleRegistry mLifecycleRegistry = null;
+    private SavedStateRegistryController mSavedStateRegistryController = null;
+    private final ViewModelStore mViewModelStore;
+
+    public boolean isInitialized() {
+        return this.mLifecycleRegistry != null;
+    }
+
+    public FragmentViewLifecycleOwner(@NonNull Fragment fragment, @NonNull ViewModelStore viewModelStore) {
+        this.mFragment = fragment;
+        this.mViewModelStore = viewModelStore;
+    }
+
+    @Override // androidx.lifecycle.ViewModelStoreOwner
+    @NonNull
+    public ViewModelStore getViewModelStore() {
+        initialize();
+        return this.mViewModelStore;
+    }
+
+    public void initialize() {
+        if (this.mLifecycleRegistry == null) {
+            this.mLifecycleRegistry = new LifecycleRegistry(this);
+            SavedStateRegistryController create = SavedStateRegistryController.create(this);
+            this.mSavedStateRegistryController = create;
+            create.performAttach();
+        }
+    }
+
+    @Override // androidx.lifecycle.LifecycleOwner
+    @NonNull
+    public Lifecycle getLifecycle() {
+        initialize();
+        return this.mLifecycleRegistry;
+    }
+
+    public void setCurrentState(@NonNull Lifecycle.State state) {
+        this.mLifecycleRegistry.setCurrentState(state);
+    }
+
+    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
+        this.mLifecycleRegistry.handleLifecycleEvent(event);
+    }
+
+    @Override // androidx.lifecycle.HasDefaultViewModelProviderFactory
+    @NonNull
+    public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+        Application application;
+        ViewModelProvider.Factory defaultViewModelProviderFactory = this.mFragment.getDefaultViewModelProviderFactory();
+        if (!defaultViewModelProviderFactory.equals(this.mFragment.mDefaultFactory)) {
+            this.mDefaultFactory = defaultViewModelProviderFactory;
+            return defaultViewModelProviderFactory;
+        }
+        if (this.mDefaultFactory == null) {
+            Context applicationContext = this.mFragment.requireContext().getApplicationContext();
+            while (true) {
+                if (!(applicationContext instanceof ContextWrapper)) {
+                    application = null;
+                    break;
+                }
+                if (applicationContext instanceof Application) {
+                    application = (Application) applicationContext;
+                    break;
+                }
+                applicationContext = ((ContextWrapper) applicationContext).getBaseContext();
+            }
+            Fragment fragment = this.mFragment;
+            this.mDefaultFactory = new SavedStateViewModelFactory(application, fragment, fragment.getArguments());
+        }
+        return this.mDefaultFactory;
+    }
+
+    @Override // androidx.lifecycle.HasDefaultViewModelProviderFactory
+    @NonNull
+    @CallSuper
+    public CreationExtras getDefaultViewModelCreationExtras() {
+        Application application;
+        Context applicationContext = this.mFragment.requireContext().getApplicationContext();
+        while (true) {
+            if (!(applicationContext instanceof ContextWrapper)) {
+                application = null;
+                break;
+            }
+            if (applicationContext instanceof Application) {
+                application = (Application) applicationContext;
+                break;
+            }
+            applicationContext = ((ContextWrapper) applicationContext).getBaseContext();
+        }
+        MutableCreationExtras mutableCreationExtras = new MutableCreationExtras();
+        if (application != null) {
+            mutableCreationExtras.set(ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY, application);
+        }
+        mutableCreationExtras.set(SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY, this.mFragment);
+        mutableCreationExtras.set(SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY, this);
+        if (this.mFragment.getArguments() != null) {
+            mutableCreationExtras.set(SavedStateHandleSupport.DEFAULT_ARGS_KEY, this.mFragment.getArguments());
+        }
+        return mutableCreationExtras;
+    }
+
+    @Override // androidx.savedstate.SavedStateRegistryOwner
+    @NonNull
+    public SavedStateRegistry getSavedStateRegistry() {
+        initialize();
+        return this.mSavedStateRegistryController.getSavedStateRegistry();
+    }
+
+    public void performRestore(@Nullable Bundle bundle) {
+        this.mSavedStateRegistryController.performRestore(bundle);
+    }
+
+    public void performSave(@NonNull Bundle bundle) {
+        this.mSavedStateRegistryController.performSave(bundle);
+    }
+}

decompiled/sources/androidx/fragment/app/ListFragment.java

@@ -0,0 +1,250 @@
+package androidx.fragment.app;
+
+import android.R;
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Handler;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.AnimationUtils;
+import android.widget.AdapterView;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public class ListFragment extends Fragment {
+    static final int INTERNAL_EMPTY_ID = 16711681;
+    static final int INTERNAL_LIST_CONTAINER_ID = 16711683;
+    static final int INTERNAL_PROGRESS_CONTAINER_ID = 16711682;
+    ListAdapter mAdapter;
+    CharSequence mEmptyText;
+    View mEmptyView;
+    ListView mList;
+    View mListContainer;
+    boolean mListShown;
+    View mProgressContainer;
+    TextView mStandardEmptyView;
+    private final Handler mHandler = new Handler();
+    private final Runnable mRequestFocus = new Runnable() { // from class: androidx.fragment.app.ListFragment.1
+        @Override // java.lang.Runnable
+        public void run() {
+            ListView listView = ListFragment.this.mList;
+            listView.focusableViewAvailable(listView);
+        }
+    };
+    private final AdapterView.OnItemClickListener mOnClickListener = new AdapterView.OnItemClickListener() { // from class: androidx.fragment.app.ListFragment.2
+        @Override // android.widget.AdapterView.OnItemClickListener
+        public void onItemClick(AdapterView<?> adapterView, View view, int i, long j) {
+            ListFragment.this.onListItemClick((ListView) adapterView, view, i, j);
+        }
+    };
+
+    @Nullable
+    public ListAdapter getListAdapter() {
+        return this.mAdapter;
+    }
+
+    public void onListItemClick(@NonNull ListView listView, @NonNull View view, int i, long j) {
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    @Nullable
+    public View onCreateView(@NonNull LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
+        Context requireContext = requireContext();
+        FrameLayout frameLayout = new FrameLayout(requireContext);
+        LinearLayout linearLayout = new LinearLayout(requireContext);
+        linearLayout.setId(INTERNAL_PROGRESS_CONTAINER_ID);
+        linearLayout.setOrientation(1);
+        linearLayout.setVisibility(8);
+        linearLayout.setGravity(17);
+        linearLayout.addView(new ProgressBar(requireContext, null, R.attr.progressBarStyleLarge), new FrameLayout.LayoutParams(-2, -2));
+        frameLayout.addView(linearLayout, new FrameLayout.LayoutParams(-1, -1));
+        FrameLayout frameLayout2 = new FrameLayout(requireContext);
+        frameLayout2.setId(INTERNAL_LIST_CONTAINER_ID);
+        TextView textView = new TextView(requireContext);
+        textView.setId(INTERNAL_EMPTY_ID);
+        textView.setGravity(17);
+        frameLayout2.addView(textView, new FrameLayout.LayoutParams(-1, -1));
+        ListView listView = new ListView(requireContext);
+        listView.setId(R.id.list);
+        listView.setDrawSelectorOnTop(false);
+        frameLayout2.addView(listView, new FrameLayout.LayoutParams(-1, -1));
+        frameLayout.addView(frameLayout2, new FrameLayout.LayoutParams(-1, -1));
+        frameLayout.setLayoutParams(new FrameLayout.LayoutParams(-1, -1));
+        return frameLayout;
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    public void onViewCreated(@NonNull View view, @Nullable Bundle bundle) {
+        super.onViewCreated(view, bundle);
+        ensureList();
+    }
+
+    @Override // androidx.fragment.app.Fragment
+    public void onDestroyView() {
+        this.mHandler.removeCallbacks(this.mRequestFocus);
+        this.mList = null;
+        this.mListShown = false;
+        this.mListContainer = null;
+        this.mProgressContainer = null;
+        this.mEmptyView = null;
+        this.mStandardEmptyView = null;
+        super.onDestroyView();
+    }
+
+    public void setListAdapter(@Nullable ListAdapter listAdapter) {
+        boolean z = this.mAdapter != null;
+        this.mAdapter = listAdapter;
+        ListView listView = this.mList;
+        if (listView != null) {
+            listView.setAdapter(listAdapter);
+            if (this.mListShown || z) {
+                return;
+            }
+            setListShown(true, requireView().getWindowToken() != null);
+        }
+    }
+
+    public void setSelection(int i) {
+        ensureList();
+        this.mList.setSelection(i);
+    }
+
+    public int getSelectedItemPosition() {
+        ensureList();
+        return this.mList.getSelectedItemPosition();
+    }
+
+    public long getSelectedItemId() {
+        ensureList();
+        return this.mList.getSelectedItemId();
+    }
+
+    @NonNull
+    public ListView getListView() {
+        ensureList();
+        return this.mList;
+    }
+
+    public void setEmptyText(@Nullable CharSequence charSequence) {
+        ensureList();
+        TextView textView = this.mStandardEmptyView;
+        if (textView == null) {
+            throw new IllegalStateException("Can't be used with a custom content view");
+        }
+        textView.setText(charSequence);
+        if (this.mEmptyText == null) {
+            this.mList.setEmptyView(this.mStandardEmptyView);
+        }
+        this.mEmptyText = charSequence;
+    }
+
+    public void setListShown(boolean z) {
+        setListShown(z, true);
+    }
+
+    public void setListShownNoAnimation(boolean z) {
+        setListShown(z, false);
+    }
+
+    private void setListShown(boolean z, boolean z2) {
+        ensureList();
+        View view = this.mProgressContainer;
+        if (view == null) {
+            throw new IllegalStateException("Can't be used with a custom content view");
+        }
+        if (this.mListShown == z) {
+            return;
+        }
+        this.mListShown = z;
+        if (z) {
+            if (z2) {
+                view.startAnimation(AnimationUtils.loadAnimation(getContext(), R.anim.fade_out));
+                this.mListContainer.startAnimation(AnimationUtils.loadAnimation(getContext(), R.anim.fade_in));
+            } else {
+                view.clearAnimation();
+                this.mListContainer.clearAnimation();
+            }
+            this.mProgressContainer.setVisibility(8);
+            this.mListContainer.setVisibility(0);
+            return;
+        }
+        if (z2) {
+            view.startAnimation(AnimationUtils.loadAnimation(getContext(), R.anim.fade_in));
+            this.mListContainer.startAnimation(AnimationUtils.loadAnimation(getContext(), R.anim.fade_out));
+        } else {
+            view.clearAnimation();
+            this.mListContainer.clearAnimation();
+        }
+        this.mProgressContainer.setVisibility(0);
+        this.mListContainer.setVisibility(8);
+    }
+
+    @NonNull
+    public final ListAdapter requireListAdapter() {
+        ListAdapter listAdapter = getListAdapter();
+        if (listAdapter != null) {
+            return listAdapter;
+        }
+        throw new IllegalStateException("ListFragment " + this + " does not have a ListAdapter.");
+    }
+
+    private void ensureList() {
+        if (this.mList != null) {
+            return;
+        }
+        View view = getView();
+        if (view == null) {
+            throw new IllegalStateException("Content view not yet created");
+        }
+        if (view instanceof ListView) {
+            this.mList = (ListView) view;
+        } else {
+            TextView textView = (TextView) view.findViewById(INTERNAL_EMPTY_ID);
+            this.mStandardEmptyView = textView;
+            if (textView == null) {
+                this.mEmptyView = view.findViewById(R.id.empty);
+            } else {
+                textView.setVisibility(8);
+            }
+            this.mProgressContainer = view.findViewById(INTERNAL_PROGRESS_CONTAINER_ID);
+            this.mListContainer = view.findViewById(INTERNAL_LIST_CONTAINER_ID);
+            View findViewById = view.findViewById(R.id.list);
+            if (!(findViewById instanceof ListView)) {
+                if (findViewById == null) {
+                    throw new RuntimeException("Your content must have a ListView whose id attribute is 'android.R.id.list'");
+                }
+                throw new RuntimeException("Content has view with id attribute 'android.R.id.list' that is not a ListView class");
+            }
+            ListView listView = (ListView) findViewById;
+            this.mList = listView;
+            View view2 = this.mEmptyView;
+            if (view2 != null) {
+                listView.setEmptyView(view2);
+            } else {
+                CharSequence charSequence = this.mEmptyText;
+                if (charSequence != null) {
+                    this.mStandardEmptyView.setText(charSequence);
+                    this.mList.setEmptyView(this.mStandardEmptyView);
+                }
+            }
+        }
+        this.mListShown = true;
+        this.mList.setOnItemClickListener(this.mOnClickListener);
+        ListAdapter listAdapter = this.mAdapter;
+        if (listAdapter != null) {
+            this.mAdapter = null;
+            setListAdapter(listAdapter);
+        } else if (this.mProgressContainer != null) {
+            setListShown(false, false);
+        }
+        this.mHandler.post(this.mRequestFocus);
+    }
+}

decompiled/sources/androidx/fragment/app/LogWriter.java

@@ -0,0 +1,43 @@
+package androidx.fragment.app;
+
+import java.io.Writer;
+
+/* loaded from: classes.dex */
+final class LogWriter extends Writer {
+    private StringBuilder mBuilder = new StringBuilder(128);
+    private final String mTag;
+
+    public LogWriter(String str) {
+        this.mTag = str;
+    }
+
+    @Override // java.io.Writer, java.io.Closeable, java.lang.AutoCloseable
+    public void close() {
+        flushBuilder();
+    }
+
+    @Override // java.io.Writer, java.io.Flushable
+    public void flush() {
+        flushBuilder();
+    }
+
+    @Override // java.io.Writer
+    public void write(char[] cArr, int i, int i2) {
+        for (int i3 = 0; i3 < i2; i3++) {
+            char c = cArr[i + i3];
+            if (c == '\n') {
+                flushBuilder();
+            } else {
+                this.mBuilder.append(c);
+            }
+        }
+    }
+
+    private void flushBuilder() {
+        if (this.mBuilder.length() > 0) {
+            this.mBuilder.toString();
+            StringBuilder sb = this.mBuilder;
+            sb.delete(0, sb.length());
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/SpecialEffectsController.java

@@ -0,0 +1,636 @@
+package androidx.fragment.app;
+
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.CallSuper;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.os.CancellationSignal;
+import androidx.core.view.ViewCompat;
+import androidx.fragment.R;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes.dex */
+abstract class SpecialEffectsController {
+    private final ViewGroup mContainer;
+    final ArrayList<Operation> mPendingOperations = new ArrayList<>();
+    final ArrayList<Operation> mRunningOperations = new ArrayList<>();
+    boolean mOperationDirectionIsPop = false;
+    boolean mIsContainerPostponed = false;
+
+    public abstract void executeOperations(@NonNull List<Operation> list, boolean z);
+
+    @NonNull
+    public ViewGroup getContainer() {
+        return this.mContainer;
+    }
+
+    public void updateOperationDirection(boolean z) {
+        this.mOperationDirectionIsPop = z;
+    }
+
+    @NonNull
+    public static SpecialEffectsController getOrCreateController(@NonNull ViewGroup viewGroup, @NonNull FragmentManager fragmentManager) {
+        return getOrCreateController(viewGroup, fragmentManager.getSpecialEffectsControllerFactory());
+    }
+
+    @NonNull
+    public static SpecialEffectsController getOrCreateController(@NonNull ViewGroup viewGroup, @NonNull SpecialEffectsControllerFactory specialEffectsControllerFactory) {
+        Object tag = viewGroup.getTag(R.id.special_effects_controller_view_tag);
+        if (tag instanceof SpecialEffectsController) {
+            return (SpecialEffectsController) tag;
+        }
+        SpecialEffectsController createController = specialEffectsControllerFactory.createController(viewGroup);
+        viewGroup.setTag(R.id.special_effects_controller_view_tag, createController);
+        return createController;
+    }
+
+    public SpecialEffectsController(@NonNull ViewGroup viewGroup) {
+        this.mContainer = viewGroup;
+    }
+
+    @Nullable
+    public Operation.LifecycleImpact getAwaitingCompletionLifecycleImpact(@NonNull FragmentStateManager fragmentStateManager) {
+        Operation findPendingOperation = findPendingOperation(fragmentStateManager.getFragment());
+        Operation.LifecycleImpact lifecycleImpact = findPendingOperation != null ? findPendingOperation.getLifecycleImpact() : null;
+        Operation findRunningOperation = findRunningOperation(fragmentStateManager.getFragment());
+        return (findRunningOperation == null || !(lifecycleImpact == null || lifecycleImpact == Operation.LifecycleImpact.NONE)) ? lifecycleImpact : findRunningOperation.getLifecycleImpact();
+    }
+
+    @Nullable
+    private Operation findPendingOperation(@NonNull Fragment fragment) {
+        Iterator<Operation> it = this.mPendingOperations.iterator();
+        while (it.hasNext()) {
+            Operation next = it.next();
+            if (next.getFragment().equals(fragment) && !next.isCanceled()) {
+                return next;
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    private Operation findRunningOperation(@NonNull Fragment fragment) {
+        Iterator<Operation> it = this.mRunningOperations.iterator();
+        while (it.hasNext()) {
+            Operation next = it.next();
+            if (next.getFragment().equals(fragment) && !next.isCanceled()) {
+                return next;
+            }
+        }
+        return null;
+    }
+
+    public void enqueueAdd(@NonNull Operation.State state, @NonNull FragmentStateManager fragmentStateManager) {
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("SpecialEffectsController: Enqueuing add operation for fragment ");
+            sb.append(fragmentStateManager.getFragment());
+        }
+        enqueue(state, Operation.LifecycleImpact.ADDING, fragmentStateManager);
+    }
+
+    public void enqueueShow(@NonNull FragmentStateManager fragmentStateManager) {
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("SpecialEffectsController: Enqueuing show operation for fragment ");
+            sb.append(fragmentStateManager.getFragment());
+        }
+        enqueue(Operation.State.VISIBLE, Operation.LifecycleImpact.NONE, fragmentStateManager);
+    }
+
+    public void enqueueHide(@NonNull FragmentStateManager fragmentStateManager) {
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("SpecialEffectsController: Enqueuing hide operation for fragment ");
+            sb.append(fragmentStateManager.getFragment());
+        }
+        enqueue(Operation.State.GONE, Operation.LifecycleImpact.NONE, fragmentStateManager);
+    }
+
+    public void enqueueRemove(@NonNull FragmentStateManager fragmentStateManager) {
+        if (FragmentManager.isLoggingEnabled(2)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("SpecialEffectsController: Enqueuing remove operation for fragment ");
+            sb.append(fragmentStateManager.getFragment());
+        }
+        enqueue(Operation.State.REMOVED, Operation.LifecycleImpact.REMOVING, fragmentStateManager);
+    }
+
+    private void enqueue(@NonNull Operation.State state, @NonNull Operation.LifecycleImpact lifecycleImpact, @NonNull FragmentStateManager fragmentStateManager) {
+        synchronized (this.mPendingOperations) {
+            try {
+                CancellationSignal cancellationSignal = new CancellationSignal();
+                Operation findPendingOperation = findPendingOperation(fragmentStateManager.getFragment());
+                if (findPendingOperation != null) {
+                    findPendingOperation.mergeWith(state, lifecycleImpact);
+                    return;
+                }
+                final FragmentStateManagerOperation fragmentStateManagerOperation = new FragmentStateManagerOperation(state, lifecycleImpact, fragmentStateManager, cancellationSignal);
+                this.mPendingOperations.add(fragmentStateManagerOperation);
+                fragmentStateManagerOperation.addCompletionListener(new Runnable() { // from class: androidx.fragment.app.SpecialEffectsController.1
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (SpecialEffectsController.this.mPendingOperations.contains(fragmentStateManagerOperation)) {
+                            fragmentStateManagerOperation.getFinalState().applyState(fragmentStateManagerOperation.getFragment().mView);
+                        }
+                    }
+                });
+                fragmentStateManagerOperation.addCompletionListener(new Runnable() { // from class: androidx.fragment.app.SpecialEffectsController.2
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        SpecialEffectsController.this.mPendingOperations.remove(fragmentStateManagerOperation);
+                        SpecialEffectsController.this.mRunningOperations.remove(fragmentStateManagerOperation);
+                    }
+                });
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public void markPostponedState() {
+        synchronized (this.mPendingOperations) {
+            try {
+                updateFinalState();
+                this.mIsContainerPostponed = false;
+                int size = this.mPendingOperations.size() - 1;
+                while (true) {
+                    if (size < 0) {
+                        break;
+                    }
+                    Operation operation = this.mPendingOperations.get(size);
+                    Operation.State from = Operation.State.from(operation.getFragment().mView);
+                    Operation.State finalState = operation.getFinalState();
+                    Operation.State state = Operation.State.VISIBLE;
+                    if (finalState == state && from != state) {
+                        this.mIsContainerPostponed = operation.getFragment().isPostponed();
+                        break;
+                    }
+                    size--;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public void forcePostponedExecutePendingOperations() {
+        if (this.mIsContainerPostponed) {
+            FragmentManager.isLoggingEnabled(2);
+            this.mIsContainerPostponed = false;
+            executePendingOperations();
+        }
+    }
+
+    public void executePendingOperations() {
+        if (this.mIsContainerPostponed) {
+            return;
+        }
+        if (!ViewCompat.isAttachedToWindow(this.mContainer)) {
+            forceCompleteAllOperations();
+            this.mOperationDirectionIsPop = false;
+            return;
+        }
+        synchronized (this.mPendingOperations) {
+            try {
+                if (!this.mPendingOperations.isEmpty()) {
+                    ArrayList arrayList = new ArrayList(this.mRunningOperations);
+                    this.mRunningOperations.clear();
+                    Iterator it = arrayList.iterator();
+                    while (it.hasNext()) {
+                        Operation operation = (Operation) it.next();
+                        if (FragmentManager.isLoggingEnabled(2)) {
+                            StringBuilder sb = new StringBuilder();
+                            sb.append("SpecialEffectsController: Cancelling operation ");
+                            sb.append(operation);
+                        }
+                        operation.cancel();
+                        if (!operation.isComplete()) {
+                            this.mRunningOperations.add(operation);
+                        }
+                    }
+                    updateFinalState();
+                    ArrayList arrayList2 = new ArrayList(this.mPendingOperations);
+                    this.mPendingOperations.clear();
+                    this.mRunningOperations.addAll(arrayList2);
+                    FragmentManager.isLoggingEnabled(2);
+                    Iterator it2 = arrayList2.iterator();
+                    while (it2.hasNext()) {
+                        ((Operation) it2.next()).onStart();
+                    }
+                    executeOperations(arrayList2, this.mOperationDirectionIsPop);
+                    this.mOperationDirectionIsPop = false;
+                    FragmentManager.isLoggingEnabled(2);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public void forceCompleteAllOperations() {
+        String str;
+        String str2;
+        FragmentManager.isLoggingEnabled(2);
+        boolean isAttachedToWindow = ViewCompat.isAttachedToWindow(this.mContainer);
+        synchronized (this.mPendingOperations) {
+            try {
+                updateFinalState();
+                Iterator<Operation> it = this.mPendingOperations.iterator();
+                while (it.hasNext()) {
+                    it.next().onStart();
+                }
+                Iterator it2 = new ArrayList(this.mRunningOperations).iterator();
+                while (it2.hasNext()) {
+                    Operation operation = (Operation) it2.next();
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb = new StringBuilder();
+                        sb.append("SpecialEffectsController: ");
+                        if (isAttachedToWindow) {
+                            str2 = "";
+                        } else {
+                            str2 = "Container " + this.mContainer + " is not attached to window. ";
+                        }
+                        sb.append(str2);
+                        sb.append("Cancelling running operation ");
+                        sb.append(operation);
+                    }
+                    operation.cancel();
+                }
+                Iterator it3 = new ArrayList(this.mPendingOperations).iterator();
+                while (it3.hasNext()) {
+                    Operation operation2 = (Operation) it3.next();
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb2 = new StringBuilder();
+                        sb2.append("SpecialEffectsController: ");
+                        if (isAttachedToWindow) {
+                            str = "";
+                        } else {
+                            str = "Container " + this.mContainer + " is not attached to window. ";
+                        }
+                        sb2.append(str);
+                        sb2.append("Cancelling pending operation ");
+                        sb2.append(operation2);
+                    }
+                    operation2.cancel();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private void updateFinalState() {
+        Iterator<Operation> it = this.mPendingOperations.iterator();
+        while (it.hasNext()) {
+            Operation next = it.next();
+            if (next.getLifecycleImpact() == Operation.LifecycleImpact.ADDING) {
+                next.mergeWith(Operation.State.from(next.getFragment().requireView().getVisibility()), Operation.LifecycleImpact.NONE);
+            }
+        }
+    }
+
+    public static class Operation {
+
+        @NonNull
+        private State mFinalState;
+
+        @NonNull
+        private final Fragment mFragment;
+
+        @NonNull
+        private LifecycleImpact mLifecycleImpact;
+
+        @NonNull
+        private final List<Runnable> mCompletionListeners = new ArrayList();
+
+        @NonNull
+        private final HashSet<CancellationSignal> mSpecialEffectsSignals = new HashSet<>();
+        private boolean mIsCanceled = false;
+        private boolean mIsComplete = false;
+
+        public enum LifecycleImpact {
+            NONE,
+            ADDING,
+            REMOVING
+        }
+
+        @NonNull
+        public State getFinalState() {
+            return this.mFinalState;
+        }
+
+        @NonNull
+        public final Fragment getFragment() {
+            return this.mFragment;
+        }
+
+        @NonNull
+        public LifecycleImpact getLifecycleImpact() {
+            return this.mLifecycleImpact;
+        }
+
+        public final boolean isCanceled() {
+            return this.mIsCanceled;
+        }
+
+        public final boolean isComplete() {
+            return this.mIsComplete;
+        }
+
+        public void onStart() {
+        }
+
+        public enum State {
+            REMOVED,
+            VISIBLE,
+            GONE,
+            INVISIBLE;
+
+            @NonNull
+            public static State from(@NonNull View view) {
+                return (view.getAlpha() == 0.0f && view.getVisibility() == 0) ? INVISIBLE : from(view.getVisibility());
+            }
+
+            @NonNull
+            public static State from(int i) {
+                if (i == 0) {
+                    return VISIBLE;
+                }
+                if (i == 4) {
+                    return INVISIBLE;
+                }
+                if (i == 8) {
+                    return GONE;
+                }
+                throw new IllegalArgumentException("Unknown visibility " + i);
+            }
+
+            public void applyState(@NonNull View view) {
+                int i = AnonymousClass3.$SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[ordinal()];
+                if (i == 1) {
+                    ViewGroup viewGroup = (ViewGroup) view.getParent();
+                    if (viewGroup != null) {
+                        if (FragmentManager.isLoggingEnabled(2)) {
+                            StringBuilder sb = new StringBuilder();
+                            sb.append("SpecialEffectsController: Removing view ");
+                            sb.append(view);
+                            sb.append(" from container ");
+                            sb.append(viewGroup);
+                        }
+                        viewGroup.removeView(view);
+                        return;
+                    }
+                    return;
+                }
+                if (i == 2) {
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb2 = new StringBuilder();
+                        sb2.append("SpecialEffectsController: Setting view ");
+                        sb2.append(view);
+                        sb2.append(" to VISIBLE");
+                    }
+                    view.setVisibility(0);
+                    return;
+                }
+                if (i == 3) {
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb3 = new StringBuilder();
+                        sb3.append("SpecialEffectsController: Setting view ");
+                        sb3.append(view);
+                        sb3.append(" to GONE");
+                    }
+                    view.setVisibility(8);
+                    return;
+                }
+                if (i != 4) {
+                    return;
+                }
+                if (FragmentManager.isLoggingEnabled(2)) {
+                    StringBuilder sb4 = new StringBuilder();
+                    sb4.append("SpecialEffectsController: Setting view ");
+                    sb4.append(view);
+                    sb4.append(" to INVISIBLE");
+                }
+                view.setVisibility(4);
+            }
+        }
+
+        public Operation(@NonNull State state, @NonNull LifecycleImpact lifecycleImpact, @NonNull Fragment fragment, @NonNull CancellationSignal cancellationSignal) {
+            this.mFinalState = state;
+            this.mLifecycleImpact = lifecycleImpact;
+            this.mFragment = fragment;
+            cancellationSignal.setOnCancelListener(new CancellationSignal.OnCancelListener() { // from class: androidx.fragment.app.SpecialEffectsController.Operation.1
+                @Override // androidx.core.os.CancellationSignal.OnCancelListener
+                public void onCancel() {
+                    Operation.this.cancel();
+                }
+            });
+        }
+
+        @NonNull
+        public String toString() {
+            return "Operation {" + Integer.toHexString(System.identityHashCode(this)) + "} {mFinalState = " + this.mFinalState + "} {mLifecycleImpact = " + this.mLifecycleImpact + "} {mFragment = " + this.mFragment + "}";
+        }
+
+        public final void cancel() {
+            if (isCanceled()) {
+                return;
+            }
+            this.mIsCanceled = true;
+            if (this.mSpecialEffectsSignals.isEmpty()) {
+                complete();
+                return;
+            }
+            Iterator it = new ArrayList(this.mSpecialEffectsSignals).iterator();
+            while (it.hasNext()) {
+                ((CancellationSignal) it.next()).cancel();
+            }
+        }
+
+        public final void mergeWith(@NonNull State state, @NonNull LifecycleImpact lifecycleImpact) {
+            int i = AnonymousClass3.$SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$LifecycleImpact[lifecycleImpact.ordinal()];
+            if (i == 1) {
+                if (this.mFinalState == State.REMOVED) {
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb = new StringBuilder();
+                        sb.append("SpecialEffectsController: For fragment ");
+                        sb.append(this.mFragment);
+                        sb.append(" mFinalState = REMOVED -> VISIBLE. mLifecycleImpact = ");
+                        sb.append(this.mLifecycleImpact);
+                        sb.append(" to ADDING.");
+                    }
+                    this.mFinalState = State.VISIBLE;
+                    this.mLifecycleImpact = LifecycleImpact.ADDING;
+                    return;
+                }
+                return;
+            }
+            if (i == 2) {
+                if (FragmentManager.isLoggingEnabled(2)) {
+                    StringBuilder sb2 = new StringBuilder();
+                    sb2.append("SpecialEffectsController: For fragment ");
+                    sb2.append(this.mFragment);
+                    sb2.append(" mFinalState = ");
+                    sb2.append(this.mFinalState);
+                    sb2.append(" -> REMOVED. mLifecycleImpact  = ");
+                    sb2.append(this.mLifecycleImpact);
+                    sb2.append(" to REMOVING.");
+                }
+                this.mFinalState = State.REMOVED;
+                this.mLifecycleImpact = LifecycleImpact.REMOVING;
+                return;
+            }
+            if (i == 3 && this.mFinalState != State.REMOVED) {
+                if (FragmentManager.isLoggingEnabled(2)) {
+                    StringBuilder sb3 = new StringBuilder();
+                    sb3.append("SpecialEffectsController: For fragment ");
+                    sb3.append(this.mFragment);
+                    sb3.append(" mFinalState = ");
+                    sb3.append(this.mFinalState);
+                    sb3.append(" -> ");
+                    sb3.append(state);
+                    sb3.append(". ");
+                }
+                this.mFinalState = state;
+            }
+        }
+
+        public final void addCompletionListener(@NonNull Runnable runnable) {
+            this.mCompletionListeners.add(runnable);
+        }
+
+        public final void markStartedSpecialEffect(@NonNull CancellationSignal cancellationSignal) {
+            onStart();
+            this.mSpecialEffectsSignals.add(cancellationSignal);
+        }
+
+        public final void completeSpecialEffect(@NonNull CancellationSignal cancellationSignal) {
+            if (this.mSpecialEffectsSignals.remove(cancellationSignal) && this.mSpecialEffectsSignals.isEmpty()) {
+                complete();
+            }
+        }
+
+        @CallSuper
+        public void complete() {
+            if (this.mIsComplete) {
+                return;
+            }
+            if (FragmentManager.isLoggingEnabled(2)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("SpecialEffectsController: ");
+                sb.append(this);
+                sb.append(" has called complete.");
+            }
+            this.mIsComplete = true;
+            Iterator<Runnable> it = this.mCompletionListeners.iterator();
+            while (it.hasNext()) {
+                it.next().run();
+            }
+        }
+    }
+
+    /* renamed from: androidx.fragment.app.SpecialEffectsController$3, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass3 {
+        static final /* synthetic */ int[] $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$LifecycleImpact;
+        static final /* synthetic */ int[] $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State;
+
+        static {
+            int[] iArr = new int[Operation.LifecycleImpact.values().length];
+            $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$LifecycleImpact = iArr;
+            try {
+                iArr[Operation.LifecycleImpact.ADDING.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$LifecycleImpact[Operation.LifecycleImpact.REMOVING.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$LifecycleImpact[Operation.LifecycleImpact.NONE.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            int[] iArr2 = new int[Operation.State.values().length];
+            $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State = iArr2;
+            try {
+                iArr2[Operation.State.REMOVED.ordinal()] = 1;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[Operation.State.VISIBLE.ordinal()] = 2;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[Operation.State.GONE.ordinal()] = 3;
+            } catch (NoSuchFieldError unused6) {
+            }
+            try {
+                $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[Operation.State.INVISIBLE.ordinal()] = 4;
+            } catch (NoSuchFieldError unused7) {
+            }
+        }
+    }
+
+    public static class FragmentStateManagerOperation extends Operation {
+
+        @NonNull
+        private final FragmentStateManager mFragmentStateManager;
+
+        public FragmentStateManagerOperation(@NonNull Operation.State state, @NonNull Operation.LifecycleImpact lifecycleImpact, @NonNull FragmentStateManager fragmentStateManager, @NonNull CancellationSignal cancellationSignal) {
+            super(state, lifecycleImpact, fragmentStateManager.getFragment(), cancellationSignal);
+            this.mFragmentStateManager = fragmentStateManager;
+        }
+
+        @Override // androidx.fragment.app.SpecialEffectsController.Operation
+        public void onStart() {
+            if (getLifecycleImpact() == Operation.LifecycleImpact.ADDING) {
+                Fragment fragment = this.mFragmentStateManager.getFragment();
+                View findFocus = fragment.mView.findFocus();
+                if (findFocus != null) {
+                    fragment.setFocusedView(findFocus);
+                    if (FragmentManager.isLoggingEnabled(2)) {
+                        StringBuilder sb = new StringBuilder();
+                        sb.append("requestFocus: Saved focused view ");
+                        sb.append(findFocus);
+                        sb.append(" for Fragment ");
+                        sb.append(fragment);
+                    }
+                }
+                View requireView = getFragment().requireView();
+                if (requireView.getParent() == null) {
+                    this.mFragmentStateManager.addViewToContainer();
+                    requireView.setAlpha(0.0f);
+                }
+                if (requireView.getAlpha() == 0.0f && requireView.getVisibility() == 0) {
+                    requireView.setVisibility(4);
+                }
+                requireView.setAlpha(fragment.getPostOnViewCreatedAlpha());
+                return;
+            }
+            if (getLifecycleImpact() == Operation.LifecycleImpact.REMOVING) {
+                Fragment fragment2 = this.mFragmentStateManager.getFragment();
+                View requireView2 = fragment2.requireView();
+                if (FragmentManager.isLoggingEnabled(2)) {
+                    StringBuilder sb2 = new StringBuilder();
+                    sb2.append("Clearing focus ");
+                    sb2.append(requireView2.findFocus());
+                    sb2.append(" on view ");
+                    sb2.append(requireView2);
+                    sb2.append(" for Fragment ");
+                    sb2.append(fragment2);
+                }
+                requireView2.clearFocus();
+            }
+        }
+
+        @Override // androidx.fragment.app.SpecialEffectsController.Operation
+        public void complete() {
+            super.complete();
+            this.mFragmentStateManager.moveToExpectedState();
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/SpecialEffectsControllerFactory.java

@@ -0,0 +1,10 @@
+package androidx.fragment.app;
+
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+interface SpecialEffectsControllerFactory {
+    @NonNull
+    SpecialEffectsController createController(@NonNull ViewGroup viewGroup);
+}

decompiled/sources/androidx/fragment/app/SuperNotCalledException.java

@@ -0,0 +1,10 @@
+package androidx.fragment.app;
+
+import android.util.AndroidRuntimeException;
+
+/* loaded from: classes.dex */
+final class SuperNotCalledException extends AndroidRuntimeException {
+    public SuperNotCalledException(String str) {
+        super(str);
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/FragmentReuseViolation.java

@@ -0,0 +1,21 @@
+package androidx.fragment.app.strictmode;
+
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class FragmentReuseViolation extends Violation {
+    private final String previousFragmentId;
+
+    public final String getPreviousFragmentId() {
+        return this.previousFragmentId;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FragmentReuseViolation(Fragment fragment, String previousFragmentId) {
+        super(fragment, "Attempting to reuse fragment " + fragment + " with previous ID " + previousFragmentId);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        Intrinsics.checkNotNullParameter(previousFragmentId, "previousFragmentId");
+        this.previousFragmentId = previousFragmentId;
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/FragmentStrictMode.java

@@ -0,0 +1,423 @@
+package androidx.fragment.app.strictmode;
+
+import android.annotation.SuppressLint;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import android.view.ViewGroup;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentManager;
+import androidx.fragment.app.strictmode.FragmentStrictMode;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.collections.MapsKt__MapsKt;
+import kotlin.collections.SetsKt__SetsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class FragmentStrictMode {
+    private static final String TAG = "FragmentStrictMode";
+    public static final FragmentStrictMode INSTANCE = new FragmentStrictMode();
+    private static Policy defaultPolicy = Policy.LAX;
+
+    public enum Flag {
+        PENALTY_LOG,
+        PENALTY_DEATH,
+        DETECT_FRAGMENT_REUSE,
+        DETECT_FRAGMENT_TAG_USAGE,
+        DETECT_RETAIN_INSTANCE_USAGE,
+        DETECT_SET_USER_VISIBLE_HINT,
+        DETECT_TARGET_FRAGMENT_USAGE,
+        DETECT_WRONG_FRAGMENT_CONTAINER
+    }
+
+    public interface OnViolationListener {
+        void onViolation(Violation violation);
+    }
+
+    public final Policy getDefaultPolicy() {
+        return defaultPolicy;
+    }
+
+    public final void setDefaultPolicy(Policy policy) {
+        Intrinsics.checkNotNullParameter(policy, "<set-?>");
+        defaultPolicy = policy;
+    }
+
+    private FragmentStrictMode() {
+    }
+
+    private final Policy getNearestPolicy(Fragment fragment) {
+        while (fragment != null) {
+            if (fragment.isAdded()) {
+                FragmentManager parentFragmentManager = fragment.getParentFragmentManager();
+                Intrinsics.checkNotNullExpressionValue(parentFragmentManager, "declaringFragment.parentFragmentManager");
+                if (parentFragmentManager.getStrictModePolicy() != null) {
+                    Policy strictModePolicy = parentFragmentManager.getStrictModePolicy();
+                    Intrinsics.checkNotNull(strictModePolicy);
+                    return strictModePolicy;
+                }
+            }
+            fragment = fragment.getParentFragment();
+        }
+        return defaultPolicy;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final void onFragmentReuse(Fragment fragment, String previousFragmentId) {
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        Intrinsics.checkNotNullParameter(previousFragmentId, "previousFragmentId");
+        FragmentReuseViolation fragmentReuseViolation = new FragmentReuseViolation(fragment, previousFragmentId);
+        FragmentStrictMode fragmentStrictMode = INSTANCE;
+        fragmentStrictMode.logIfDebuggingEnabled(fragmentReuseViolation);
+        Policy nearestPolicy = fragmentStrictMode.getNearestPolicy(fragment);
+        if (nearestPolicy.getFlags$fragment_release().contains(Flag.DETECT_FRAGMENT_REUSE) && fragmentStrictMode.shouldHandlePolicyViolation(nearestPolicy, fragment.getClass(), fragmentReuseViolation.getClass())) {
+            fragmentStrictMode.handlePolicyViolation(nearestPolicy, fragmentReuseViolation);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final void onFragmentTagUsage(Fragment fragment, ViewGroup viewGroup) {
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        FragmentTagUsageViolation fragmentTagUsageViolation = new FragmentTagUsageViolation(fragment, viewGroup);
+        FragmentStrictMode fragmentStrictMode = INSTANCE;
+        fragmentStrictMode.logIfDebuggingEnabled(fragmentTagUsageViolation);
+        Policy nearestPolicy = fragmentStrictMode.getNearestPolicy(fragment);
+        if (nearestPolicy.getFlags$fragment_release().contains(Flag.DETECT_FRAGMENT_TAG_USAGE) && fragmentStrictMode.shouldHandlePolicyViolation(nearestPolicy, fragment.getClass(), fragmentTagUsageViolation.getClass())) {
+            fragmentStrictMode.handlePolicyViolation(nearestPolicy, fragmentTagUsageViolation);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final void onSetRetainInstanceUsage(Fragment fragment) {
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        SetRetainInstanceUsageViolation setRetainInstanceUsageViolation = new SetRetainInstanceUsageViolation(fragment);
+        FragmentStrictMode fragmentStrictMode = INSTANCE;
+        fragmentStrictMode.logIfDebuggingEnabled(setRetainInstanceUsageViolation);
+        Policy nearestPolicy = fragmentStrictMode.getNearestPolicy(fragment);
+        if (nearestPolicy.getFlags$fragment_release().contains(Flag.DETECT_RETAIN_INSTANCE_USAGE) && fragmentStrictMode.shouldHandlePolicyViolation(nearestPolicy, fragment.getClass(), setRetainInstanceUsageViolation.getClass())) {
+            fragmentStrictMode.handlePolicyViolation(nearestPolicy, setRetainInstanceUsageViolation);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final void onGetRetainInstanceUsage(Fragment fragment) {
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        GetRetainInstanceUsageViolation getRetainInstanceUsageViolation = new GetRetainInstanceUsageViolation(fragment);
+        FragmentStrictMode fragmentStrictMode = INSTANCE;
+        fragmentStrictMode.logIfDebuggingEnabled(getRetainInstanceUsageViolation);
+        Policy nearestPolicy = fragmentStrictMode.getNearestPolicy(fragment);
+        if (nearestPolicy.getFlags$fragment_release().contains(Flag.DETECT_RETAIN_INSTANCE_USAGE) && fragmentStrictMode.shouldHandlePolicyViolation(nearestPolicy, fragment.getClass(), getRetainInstanceUsageViolation.getClass())) {
+            fragmentStrictMode.handlePolicyViolation(nearestPolicy, getRetainInstanceUsageViolation);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final void onSetUserVisibleHint(Fragment fragment, boolean z) {
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        SetUserVisibleHintViolation setUserVisibleHintViolation = new SetUserVisibleHintViolation(fragment, z);
+        FragmentStrictMode fragmentStrictMode = INSTANCE;
+        fragmentStrictMode.logIfDebuggingEnabled(setUserVisibleHintViolation);
+        Policy nearestPolicy = fragmentStrictMode.getNearestPolicy(fragment);
+        if (nearestPolicy.getFlags$fragment_release().contains(Flag.DETECT_SET_USER_VISIBLE_HINT) && fragmentStrictMode.shouldHandlePolicyViolation(nearestPolicy, fragment.getClass(), setUserVisibleHintViolation.getClass())) {
+            fragmentStrictMode.handlePolicyViolation(nearestPolicy, setUserVisibleHintViolation);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final void onSetTargetFragmentUsage(Fragment violatingFragment, Fragment targetFragment, int i) {
+        Intrinsics.checkNotNullParameter(violatingFragment, "violatingFragment");
+        Intrinsics.checkNotNullParameter(targetFragment, "targetFragment");
+        SetTargetFragmentUsageViolation setTargetFragmentUsageViolation = new SetTargetFragmentUsageViolation(violatingFragment, targetFragment, i);
+        FragmentStrictMode fragmentStrictMode = INSTANCE;
+        fragmentStrictMode.logIfDebuggingEnabled(setTargetFragmentUsageViolation);
+        Policy nearestPolicy = fragmentStrictMode.getNearestPolicy(violatingFragment);
+        if (nearestPolicy.getFlags$fragment_release().contains(Flag.DETECT_TARGET_FRAGMENT_USAGE) && fragmentStrictMode.shouldHandlePolicyViolation(nearestPolicy, violatingFragment.getClass(), setTargetFragmentUsageViolation.getClass())) {
+            fragmentStrictMode.handlePolicyViolation(nearestPolicy, setTargetFragmentUsageViolation);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final void onGetTargetFragmentUsage(Fragment fragment) {
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        GetTargetFragmentUsageViolation getTargetFragmentUsageViolation = new GetTargetFragmentUsageViolation(fragment);
+        FragmentStrictMode fragmentStrictMode = INSTANCE;
+        fragmentStrictMode.logIfDebuggingEnabled(getTargetFragmentUsageViolation);
+        Policy nearestPolicy = fragmentStrictMode.getNearestPolicy(fragment);
+        if (nearestPolicy.getFlags$fragment_release().contains(Flag.DETECT_TARGET_FRAGMENT_USAGE) && fragmentStrictMode.shouldHandlePolicyViolation(nearestPolicy, fragment.getClass(), getTargetFragmentUsageViolation.getClass())) {
+            fragmentStrictMode.handlePolicyViolation(nearestPolicy, getTargetFragmentUsageViolation);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final void onGetTargetFragmentRequestCodeUsage(Fragment fragment) {
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        GetTargetFragmentRequestCodeUsageViolation getTargetFragmentRequestCodeUsageViolation = new GetTargetFragmentRequestCodeUsageViolation(fragment);
+        FragmentStrictMode fragmentStrictMode = INSTANCE;
+        fragmentStrictMode.logIfDebuggingEnabled(getTargetFragmentRequestCodeUsageViolation);
+        Policy nearestPolicy = fragmentStrictMode.getNearestPolicy(fragment);
+        if (nearestPolicy.getFlags$fragment_release().contains(Flag.DETECT_TARGET_FRAGMENT_USAGE) && fragmentStrictMode.shouldHandlePolicyViolation(nearestPolicy, fragment.getClass(), getTargetFragmentRequestCodeUsageViolation.getClass())) {
+            fragmentStrictMode.handlePolicyViolation(nearestPolicy, getTargetFragmentRequestCodeUsageViolation);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final void onWrongFragmentContainer(Fragment fragment, ViewGroup container) {
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        Intrinsics.checkNotNullParameter(container, "container");
+        WrongFragmentContainerViolation wrongFragmentContainerViolation = new WrongFragmentContainerViolation(fragment, container);
+        FragmentStrictMode fragmentStrictMode = INSTANCE;
+        fragmentStrictMode.logIfDebuggingEnabled(wrongFragmentContainerViolation);
+        Policy nearestPolicy = fragmentStrictMode.getNearestPolicy(fragment);
+        if (nearestPolicy.getFlags$fragment_release().contains(Flag.DETECT_WRONG_FRAGMENT_CONTAINER) && fragmentStrictMode.shouldHandlePolicyViolation(nearestPolicy, fragment.getClass(), wrongFragmentContainerViolation.getClass())) {
+            fragmentStrictMode.handlePolicyViolation(nearestPolicy, wrongFragmentContainerViolation);
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @VisibleForTesting
+    public final void onPolicyViolation(Violation violation) {
+        Intrinsics.checkNotNullParameter(violation, "violation");
+        logIfDebuggingEnabled(violation);
+        Fragment fragment = violation.getFragment();
+        Policy nearestPolicy = getNearestPolicy(fragment);
+        if (shouldHandlePolicyViolation(nearestPolicy, fragment.getClass(), violation.getClass())) {
+            handlePolicyViolation(nearestPolicy, violation);
+        }
+    }
+
+    private final void logIfDebuggingEnabled(Violation violation) {
+        if (FragmentManager.isLoggingEnabled(3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("StrictMode violation in ");
+            sb.append(violation.getFragment().getClass().getName());
+        }
+    }
+
+    private final boolean shouldHandlePolicyViolation(Policy policy, Class<? extends Fragment> cls, Class<? extends Violation> cls2) {
+        boolean contains;
+        Set<Class<? extends Violation>> set = policy.getMAllowedViolations$fragment_release().get(cls.getName());
+        if (set == null) {
+            return true;
+        }
+        if (!Intrinsics.areEqual(cls2.getSuperclass(), Violation.class)) {
+            contains = CollectionsKt___CollectionsKt.contains(set, cls2.getSuperclass());
+            if (contains) {
+                return false;
+            }
+        }
+        return !set.contains(cls2);
+    }
+
+    private final void handlePolicyViolation(final Policy policy, final Violation violation) {
+        Fragment fragment = violation.getFragment();
+        final String name = fragment.getClass().getName();
+        if (policy.getFlags$fragment_release().contains(Flag.PENALTY_LOG)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Policy violation in ");
+            sb.append(name);
+        }
+        if (policy.getListener$fragment_release() != null) {
+            runOnHostThread(fragment, new Runnable() { // from class: androidx.fragment.app.strictmode.FragmentStrictMode$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    FragmentStrictMode.m154handlePolicyViolation$lambda0(FragmentStrictMode.Policy.this, violation);
+                }
+            });
+        }
+        if (policy.getFlags$fragment_release().contains(Flag.PENALTY_DEATH)) {
+            runOnHostThread(fragment, new Runnable() { // from class: androidx.fragment.app.strictmode.FragmentStrictMode$$ExternalSyntheticLambda1
+                @Override // java.lang.Runnable
+                public final void run() {
+                    FragmentStrictMode.m155handlePolicyViolation$lambda1(name, violation);
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: handlePolicyViolation$lambda-0, reason: not valid java name */
+    public static final void m154handlePolicyViolation$lambda0(Policy policy, Violation violation) {
+        Intrinsics.checkNotNullParameter(policy, "$policy");
+        Intrinsics.checkNotNullParameter(violation, "$violation");
+        policy.getListener$fragment_release().onViolation(violation);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: handlePolicyViolation$lambda-1, reason: not valid java name */
+    public static final void m155handlePolicyViolation$lambda1(String str, Violation violation) {
+        Intrinsics.checkNotNullParameter(violation, "$violation");
+        Log.e(TAG, "Policy violation with PENALTY_DEATH in " + str, violation);
+        throw violation;
+    }
+
+    private final void runOnHostThread(Fragment fragment, Runnable runnable) {
+        if (fragment.isAdded()) {
+            Handler handler = fragment.getParentFragmentManager().getHost().getHandler();
+            Intrinsics.checkNotNullExpressionValue(handler, "fragment.parentFragmentManager.host.handler");
+            if (Intrinsics.areEqual(handler.getLooper(), Looper.myLooper())) {
+                runnable.run();
+                return;
+            } else {
+                handler.post(runnable);
+                return;
+            }
+        }
+        runnable.run();
+    }
+
+    public static final class Policy {
+        public static final Companion Companion = new Companion(null);
+        public static final Policy LAX;
+        private final Set<Flag> flags;
+        private final OnViolationListener listener;
+        private final Map<String, Set<Class<? extends Violation>>> mAllowedViolations;
+
+        public final Set<Flag> getFlags$fragment_release() {
+            return this.flags;
+        }
+
+        public final OnViolationListener getListener$fragment_release() {
+            return this.listener;
+        }
+
+        public final Map<String, Set<Class<? extends Violation>>> getMAllowedViolations$fragment_release() {
+            return this.mAllowedViolations;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        public Policy(Set<? extends Flag> flags, OnViolationListener onViolationListener, Map<String, ? extends Set<Class<? extends Violation>>> allowedViolations) {
+            Intrinsics.checkNotNullParameter(flags, "flags");
+            Intrinsics.checkNotNullParameter(allowedViolations, "allowedViolations");
+            this.flags = flags;
+            this.listener = onViolationListener;
+            LinkedHashMap linkedHashMap = new LinkedHashMap();
+            for (Map.Entry<String, ? extends Set<Class<? extends Violation>>> entry : allowedViolations.entrySet()) {
+                linkedHashMap.put(entry.getKey(), entry.getValue());
+            }
+            this.mAllowedViolations = linkedHashMap;
+        }
+
+        public static final class Builder {
+            private OnViolationListener listener;
+            private final Set<Flag> flags = new LinkedHashSet();
+            private final Map<String, Set<Class<? extends Violation>>> mAllowedViolations = new LinkedHashMap();
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder penaltyListener(OnViolationListener listener) {
+                Intrinsics.checkNotNullParameter(listener, "listener");
+                this.listener = listener;
+                return this;
+            }
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder penaltyLog() {
+                this.flags.add(Flag.PENALTY_LOG);
+                return this;
+            }
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder penaltyDeath() {
+                this.flags.add(Flag.PENALTY_DEATH);
+                return this;
+            }
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder detectFragmentReuse() {
+                this.flags.add(Flag.DETECT_FRAGMENT_REUSE);
+                return this;
+            }
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder detectFragmentTagUsage() {
+                this.flags.add(Flag.DETECT_FRAGMENT_TAG_USAGE);
+                return this;
+            }
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder detectRetainInstanceUsage() {
+                this.flags.add(Flag.DETECT_RETAIN_INSTANCE_USAGE);
+                return this;
+            }
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder detectSetUserVisibleHint() {
+                this.flags.add(Flag.DETECT_SET_USER_VISIBLE_HINT);
+                return this;
+            }
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder detectTargetFragmentUsage() {
+                this.flags.add(Flag.DETECT_TARGET_FRAGMENT_USAGE);
+                return this;
+            }
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder detectWrongFragmentContainer() {
+                this.flags.add(Flag.DETECT_WRONG_FRAGMENT_CONTAINER);
+                return this;
+            }
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder allowViolation(Class<? extends Fragment> fragmentClass, Class<? extends Violation> violationClass) {
+                Intrinsics.checkNotNullParameter(fragmentClass, "fragmentClass");
+                Intrinsics.checkNotNullParameter(violationClass, "violationClass");
+                String fragmentClassString = fragmentClass.getName();
+                Intrinsics.checkNotNullExpressionValue(fragmentClassString, "fragmentClassString");
+                return allowViolation(fragmentClassString, violationClass);
+            }
+
+            @SuppressLint({"BuilderSetStyle"})
+            public final Builder allowViolation(String fragmentClass, Class<? extends Violation> violationClass) {
+                Intrinsics.checkNotNullParameter(fragmentClass, "fragmentClass");
+                Intrinsics.checkNotNullParameter(violationClass, "violationClass");
+                Set<Class<? extends Violation>> set = this.mAllowedViolations.get(fragmentClass);
+                if (set == null) {
+                    set = new LinkedHashSet<>();
+                }
+                set.add(violationClass);
+                this.mAllowedViolations.put(fragmentClass, set);
+                return this;
+            }
+
+            public final Policy build() {
+                if (this.listener == null && !this.flags.contains(Flag.PENALTY_DEATH)) {
+                    penaltyLog();
+                }
+                return new Policy(this.flags, this.listener, this.mAllowedViolations);
+            }
+        }
+
+        public static final class Companion {
+            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+                this();
+            }
+
+            private Companion() {
+            }
+        }
+
+        static {
+            Set emptySet;
+            Map emptyMap;
+            emptySet = SetsKt__SetsKt.emptySet();
+            emptyMap = MapsKt__MapsKt.emptyMap();
+            LAX = new Policy(emptySet, null, emptyMap);
+        }
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/FragmentTagUsageViolation.java

@@ -0,0 +1,21 @@
+package androidx.fragment.app.strictmode;
+
+import android.view.ViewGroup;
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class FragmentTagUsageViolation extends Violation {
+    private final ViewGroup parentContainer;
+
+    public final ViewGroup getParentContainer() {
+        return this.parentContainer;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FragmentTagUsageViolation(Fragment fragment, ViewGroup viewGroup) {
+        super(fragment, "Attempting to use <fragment> tag to add fragment " + fragment + " to container " + viewGroup);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        this.parentContainer = viewGroup;
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/GetRetainInstanceUsageViolation.java

@@ -0,0 +1,13 @@
+package androidx.fragment.app.strictmode;
+
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class GetRetainInstanceUsageViolation extends RetainInstanceUsageViolation {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public GetRetainInstanceUsageViolation(Fragment fragment) {
+        super(fragment, "Attempting to get retain instance for fragment " + fragment);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/GetTargetFragmentRequestCodeUsageViolation.java

@@ -0,0 +1,13 @@
+package androidx.fragment.app.strictmode;
+
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class GetTargetFragmentRequestCodeUsageViolation extends TargetFragmentUsageViolation {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public GetTargetFragmentRequestCodeUsageViolation(Fragment fragment) {
+        super(fragment, "Attempting to get target request code from fragment " + fragment);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/GetTargetFragmentUsageViolation.java

@@ -0,0 +1,13 @@
+package androidx.fragment.app.strictmode;
+
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class GetTargetFragmentUsageViolation extends TargetFragmentUsageViolation {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public GetTargetFragmentUsageViolation(Fragment fragment) {
+        super(fragment, "Attempting to get target fragment from fragment " + fragment);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/RetainInstanceUsageViolation.java

@@ -0,0 +1,18 @@
+package androidx.fragment.app.strictmode;
+
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public abstract class RetainInstanceUsageViolation extends Violation {
+    public /* synthetic */ RetainInstanceUsageViolation(Fragment fragment, String str, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(fragment, (i & 2) != 0 ? null : str);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public RetainInstanceUsageViolation(Fragment fragment, String str) {
+        super(fragment, str);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/SetRetainInstanceUsageViolation.java

@@ -0,0 +1,13 @@
+package androidx.fragment.app.strictmode;
+
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class SetRetainInstanceUsageViolation extends RetainInstanceUsageViolation {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public SetRetainInstanceUsageViolation(Fragment fragment) {
+        super(fragment, "Attempting to set retain instance for fragment " + fragment);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/SetTargetFragmentUsageViolation.java

@@ -0,0 +1,27 @@
+package androidx.fragment.app.strictmode;
+
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class SetTargetFragmentUsageViolation extends TargetFragmentUsageViolation {
+    private final int requestCode;
+    private final Fragment targetFragment;
+
+    public final int getRequestCode() {
+        return this.requestCode;
+    }
+
+    public final Fragment getTargetFragment() {
+        return this.targetFragment;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public SetTargetFragmentUsageViolation(Fragment fragment, Fragment targetFragment, int i) {
+        super(fragment, "Attempting to set target fragment " + targetFragment + " with request code " + i + " for fragment " + fragment);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        Intrinsics.checkNotNullParameter(targetFragment, "targetFragment");
+        this.targetFragment = targetFragment;
+        this.requestCode = i;
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/SetUserVisibleHintViolation.java

@@ -0,0 +1,20 @@
+package androidx.fragment.app.strictmode;
+
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class SetUserVisibleHintViolation extends Violation {
+    private final boolean isVisibleToUser;
+
+    public final boolean isVisibleToUser() {
+        return this.isVisibleToUser;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public SetUserVisibleHintViolation(Fragment fragment, boolean z) {
+        super(fragment, "Attempting to set user visible hint to " + z + " for fragment " + fragment);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        this.isVisibleToUser = z;
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/TargetFragmentUsageViolation.java

@@ -0,0 +1,18 @@
+package androidx.fragment.app.strictmode;
+
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public abstract class TargetFragmentUsageViolation extends Violation {
+    public /* synthetic */ TargetFragmentUsageViolation(Fragment fragment, String str, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(fragment, (i & 2) != 0 ? null : str);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public TargetFragmentUsageViolation(Fragment fragment, String str) {
+        super(fragment, str);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/Violation.java

@@ -0,0 +1,25 @@
+package androidx.fragment.app.strictmode;
+
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public abstract class Violation extends RuntimeException {
+    private final Fragment fragment;
+
+    public final Fragment getFragment() {
+        return this.fragment;
+    }
+
+    public /* synthetic */ Violation(Fragment fragment, String str, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(fragment, (i & 2) != 0 ? null : str);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public Violation(Fragment fragment, String str) {
+        super(str);
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        this.fragment = fragment;
+    }
+}

decompiled/sources/androidx/fragment/app/strictmode/WrongFragmentContainerViolation.java

@@ -0,0 +1,22 @@
+package androidx.fragment.app.strictmode;
+
+import android.view.ViewGroup;
+import androidx.fragment.app.Fragment;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class WrongFragmentContainerViolation extends Violation {
+    private final ViewGroup container;
+
+    public final ViewGroup getContainer() {
+        return this.container;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public WrongFragmentContainerViolation(Fragment fragment, ViewGroup container) {
+        super(fragment, "Attempting to add fragment " + fragment + " to container " + container + " which is not a FragmentContainerView");
+        Intrinsics.checkNotNullParameter(fragment, "fragment");
+        Intrinsics.checkNotNullParameter(container, "container");
+        this.container = container;
+    }
+}