Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/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();
+    }
+}