CrackMe.apk
Download file
package androidx.fragment.app;
import android.app.Activity;
import android.content.Context;
import android.content.ContextWrapper;
import android.content.Intent;
import android.content.IntentSender;
import android.content.res.Configuration;
import android.os.Bundle;
import android.os.Looper;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import androidx.activity.OnBackPressedCallback;
import androidx.activity.OnBackPressedDispatcher;
import androidx.activity.result.ActivityResult;
import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.IntentSenderRequest;
import androidx.activity.result.contract.ActivityResultContract;
import androidx.activity.result.contract.ActivityResultContracts;
import androidx.fragment.R;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentTransaction;
import androidx.fragment.app.strictmode.FragmentStrictMode;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleEventObserver;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.ViewModelStore;
import androidx.lifecycle.ViewModelStoreOwner;
import androidx.savedstate.SavedStateRegistryOwner;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;
public abstract class FragmentManager implements FragmentResultOwner {
private static boolean DEBUG = false;
private static final String EXTRA_CREATED_FILLIN_INTENT = "androidx.fragment.extra.ACTIVITY_OPTIONS_BUNDLE";
public static final int POP_BACK_STACK_INCLUSIVE = 1;
static final String SAVED_STATE_TAG = "android:support:fragments";
public static final String TAG = "FragmentManager";
ArrayList<BackStackRecord> mBackStack;
private ArrayList<OnBackStackChangedListener> mBackStackChangeListeners;
private final AtomicInteger mBackStackIndex = new AtomicInteger();
private final Map<String, BackStackState> mBackStackStates = Collections.synchronizedMap(new HashMap());
private FragmentContainer mContainer;
private ArrayList<Fragment> mCreatedMenus;
int mCurState = -1;
private SpecialEffectsControllerFactory mDefaultSpecialEffectsControllerFactory = new SpecialEffectsControllerFactory() {
public SpecialEffectsController createController(ViewGroup viewGroup) {
return new DefaultSpecialEffectsController(viewGroup);
}
};
private boolean mDestroyed;
private Runnable mExecCommit = new Runnable() {
public void run() {
FragmentManager.this.execPendingActions(true);
}
};
private boolean mExecutingActions;
private FragmentFactory mFragmentFactory = null;
/* access modifiers changed from: private */
public final FragmentStore mFragmentStore = new FragmentStore();
private boolean mHavePendingDeferredStart;
private FragmentHostCallback<?> mHost;
private FragmentFactory mHostFragmentFactory = new FragmentFactory() {
public Fragment instantiate(ClassLoader classLoader, String str) {
return FragmentManager.this.getHost().instantiate(FragmentManager.this.getHost().getContext(), str, (Bundle) null);
}
};
ArrayDeque<LaunchedFragmentInfo> mLaunchedFragments = new ArrayDeque<>();
private final FragmentLayoutInflaterFactory mLayoutInflaterFactory = new FragmentLayoutInflaterFactory(this);
private final FragmentLifecycleCallbacksDispatcher mLifecycleCallbacksDispatcher = new FragmentLifecycleCallbacksDispatcher(this);
private boolean mNeedMenuInvalidate;
private FragmentManagerViewModel mNonConfig;
private final CopyOnWriteArrayList<FragmentOnAttachListener> mOnAttachListeners = new CopyOnWriteArrayList<>();
private final OnBackPressedCallback mOnBackPressedCallback = new OnBackPressedCallback(false) {
public void handleOnBackPressed() {
FragmentManager.this.handleOnBackPressed();
}
};
private OnBackPressedDispatcher mOnBackPressedDispatcher;
private Fragment mParent;
private final ArrayList<OpGenerator> mPendingActions = new ArrayList<>();
Fragment mPrimaryNav;
private ActivityResultLauncher<String[]> mRequestPermissions;
/* access modifiers changed from: private */
public final Map<String, LifecycleAwareResultListener> mResultListeners = Collections.synchronizedMap(new HashMap());
/* access modifiers changed from: private */
public final Map<String, Bundle> mResults = Collections.synchronizedMap(new HashMap());
private SpecialEffectsControllerFactory mSpecialEffectsControllerFactory = null;
private ActivityResultLauncher<Intent> mStartActivityForResult;
private ActivityResultLauncher<IntentSenderRequest> mStartIntentSenderForResult;
private boolean mStateSaved;
private boolean mStopped;
private FragmentStrictMode.Policy mStrictModePolicy;
private ArrayList<Fragment> mTmpAddedFragments;
private ArrayList<Boolean> mTmpIsPop;
private ArrayList<BackStackRecord> mTmpRecords;
public interface BackStackEntry {
@Deprecated
CharSequence getBreadCrumbShortTitle();
@Deprecated
int getBreadCrumbShortTitleRes();
@Deprecated
CharSequence getBreadCrumbTitle();
@Deprecated
int getBreadCrumbTitleRes();
int getId();
String getName();
}
public static abstract class FragmentLifecycleCallbacks {
@Deprecated
public void onFragmentActivityCreated(FragmentManager fragmentManager, Fragment fragment, Bundle bundle) {
}
public void onFragmentAttached(FragmentManager fragmentManager, Fragment fragment, Context context) {
}
public void onFragmentCreated(FragmentManager fragmentManager, Fragment fragment, Bundle bundle) {
}
public void onFragmentDestroyed(FragmentManager fragmentManager, Fragment fragment) {
}
public void onFragmentDetached(FragmentManager fragmentManager, Fragment fragment) {
}
public void onFragmentPaused(FragmentManager fragmentManager, Fragment fragment) {
}
public void onFragmentPreAttached(FragmentManager fragmentManager, Fragment fragment, Context context) {
}
public void onFragmentPreCreated(FragmentManager fragmentManager, Fragment fragment, Bundle bundle) {
}
public void onFragmentResumed(FragmentManager fragmentManager, Fragment fragment) {
}
public void onFragmentSaveInstanceState(FragmentManager fragmentManager, Fragment fragment, Bundle bundle) {
}
public void onFragmentStarted(FragmentManager fragmentManager, Fragment fragment) {
}
public void onFragmentStopped(FragmentManager fragmentManager, Fragment fragment) {
}
public void onFragmentViewCreated(FragmentManager fragmentManager, Fragment fragment, View view, Bundle bundle) {
}
public void onFragmentViewDestroyed(FragmentManager fragmentManager, Fragment fragment) {
}
}
public interface OnBackStackChangedListener {
void onBackStackChanged();
}
interface OpGenerator {
boolean generateOps(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2);
}
static int reverseTransit(int i) {
if (i == 4097) {
return 8194;
}
if (i == 8194) {
return FragmentTransaction.TRANSIT_FRAGMENT_OPEN;
}
if (i == 8197) {
return FragmentTransaction.TRANSIT_FRAGMENT_MATCH_ACTIVITY_OPEN;
}
if (i == 4099) {
return FragmentTransaction.TRANSIT_FRAGMENT_FADE;
}
if (i != 4100) {
return 0;
}
return FragmentTransaction.TRANSIT_FRAGMENT_MATCH_ACTIVITY_CLOSE;
}
@Deprecated
public static void enableDebugLogging(boolean z) {
DEBUG = z;
}
public static boolean isLoggingEnabled(int i) {
return DEBUG || Log.isLoggable(TAG, i);
}
private static class LifecycleAwareResultListener implements FragmentResultListener {
private final Lifecycle mLifecycle;
private final FragmentResultListener mListener;
private final LifecycleEventObserver mObserver;
LifecycleAwareResultListener(Lifecycle lifecycle, FragmentResultListener fragmentResultListener, LifecycleEventObserver lifecycleEventObserver) {
this.mLifecycle = lifecycle;
this.mListener = fragmentResultListener;
this.mObserver = lifecycleEventObserver;
}
public boolean isAtLeast(Lifecycle.State state) {
return this.mLifecycle.getCurrentState().isAtLeast(state);
}
public void onFragmentResult(String str, Bundle bundle) {
this.mListener.onFragmentResult(str, bundle);
}
public void removeObserver() {
this.mLifecycle.removeObserver(this.mObserver);
}
}
private void throwException(RuntimeException runtimeException) {
Log.e(TAG, runtimeException.getMessage());
Log.e(TAG, "Activity state:");
PrintWriter printWriter = new PrintWriter(new LogWriter(TAG));
FragmentHostCallback<?> fragmentHostCallback = this.mHost;
if (fragmentHostCallback != null) {
try {
fragmentHostCallback.onDump(" ", (FileDescriptor) null, printWriter, new String[0]);
} catch (Exception e) {
Log.e(TAG, "Failed dumping state", e);
}
} else {
try {
dump(" ", (FileDescriptor) null, printWriter, new String[0]);
} catch (Exception e2) {
Log.e(TAG, "Failed dumping state", e2);
}
}
throw runtimeException;
}
@Deprecated
public FragmentTransaction openTransaction() {
return beginTransaction();
}
public FragmentTransaction beginTransaction() {
return new BackStackRecord(this);
}
public boolean executePendingTransactions() {
boolean execPendingActions = execPendingActions(true);
forcePostponedTransactions();
return execPendingActions;
}
/* JADX WARNING: Code restructure failed: missing block: B:10:0x001a, code lost:
if (getBackStackEntryCount() <= 0) goto L_0x0025;
*/
/* JADX WARNING: Code restructure failed: missing block: B:12:0x0022, code lost:
if (isPrimaryNavigation(r3.mParent) == false) goto L_0x0025;
*/
/* JADX WARNING: Code restructure failed: missing block: B:13:0x0025, code lost:
r2 = false;
*/
/* JADX WARNING: Code restructure failed: missing block: B:14:0x0026, code lost:
r0.setEnabled(r2);
*/
/* JADX WARNING: Code restructure failed: missing block: B:15:0x0029, code lost:
return;
*/
/* JADX WARNING: Code restructure failed: missing block: B:9:0x0014, code lost:
r0 = r3.mOnBackPressedCallback;
*/
/* Code decompiled incorrectly, please refer to instructions dump. */
private void updateOnBackPressedCallbackEnabled() {
/*
r3 = this;
java.util.ArrayList<androidx.fragment.app.FragmentManager$OpGenerator> r0 = r3.mPendingActions
monitor-enter(r0)
java.util.ArrayList<androidx.fragment.app.FragmentManager$OpGenerator> r1 = r3.mPendingActions // Catch:{ all -> 0x002a }
boolean r1 = r1.isEmpty() // Catch:{ all -> 0x002a }
r2 = 1
if (r1 != 0) goto L_0x0013
androidx.activity.OnBackPressedCallback r1 = r3.mOnBackPressedCallback // Catch:{ all -> 0x002a }
r1.setEnabled(r2) // Catch:{ all -> 0x002a }
monitor-exit(r0) // Catch:{ all -> 0x002a }
return
L_0x0013:
monitor-exit(r0) // Catch:{ all -> 0x002a }
androidx.activity.OnBackPressedCallback r0 = r3.mOnBackPressedCallback
int r1 = r3.getBackStackEntryCount()
if (r1 <= 0) goto L_0x0025
androidx.fragment.app.Fragment r1 = r3.mParent
boolean r1 = r3.isPrimaryNavigation(r1)
if (r1 == 0) goto L_0x0025
goto L_0x0026
L_0x0025:
r2 = 0
L_0x0026:
r0.setEnabled(r2)
return
L_0x002a:
r1 = move-exception
monitor-exit(r0) // Catch:{ all -> 0x002a }
throw r1
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.fragment.app.FragmentManager.updateOnBackPressedCallbackEnabled():void");
}
/* access modifiers changed from: package-private */
public boolean isPrimaryNavigation(Fragment fragment) {
if (fragment == null) {
return true;
}
FragmentManager fragmentManager = fragment.mFragmentManager;
if (!fragment.equals(fragmentManager.getPrimaryNavigationFragment()) || !isPrimaryNavigation(fragmentManager.mParent)) {
return false;
}
return true;
}
/* access modifiers changed from: package-private */
public boolean isParentMenuVisible(Fragment fragment) {
if (fragment == null) {
return true;
}
return fragment.isMenuVisible();
}
/* access modifiers changed from: package-private */
public boolean isParentHidden(Fragment fragment) {
if (fragment == null) {
return false;
}
return fragment.isHidden();
}
/* access modifiers changed from: package-private */
public void handleOnBackPressed() {
execPendingActions(true);
if (this.mOnBackPressedCallback.isEnabled()) {
popBackStackImmediate();
} else {
this.mOnBackPressedDispatcher.onBackPressed();
}
}
public void restoreBackStack(String str) {
enqueueAction(new RestoreBackStackState(str), false);
}
public void saveBackStack(String str) {
enqueueAction(new SaveBackStackState(str), false);
}
public void clearBackStack(String str) {
enqueueAction(new ClearBackStackState(str), false);
}
public void popBackStack() {
enqueueAction(new PopBackStackState((String) null, -1, 0), false);
}
public boolean popBackStackImmediate() {
return popBackStackImmediate((String) null, -1, 0);
}
public void popBackStack(String str, int i) {
enqueueAction(new PopBackStackState(str, -1, i), false);
}
public boolean popBackStackImmediate(String str, int i) {
return popBackStackImmediate(str, -1, i);
}
public void popBackStack(int i, int i2) {
popBackStack(i, i2, false);
}
/* access modifiers changed from: package-private */
public void popBackStack(int i, int i2, boolean z) {
if (i >= 0) {
enqueueAction(new PopBackStackState((String) null, i, i2), z);
return;
}
throw new IllegalArgumentException("Bad id: " + i);
}
public boolean popBackStackImmediate(int i, int i2) {
if (i >= 0) {
return popBackStackImmediate((String) null, i, i2);
}
throw new IllegalArgumentException("Bad id: " + i);
}
private boolean popBackStackImmediate(String str, int i, int i2) {
execPendingActions(false);
ensureExecReady(true);
Fragment fragment = this.mPrimaryNav;
if (fragment != null && i < 0 && str == null && fragment.getChildFragmentManager().popBackStackImmediate()) {
return true;
}
boolean popBackStackState = popBackStackState(this.mTmpRecords, this.mTmpIsPop, str, i, i2);
if (popBackStackState) {
this.mExecutingActions = true;
try {
removeRedundantOperationsAndExecute(this.mTmpRecords, this.mTmpIsPop);
} finally {
cleanupExec();
}
}
updateOnBackPressedCallbackEnabled();
doPendingDeferredStart();
this.mFragmentStore.burpActive();
return popBackStackState;
}
public int getBackStackEntryCount() {
ArrayList<BackStackRecord> arrayList = this.mBackStack;
if (arrayList != null) {
return arrayList.size();
}
return 0;
}
public BackStackEntry getBackStackEntryAt(int i) {
return this.mBackStack.get(i);
}
public void addOnBackStackChangedListener(OnBackStackChangedListener onBackStackChangedListener) {
if (this.mBackStackChangeListeners == null) {
this.mBackStackChangeListeners = new ArrayList<>();
}
this.mBackStackChangeListeners.add(onBackStackChangedListener);
}
public void removeOnBackStackChangedListener(OnBackStackChangedListener onBackStackChangedListener) {
ArrayList<OnBackStackChangedListener> arrayList = this.mBackStackChangeListeners;
if (arrayList != null) {
arrayList.remove(onBackStackChangedListener);
}
}
public final void setFragmentResult(String str, Bundle bundle) {
LifecycleAwareResultListener lifecycleAwareResultListener = this.mResultListeners.get(str);
if (lifecycleAwareResultListener == null || !lifecycleAwareResultListener.isAtLeast(Lifecycle.State.STARTED)) {
this.mResults.put(str, bundle);
} else {
lifecycleAwareResultListener.onFragmentResult(str, bundle);
}
if (isLoggingEnabled(2)) {
Log.v(TAG, "Setting fragment result with key " + str + " and result " + bundle);
}
}
public final void clearFragmentResult(String str) {
this.mResults.remove(str);
if (isLoggingEnabled(2)) {
Log.v(TAG, "Clearing fragment result with key " + str);
}
}
public final void setFragmentResultListener(final String str, LifecycleOwner lifecycleOwner, final FragmentResultListener fragmentResultListener) {
final Lifecycle lifecycle = lifecycleOwner.getLifecycle();
if (lifecycle.getCurrentState() != Lifecycle.State.DESTROYED) {
AnonymousClass5 r0 = new LifecycleEventObserver() {
public void onStateChanged(LifecycleOwner lifecycleOwner, Lifecycle.Event event) {
Bundle bundle;
if (event == Lifecycle.Event.ON_START && (bundle = (Bundle) FragmentManager.this.mResults.get(str)) != null) {
fragmentResultListener.onFragmentResult(str, bundle);
FragmentManager.this.clearFragmentResult(str);
}
if (event == Lifecycle.Event.ON_DESTROY) {
lifecycle.removeObserver(this);
FragmentManager.this.mResultListeners.remove(str);
}
}
};
lifecycle.addObserver(r0);
LifecycleAwareResultListener put = this.mResultListeners.put(str, new LifecycleAwareResultListener(lifecycle, fragmentResultListener, r0));
if (put != null) {
put.removeObserver();
}
if (isLoggingEnabled(2)) {
Log.v(TAG, "Setting FragmentResultListener with key " + str + " lifecycleOwner " + lifecycle + " and listener " + fragmentResultListener);
}
}
}
public final void clearFragmentResultListener(String str) {
LifecycleAwareResultListener remove = this.mResultListeners.remove(str);
if (remove != null) {
remove.removeObserver();
}
if (isLoggingEnabled(2)) {
Log.v(TAG, "Clearing FragmentResultListener for key " + str);
}
}
public void putFragment(Bundle bundle, String str, Fragment fragment) {
if (fragment.mFragmentManager != this) {
throwException(new IllegalStateException("Fragment " + fragment + " is not currently in the FragmentManager"));
}
bundle.putString(str, fragment.mWho);
}
public Fragment getFragment(Bundle bundle, String str) {
String string = bundle.getString(str);
if (string == null) {
return null;
}
Fragment findActiveFragment = findActiveFragment(string);
if (findActiveFragment == null) {
throwException(new IllegalStateException("Fragment no longer exists for key " + str + ": unique id " + string));
}
return findActiveFragment;
}
public static <F extends Fragment> F findFragment(View view) {
F findViewFragment = findViewFragment(view);
if (findViewFragment != null) {
return findViewFragment;
}
throw new IllegalStateException("View " + view + " does not have a Fragment set");
}
private static Fragment findViewFragment(View view) {
while (view != null) {
Fragment viewFragment = getViewFragment(view);
if (viewFragment != null) {
return viewFragment;
}
ViewParent parent = view.getParent();
view = parent instanceof View ? (View) parent : null;
}
return null;
}
static Fragment getViewFragment(View view) {
Object tag = view.getTag(R.id.fragment_container_view_tag);
if (tag instanceof Fragment) {
return (Fragment) tag;
}
return null;
}
/* access modifiers changed from: package-private */
public void onContainerAvailable(FragmentContainerView fragmentContainerView) {
for (FragmentStateManager next : this.mFragmentStore.getActiveFragmentStateManagers()) {
Fragment fragment = next.getFragment();
if (fragment.mContainerId == fragmentContainerView.getId() && fragment.mView != null && fragment.mView.getParent() == null) {
fragment.mContainer = fragmentContainerView;
next.addViewToContainer();
}
}
}
static FragmentManager findFragmentManager(View view) {
Fragment findViewFragment = findViewFragment(view);
if (findViewFragment == null) {
Context context = view.getContext();
FragmentActivity fragmentActivity = null;
while (true) {
if (!(context instanceof ContextWrapper)) {
break;
} else if (context instanceof FragmentActivity) {
fragmentActivity = (FragmentActivity) context;
break;
} else {
context = ((ContextWrapper) context).getBaseContext();
}
}
if (fragmentActivity != null) {
return fragmentActivity.getSupportFragmentManager();
}
throw new IllegalStateException("View " + view + " is not within a subclass of FragmentActivity.");
} else if (findViewFragment.isAdded()) {
return findViewFragment.getChildFragmentManager();
} else {
throw new IllegalStateException("The Fragment " + findViewFragment + " that owns View " + view + " has already been destroyed. Nested fragments should always use the child FragmentManager.");
}
}
public List<Fragment> getFragments() {
return this.mFragmentStore.getFragments();
}
/* access modifiers changed from: package-private */
public ViewModelStore getViewModelStore(Fragment fragment) {
return this.mNonConfig.getViewModelStore(fragment);
}
private FragmentManagerViewModel getChildNonConfig(Fragment fragment) {
return this.mNonConfig.getChildNonConfig(fragment);
}
/* access modifiers changed from: package-private */
public void addRetainedFragment(Fragment fragment) {
this.mNonConfig.addRetainedFragment(fragment);
}
/* access modifiers changed from: package-private */
public void removeRetainedFragment(Fragment fragment) {
this.mNonConfig.removeRetainedFragment(fragment);
}
/* access modifiers changed from: package-private */
public List<Fragment> getActiveFragments() {
return this.mFragmentStore.getActiveFragments();
}
/* access modifiers changed from: package-private */
public int getActiveFragmentCount() {
return this.mFragmentStore.getActiveFragmentCount();
}
public Fragment.SavedState saveFragmentInstanceState(Fragment fragment) {
FragmentStateManager fragmentStateManager = this.mFragmentStore.getFragmentStateManager(fragment.mWho);
if (fragmentStateManager == null || !fragmentStateManager.getFragment().equals(fragment)) {
throwException(new IllegalStateException("Fragment " + fragment + " is not currently in the FragmentManager"));
}
return fragmentStateManager.saveInstanceState();
}
private void clearBackStackStateViewModels() {
FragmentHostCallback<?> fragmentHostCallback = this.mHost;
boolean z = true;
if (fragmentHostCallback instanceof ViewModelStoreOwner) {
z = this.mFragmentStore.getNonConfig().isCleared();
} else if (fragmentHostCallback.getContext() instanceof Activity) {
z = true ^ ((Activity) this.mHost.getContext()).isChangingConfigurations();
}
if (z) {
for (BackStackState backStackState : this.mBackStackStates.values()) {
for (String clearNonConfigState : backStackState.mFragments) {
this.mFragmentStore.getNonConfig().clearNonConfigState(clearNonConfigState);
}
}
}
}
public boolean isDestroyed() {
return this.mDestroyed;
}
public String toString() {
StringBuilder sb = new StringBuilder(128);
sb.append("FragmentManager{");
sb.append(Integer.toHexString(System.identityHashCode(this)));
sb.append(" in ");
Fragment fragment = this.mParent;
if (fragment != null) {
sb.append(fragment.getClass().getSimpleName());
sb.append("{");
sb.append(Integer.toHexString(System.identityHashCode(this.mParent)));
sb.append("}");
} else {
FragmentHostCallback<?> fragmentHostCallback = this.mHost;
if (fragmentHostCallback != null) {
sb.append(fragmentHostCallback.getClass().getSimpleName());
sb.append("{");
sb.append(Integer.toHexString(System.identityHashCode(this.mHost)));
sb.append("}");
} else {
sb.append("null");
}
}
sb.append("}}");
return sb.toString();
}
public void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
int size;
int size2;
String str2 = str + " ";
this.mFragmentStore.dump(str, fileDescriptor, printWriter, strArr);
ArrayList<Fragment> arrayList = this.mCreatedMenus;
if (arrayList != null && (size2 = arrayList.size()) > 0) {
printWriter.print(str);
printWriter.println("Fragments Created Menus:");
for (int i = 0; i < size2; i++) {
printWriter.print(str);
printWriter.print(" #");
printWriter.print(i);
printWriter.print(": ");
printWriter.println(this.mCreatedMenus.get(i).toString());
}
}
ArrayList<BackStackRecord> arrayList2 = this.mBackStack;
if (arrayList2 != null && (size = arrayList2.size()) > 0) {
printWriter.print(str);
printWriter.println("Back Stack:");
for (int i2 = 0; i2 < size; i2++) {
BackStackRecord backStackRecord = this.mBackStack.get(i2);
printWriter.print(str);
printWriter.print(" #");
printWriter.print(i2);
printWriter.print(": ");
printWriter.println(backStackRecord.toString());
backStackRecord.dump(str2, printWriter);
}
}
printWriter.print(str);
printWriter.println("Back Stack Index: " + this.mBackStackIndex.get());
synchronized (this.mPendingActions) {
int size3 = this.mPendingActions.size();
if (size3 > 0) {
printWriter.print(str);
printWriter.println("Pending Actions:");
for (int i3 = 0; i3 < size3; i3++) {
printWriter.print(str);
printWriter.print(" #");
printWriter.print(i3);
printWriter.print(": ");
printWriter.println(this.mPendingActions.get(i3));
}
}
}
printWriter.print(str);
printWriter.println("FragmentManager misc state:");
printWriter.print(str);
printWriter.print(" mHost=");
printWriter.println(this.mHost);
printWriter.print(str);
printWriter.print(" mContainer=");
printWriter.println(this.mContainer);
if (this.mParent != null) {
printWriter.print(str);
printWriter.print(" mParent=");
printWriter.println(this.mParent);
}
printWriter.print(str);
printWriter.print(" mCurState=");
printWriter.print(this.mCurState);
printWriter.print(" mStateSaved=");
printWriter.print(this.mStateSaved);
printWriter.print(" mStopped=");
printWriter.print(this.mStopped);
printWriter.print(" mDestroyed=");
printWriter.println(this.mDestroyed);
if (this.mNeedMenuInvalidate) {
printWriter.print(str);
printWriter.print(" mNeedMenuInvalidate=");
printWriter.println(this.mNeedMenuInvalidate);
}
}
/* access modifiers changed from: package-private */
public void performPendingDeferredStart(FragmentStateManager fragmentStateManager) {
Fragment fragment = fragmentStateManager.getFragment();
if (!fragment.mDeferStart) {
return;
}
if (this.mExecutingActions) {
this.mHavePendingDeferredStart = true;
return;
}
fragment.mDeferStart = false;
fragmentStateManager.moveToExpectedState();
}
/* access modifiers changed from: package-private */
public boolean isStateAtLeast(int i) {
return this.mCurState >= i;
}
/* access modifiers changed from: package-private */
public void setExitAnimationOrder(Fragment fragment, boolean z) {
ViewGroup fragmentContainer = getFragmentContainer(fragment);
if (fragmentContainer != null && (fragmentContainer instanceof FragmentContainerView)) {
((FragmentContainerView) fragmentContainer).setDrawDisappearingViewsLast(!z);
}
}
/* access modifiers changed from: package-private */
public void moveToState(int i, boolean z) {
FragmentHostCallback<?> fragmentHostCallback;
if (this.mHost == null && i != -1) {
throw new IllegalStateException("No activity");
} else if (z || i != this.mCurState) {
this.mCurState = i;
this.mFragmentStore.moveToExpectedState();
startPendingDeferredFragments();
if (this.mNeedMenuInvalidate && (fragmentHostCallback = this.mHost) != null && this.mCurState == 7) {
fragmentHostCallback.onSupportInvalidateOptionsMenu();
this.mNeedMenuInvalidate = false;
}
}
}
private void startPendingDeferredFragments() {
for (FragmentStateManager performPendingDeferredStart : this.mFragmentStore.getActiveFragmentStateManagers()) {
performPendingDeferredStart(performPendingDeferredStart);
}
}
/* access modifiers changed from: package-private */
public FragmentStateManager createOrGetFragmentStateManager(Fragment fragment) {
FragmentStateManager fragmentStateManager = this.mFragmentStore.getFragmentStateManager(fragment.mWho);
if (fragmentStateManager != null) {
return fragmentStateManager;
}
FragmentStateManager fragmentStateManager2 = new FragmentStateManager(this.mLifecycleCallbacksDispatcher, this.mFragmentStore, fragment);
fragmentStateManager2.restoreState(this.mHost.getContext().getClassLoader());
fragmentStateManager2.setFragmentManagerState(this.mCurState);
return fragmentStateManager2;
}
/* access modifiers changed from: package-private */
public FragmentStateManager addFragment(Fragment fragment) {
if (fragment.mPreviousWho != null) {
FragmentStrictMode.onFragmentReuse(fragment, fragment.mPreviousWho);
}
if (isLoggingEnabled(2)) {
Log.v(TAG, "add: " + fragment);
}
FragmentStateManager createOrGetFragmentStateManager = createOrGetFragmentStateManager(fragment);
fragment.mFragmentManager = this;
this.mFragmentStore.makeActive(createOrGetFragmentStateManager);
if (!fragment.mDetached) {
this.mFragmentStore.addFragment(fragment);
fragment.mRemoving = false;
if (fragment.mView == null) {
fragment.mHiddenChanged = false;
}
if (isMenuAvailable(fragment)) {
this.mNeedMenuInvalidate = true;
}
}
return createOrGetFragmentStateManager;
}
/* access modifiers changed from: package-private */
public void removeFragment(Fragment fragment) {
if (isLoggingEnabled(2)) {
Log.v(TAG, "remove: " + fragment + " nesting=" + fragment.mBackStackNesting);
}
boolean z = !fragment.isInBackStack();
if (!fragment.mDetached || z) {
this.mFragmentStore.removeFragment(fragment);
if (isMenuAvailable(fragment)) {
this.mNeedMenuInvalidate = true;
}
fragment.mRemoving = true;
setVisibleRemovingFragment(fragment);
}
}
/* access modifiers changed from: package-private */
public void hideFragment(Fragment fragment) {
if (isLoggingEnabled(2)) {
Log.v(TAG, "hide: " + fragment);
}
if (!fragment.mHidden) {
fragment.mHidden = true;
fragment.mHiddenChanged = true ^ fragment.mHiddenChanged;
setVisibleRemovingFragment(fragment);
}
}
/* access modifiers changed from: package-private */
public void showFragment(Fragment fragment) {
if (isLoggingEnabled(2)) {
Log.v(TAG, "show: " + fragment);
}
if (fragment.mHidden) {
fragment.mHidden = false;
fragment.mHiddenChanged = !fragment.mHiddenChanged;
}
}
/* access modifiers changed from: package-private */
public void detachFragment(Fragment fragment) {
if (isLoggingEnabled(2)) {
Log.v(TAG, "detach: " + fragment);
}
if (!fragment.mDetached) {
fragment.mDetached = true;
if (fragment.mAdded) {
if (isLoggingEnabled(2)) {
Log.v(TAG, "remove from detach: " + fragment);
}
this.mFragmentStore.removeFragment(fragment);
if (isMenuAvailable(fragment)) {
this.mNeedMenuInvalidate = true;
}
setVisibleRemovingFragment(fragment);
}
}
}
/* access modifiers changed from: package-private */
public void attachFragment(Fragment fragment) {
if (isLoggingEnabled(2)) {
Log.v(TAG, "attach: " + fragment);
}
if (fragment.mDetached) {
fragment.mDetached = false;
if (!fragment.mAdded) {
this.mFragmentStore.addFragment(fragment);
if (isLoggingEnabled(2)) {
Log.v(TAG, "add from attach: " + fragment);
}
if (isMenuAvailable(fragment)) {
this.mNeedMenuInvalidate = true;
}
}
}
}
public Fragment findFragmentById(int i) {
return this.mFragmentStore.findFragmentById(i);
}
public Fragment findFragmentByTag(String str) {
return this.mFragmentStore.findFragmentByTag(str);
}
/* access modifiers changed from: package-private */
public Fragment findFragmentByWho(String str) {
return this.mFragmentStore.findFragmentByWho(str);
}
/* access modifiers changed from: package-private */
public Fragment findActiveFragment(String str) {
return this.mFragmentStore.findActiveFragment(str);
}
private void checkStateLoss() {
if (isStateSaved()) {
throw new IllegalStateException("Can not perform this action after onSaveInstanceState");
}
}
public boolean isStateSaved() {
return this.mStateSaved || this.mStopped;
}
/* access modifiers changed from: package-private */
public void enqueueAction(OpGenerator opGenerator, boolean z) {
if (!z) {
if (this.mHost != null) {
checkStateLoss();
} else if (this.mDestroyed) {
throw new IllegalStateException("FragmentManager has been destroyed");
} else {
throw new IllegalStateException("FragmentManager has not been attached to a host.");
}
}
synchronized (this.mPendingActions) {
if (this.mHost != null) {
this.mPendingActions.add(opGenerator);
scheduleCommit();
} else if (!z) {
throw new IllegalStateException("Activity has been destroyed");
}
}
}
/* access modifiers changed from: package-private */
public void scheduleCommit() {
synchronized (this.mPendingActions) {
boolean z = true;
if (this.mPendingActions.size() != 1) {
z = false;
}
if (z) {
this.mHost.getHandler().removeCallbacks(this.mExecCommit);
this.mHost.getHandler().post(this.mExecCommit);
updateOnBackPressedCallbackEnabled();
}
}
}
/* access modifiers changed from: package-private */
public int allocBackStackIndex() {
return this.mBackStackIndex.getAndIncrement();
}
private void ensureExecReady(boolean z) {
if (this.mExecutingActions) {
throw new IllegalStateException("FragmentManager is already executing transactions");
} else if (this.mHost == null) {
if (this.mDestroyed) {
throw new IllegalStateException("FragmentManager has been destroyed");
}
throw new IllegalStateException("FragmentManager has not been attached to a host.");
} else if (Looper.myLooper() == this.mHost.getHandler().getLooper()) {
if (!z) {
checkStateLoss();
}
if (this.mTmpRecords == null) {
this.mTmpRecords = new ArrayList<>();
this.mTmpIsPop = new ArrayList<>();
}
} else {
throw new IllegalStateException("Must be called from main thread of fragment host");
}
}
/* access modifiers changed from: package-private */
public void execSingleAction(OpGenerator opGenerator, boolean z) {
if (!z || (this.mHost != null && !this.mDestroyed)) {
ensureExecReady(z);
if (opGenerator.generateOps(this.mTmpRecords, this.mTmpIsPop)) {
this.mExecutingActions = true;
try {
removeRedundantOperationsAndExecute(this.mTmpRecords, this.mTmpIsPop);
} finally {
cleanupExec();
}
}
updateOnBackPressedCallbackEnabled();
doPendingDeferredStart();
this.mFragmentStore.burpActive();
}
}
private void cleanupExec() {
this.mExecutingActions = false;
this.mTmpIsPop.clear();
this.mTmpRecords.clear();
}
/* JADX INFO: finally extract failed */
/* access modifiers changed from: package-private */
public boolean execPendingActions(boolean z) {
ensureExecReady(z);
boolean z2 = false;
while (generateOpsForPendingActions(this.mTmpRecords, this.mTmpIsPop)) {
this.mExecutingActions = true;
try {
removeRedundantOperationsAndExecute(this.mTmpRecords, this.mTmpIsPop);
cleanupExec();
z2 = true;
} catch (Throwable th) {
cleanupExec();
throw th;
}
}
updateOnBackPressedCallbackEnabled();
doPendingDeferredStart();
this.mFragmentStore.burpActive();
return z2;
}
private void removeRedundantOperationsAndExecute(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2) {
if (!arrayList.isEmpty()) {
if (arrayList.size() == arrayList2.size()) {
int size = arrayList.size();
int i = 0;
int i2 = 0;
while (i < size) {
if (!arrayList.get(i).mReorderingAllowed) {
if (i2 != i) {
executeOpsTogether(arrayList, arrayList2, i2, i);
}
i2 = i + 1;
if (arrayList2.get(i).booleanValue()) {
while (i2 < size && arrayList2.get(i2).booleanValue() && !arrayList.get(i2).mReorderingAllowed) {
i2++;
}
}
executeOpsTogether(arrayList, arrayList2, i, i2);
i = i2 - 1;
}
i++;
}
if (i2 != size) {
executeOpsTogether(arrayList, arrayList2, i2, size);
return;
}
return;
}
throw new IllegalStateException("Internal error with the back stack records");
}
}
private void executeOpsTogether(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2, int i, int i2) {
boolean z = arrayList.get(i).mReorderingAllowed;
ArrayList<Fragment> arrayList3 = this.mTmpAddedFragments;
if (arrayList3 == null) {
this.mTmpAddedFragments = new ArrayList<>();
} else {
arrayList3.clear();
}
this.mTmpAddedFragments.addAll(this.mFragmentStore.getFragments());
Fragment primaryNavigationFragment = getPrimaryNavigationFragment();
boolean z2 = false;
for (int i3 = i; i3 < i2; i3++) {
BackStackRecord backStackRecord = arrayList.get(i3);
if (!arrayList2.get(i3).booleanValue()) {
primaryNavigationFragment = backStackRecord.expandOps(this.mTmpAddedFragments, primaryNavigationFragment);
} else {
primaryNavigationFragment = backStackRecord.trackAddedFragmentsInPop(this.mTmpAddedFragments, primaryNavigationFragment);
}
z2 = z2 || backStackRecord.mAddToBackStack;
}
this.mTmpAddedFragments.clear();
if (!z && this.mCurState >= 1) {
for (int i4 = i; i4 < i2; i4++) {
Iterator it = arrayList.get(i4).mOps.iterator();
while (it.hasNext()) {
Fragment fragment = ((FragmentTransaction.Op) it.next()).mFragment;
if (!(fragment == null || fragment.mFragmentManager == null)) {
this.mFragmentStore.makeActive(createOrGetFragmentStateManager(fragment));
}
}
}
}
executeOps(arrayList, arrayList2, i, i2);
boolean booleanValue = arrayList2.get(i2 - 1).booleanValue();
for (int i5 = i; i5 < i2; i5++) {
BackStackRecord backStackRecord2 = arrayList.get(i5);
if (booleanValue) {
for (int size = backStackRecord2.mOps.size() - 1; size >= 0; size--) {
Fragment fragment2 = ((FragmentTransaction.Op) backStackRecord2.mOps.get(size)).mFragment;
if (fragment2 != null) {
createOrGetFragmentStateManager(fragment2).moveToExpectedState();
}
}
} else {
Iterator it2 = backStackRecord2.mOps.iterator();
while (it2.hasNext()) {
Fragment fragment3 = ((FragmentTransaction.Op) it2.next()).mFragment;
if (fragment3 != null) {
createOrGetFragmentStateManager(fragment3).moveToExpectedState();
}
}
}
}
moveToState(this.mCurState, true);
for (SpecialEffectsController next : collectChangedControllers(arrayList, i, i2)) {
next.updateOperationDirection(booleanValue);
next.markPostponedState();
next.executePendingOperations();
}
while (i < i2) {
BackStackRecord backStackRecord3 = arrayList.get(i);
if (arrayList2.get(i).booleanValue() && backStackRecord3.mIndex >= 0) {
backStackRecord3.mIndex = -1;
}
backStackRecord3.runOnCommitRunnables();
i++;
}
if (z2) {
reportBackStackChanged();
}
}
private Set<SpecialEffectsController> collectChangedControllers(ArrayList<BackStackRecord> arrayList, int i, int i2) {
ViewGroup viewGroup;
HashSet hashSet = new HashSet();
while (i < i2) {
Iterator it = arrayList.get(i).mOps.iterator();
while (it.hasNext()) {
Fragment fragment = ((FragmentTransaction.Op) it.next()).mFragment;
if (!(fragment == null || (viewGroup = fragment.mContainer) == null)) {
hashSet.add(SpecialEffectsController.getOrCreateController(viewGroup, this));
}
}
i++;
}
return hashSet;
}
private static void executeOps(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2, int i, int i2) {
while (i < i2) {
BackStackRecord backStackRecord = arrayList.get(i);
if (arrayList2.get(i).booleanValue()) {
backStackRecord.bumpBackStackNesting(-1);
backStackRecord.executePopOps();
} else {
backStackRecord.bumpBackStackNesting(1);
backStackRecord.executeOps();
}
i++;
}
}
private void setVisibleRemovingFragment(Fragment fragment) {
ViewGroup fragmentContainer = getFragmentContainer(fragment);
if (fragmentContainer != null && fragment.getEnterAnim() + fragment.getExitAnim() + fragment.getPopEnterAnim() + fragment.getPopExitAnim() > 0) {
if (fragmentContainer.getTag(R.id.visible_removing_fragment_view_tag) == null) {
fragmentContainer.setTag(R.id.visible_removing_fragment_view_tag, fragment);
}
((Fragment) fragmentContainer.getTag(R.id.visible_removing_fragment_view_tag)).setPopDirection(fragment.getPopDirection());
}
}
private ViewGroup getFragmentContainer(Fragment fragment) {
if (fragment.mContainer != null) {
return fragment.mContainer;
}
if (fragment.mContainerId > 0 && this.mContainer.onHasView()) {
View onFindViewById = this.mContainer.onFindViewById(fragment.mContainerId);
if (onFindViewById instanceof ViewGroup) {
return (ViewGroup) onFindViewById;
}
}
return null;
}
private void forcePostponedTransactions() {
for (SpecialEffectsController forcePostponedExecutePendingOperations : collectAllSpecialEffectsController()) {
forcePostponedExecutePendingOperations.forcePostponedExecutePendingOperations();
}
}
private void endAnimatingAwayFragments() {
for (SpecialEffectsController forceCompleteAllOperations : collectAllSpecialEffectsController()) {
forceCompleteAllOperations.forceCompleteAllOperations();
}
}
private Set<SpecialEffectsController> collectAllSpecialEffectsController() {
HashSet hashSet = new HashSet();
for (FragmentStateManager fragment : this.mFragmentStore.getActiveFragmentStateManagers()) {
ViewGroup viewGroup = fragment.getFragment().mContainer;
if (viewGroup != null) {
hashSet.add(SpecialEffectsController.getOrCreateController(viewGroup, getSpecialEffectsControllerFactory()));
}
}
return hashSet;
}
private boolean generateOpsForPendingActions(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2) {
synchronized (this.mPendingActions) {
if (this.mPendingActions.isEmpty()) {
return false;
}
try {
int size = this.mPendingActions.size();
boolean z = false;
for (int i = 0; i < size; i++) {
z |= this.mPendingActions.get(i).generateOps(arrayList, arrayList2);
}
return z;
} finally {
this.mPendingActions.clear();
this.mHost.getHandler().removeCallbacks(this.mExecCommit);
}
}
}
private void doPendingDeferredStart() {
if (this.mHavePendingDeferredStart) {
this.mHavePendingDeferredStart = false;
startPendingDeferredFragments();
}
}
private void reportBackStackChanged() {
if (this.mBackStackChangeListeners != null) {
for (int i = 0; i < this.mBackStackChangeListeners.size(); i++) {
this.mBackStackChangeListeners.get(i).onBackStackChanged();
}
}
}
/* access modifiers changed from: package-private */
public void addBackStackState(BackStackRecord backStackRecord) {
if (this.mBackStack == null) {
this.mBackStack = new ArrayList<>();
}
this.mBackStack.add(backStackRecord);
}
/* access modifiers changed from: package-private */
public boolean restoreBackStackState(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2, String str) {
BackStackState remove = this.mBackStackStates.remove(str);
if (remove == null) {
return false;
}
HashMap hashMap = new HashMap();
Iterator<BackStackRecord> it = arrayList.iterator();
while (it.hasNext()) {
BackStackRecord next = it.next();
if (next.mBeingSaved) {
Iterator it2 = next.mOps.iterator();
while (it2.hasNext()) {
FragmentTransaction.Op op = (FragmentTransaction.Op) it2.next();
if (op.mFragment != null) {
hashMap.put(op.mFragment.mWho, op.mFragment);
}
}
}
}
Iterator<BackStackRecord> it3 = remove.instantiate(this, hashMap).iterator();
while (true) {
boolean z = false;
while (true) {
if (!it3.hasNext()) {
return z;
}
if (it3.next().generateOps(arrayList, arrayList2) || z) {
z = true;
}
}
}
}
/* access modifiers changed from: package-private */
public boolean saveBackStackState(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2, String str) {
String str2;
String str3 = str;
int findBackStackIndex = findBackStackIndex(str3, -1, true);
if (findBackStackIndex < 0) {
return false;
}
for (int i = findBackStackIndex; i < this.mBackStack.size(); i++) {
BackStackRecord backStackRecord = this.mBackStack.get(i);
if (!backStackRecord.mReorderingAllowed) {
throwException(new IllegalArgumentException("saveBackStack(\"" + str3 + "\") included FragmentTransactions must use setReorderingAllowed(true) to ensure that the back stack can be restored as an atomic operation. Found " + backStackRecord + " that did not use setReorderingAllowed(true)."));
}
}
HashSet hashSet = new HashSet();
for (int i2 = findBackStackIndex; i2 < this.mBackStack.size(); i2++) {
BackStackRecord backStackRecord2 = this.mBackStack.get(i2);
HashSet hashSet2 = new HashSet();
HashSet hashSet3 = new HashSet();
Iterator it = backStackRecord2.mOps.iterator();
while (it.hasNext()) {
FragmentTransaction.Op op = (FragmentTransaction.Op) it.next();
Fragment fragment = op.mFragment;
if (fragment != null) {
if (!op.mFromExpandedOp || op.mCmd == 1 || op.mCmd == 2 || op.mCmd == 8) {
hashSet.add(fragment);
hashSet2.add(fragment);
}
if (op.mCmd == 1 || op.mCmd == 2) {
hashSet3.add(fragment);
}
}
}
hashSet2.removeAll(hashSet3);
if (!hashSet2.isEmpty()) {
StringBuilder sb = new StringBuilder();
sb.append("saveBackStack(\"");
sb.append(str3);
sb.append("\") must be self contained and not reference fragments from non-saved FragmentTransactions. Found reference to fragment");
if (hashSet2.size() == 1) {
str2 = " " + hashSet2.iterator().next();
} else {
str2 = "s " + hashSet2;
}
sb.append(str2);
sb.append(" in ");
sb.append(backStackRecord2);
sb.append(" that were previously added to the FragmentManager through a separate FragmentTransaction.");
throwException(new IllegalArgumentException(sb.toString()));
}
}
ArrayDeque arrayDeque = new ArrayDeque(hashSet);
while (!arrayDeque.isEmpty()) {
Fragment fragment2 = (Fragment) arrayDeque.removeFirst();
if (fragment2.mRetainInstance) {
StringBuilder sb2 = new StringBuilder();
sb2.append("saveBackStack(\"");
sb2.append(str3);
sb2.append("\") must not contain retained fragments. Found ");
sb2.append(hashSet.contains(fragment2) ? "direct reference to retained " : "retained child ");
sb2.append("fragment ");
sb2.append(fragment2);
throwException(new IllegalArgumentException(sb2.toString()));
}
for (Fragment next : fragment2.mChildFragmentManager.getActiveFragments()) {
if (next != null) {
arrayDeque.addLast(next);
}
}
}
ArrayList arrayList3 = new ArrayList();
Iterator it2 = hashSet.iterator();
while (it2.hasNext()) {
arrayList3.add(((Fragment) it2.next()).mWho);
}
ArrayList arrayList4 = new ArrayList(this.mBackStack.size() - findBackStackIndex);
for (int i3 = findBackStackIndex; i3 < this.mBackStack.size(); i3++) {
arrayList4.add((Object) null);
}
BackStackState backStackState = new BackStackState(arrayList3, arrayList4);
for (int size = this.mBackStack.size() - 1; size >= findBackStackIndex; size--) {
BackStackRecord remove = this.mBackStack.remove(size);
BackStackRecord backStackRecord3 = new BackStackRecord(remove);
backStackRecord3.collapseOps();
arrayList4.set(size - findBackStackIndex, new BackStackRecordState(backStackRecord3));
remove.mBeingSaved = true;
arrayList.add(remove);
arrayList2.add(true);
}
this.mBackStackStates.put(str3, backStackState);
return true;
}
/* access modifiers changed from: package-private */
public boolean clearBackStackState(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2, String str) {
if (!restoreBackStackState(arrayList, arrayList2, str)) {
return false;
}
return popBackStackState(arrayList, arrayList2, str, -1, 1);
}
/* access modifiers changed from: package-private */
public boolean popBackStackState(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2, String str, int i, int i2) {
int findBackStackIndex = findBackStackIndex(str, i, (i2 & 1) != 0);
if (findBackStackIndex < 0) {
return false;
}
for (int size = this.mBackStack.size() - 1; size >= findBackStackIndex; size--) {
arrayList.add(this.mBackStack.remove(size));
arrayList2.add(true);
}
return true;
}
private int findBackStackIndex(String str, int i, boolean z) {
ArrayList<BackStackRecord> arrayList = this.mBackStack;
if (arrayList == null || arrayList.isEmpty()) {
return -1;
}
if (str != null || i >= 0) {
int size = this.mBackStack.size() - 1;
while (size >= 0) {
BackStackRecord backStackRecord = this.mBackStack.get(size);
if ((str != null && str.equals(backStackRecord.getName())) || (i >= 0 && i == backStackRecord.mIndex)) {
break;
}
size--;
}
if (size < 0) {
return size;
}
if (z) {
while (size > 0) {
BackStackRecord backStackRecord2 = this.mBackStack.get(size - 1);
if ((str == null || !str.equals(backStackRecord2.getName())) && (i < 0 || i != backStackRecord2.mIndex)) {
return size;
}
size--;
}
return size;
} else if (size == this.mBackStack.size() - 1) {
return -1;
} else {
return size + 1;
}
} else if (z) {
return 0;
} else {
return this.mBackStack.size() - 1;
}
}
/* access modifiers changed from: package-private */
@Deprecated
public FragmentManagerNonConfig retainNonConfig() {
if (this.mHost instanceof ViewModelStoreOwner) {
throwException(new IllegalStateException("You cannot use retainNonConfig when your FragmentHostCallback implements ViewModelStoreOwner."));
}
return this.mNonConfig.getSnapshot();
}
/* access modifiers changed from: package-private */
public Parcelable saveAllState() {
if (this.mHost instanceof SavedStateRegistryOwner) {
throwException(new IllegalStateException("You cannot use saveAllState when your FragmentHostCallback implements SavedStateRegistryOwner."));
}
return saveAllStateInternal();
}
/* access modifiers changed from: package-private */
public Parcelable saveAllStateInternal() {
int size;
forcePostponedTransactions();
endAnimatingAwayFragments();
execPendingActions(true);
this.mStateSaved = true;
this.mNonConfig.setIsStateSaved(true);
ArrayList<String> saveActiveFragments = this.mFragmentStore.saveActiveFragments();
ArrayList<FragmentState> allSavedState = this.mFragmentStore.getAllSavedState();
BackStackRecordState[] backStackRecordStateArr = null;
if (allSavedState.isEmpty()) {
if (isLoggingEnabled(2)) {
Log.v(TAG, "saveAllState: no fragments!");
}
return null;
}
ArrayList<String> saveAddedFragments = this.mFragmentStore.saveAddedFragments();
ArrayList<BackStackRecord> arrayList = this.mBackStack;
if (arrayList != null && (size = arrayList.size()) > 0) {
backStackRecordStateArr = new BackStackRecordState[size];
for (int i = 0; i < size; i++) {
backStackRecordStateArr[i] = new BackStackRecordState(this.mBackStack.get(i));
if (isLoggingEnabled(2)) {
Log.v(TAG, "saveAllState: adding back stack #" + i + ": " + this.mBackStack.get(i));
}
}
}
FragmentManagerState fragmentManagerState = new FragmentManagerState();
fragmentManagerState.mSavedState = allSavedState;
fragmentManagerState.mActive = saveActiveFragments;
fragmentManagerState.mAdded = saveAddedFragments;
fragmentManagerState.mBackStack = backStackRecordStateArr;
fragmentManagerState.mBackStackIndex = this.mBackStackIndex.get();
Fragment fragment = this.mPrimaryNav;
if (fragment != null) {
fragmentManagerState.mPrimaryNavActiveWho = fragment.mWho;
}
fragmentManagerState.mBackStackStateKeys.addAll(this.mBackStackStates.keySet());
fragmentManagerState.mBackStackStates.addAll(this.mBackStackStates.values());
fragmentManagerState.mResultKeys.addAll(this.mResults.keySet());
fragmentManagerState.mResults.addAll(this.mResults.values());
fragmentManagerState.mLaunchedFragments = new ArrayList<>(this.mLaunchedFragments);
return fragmentManagerState;
}
/* access modifiers changed from: package-private */
public void restoreAllState(Parcelable parcelable, FragmentManagerNonConfig fragmentManagerNonConfig) {
if (this.mHost instanceof ViewModelStoreOwner) {
throwException(new IllegalStateException("You must use restoreSaveState when your FragmentHostCallback implements ViewModelStoreOwner"));
}
this.mNonConfig.restoreFromSnapshot(fragmentManagerNonConfig);
restoreSaveStateInternal(parcelable);
}
/* access modifiers changed from: package-private */
public void restoreSaveState(Parcelable parcelable) {
if (this.mHost instanceof SavedStateRegistryOwner) {
throwException(new IllegalStateException("You cannot use restoreSaveState when your FragmentHostCallback implements SavedStateRegistryOwner."));
}
restoreSaveStateInternal(parcelable);
}
/* access modifiers changed from: package-private */
public void restoreSaveStateInternal(Parcelable parcelable) {
FragmentStateManager fragmentStateManager;
if (parcelable != null) {
FragmentManagerState fragmentManagerState = (FragmentManagerState) parcelable;
if (fragmentManagerState.mSavedState != null) {
this.mFragmentStore.restoreSaveState(fragmentManagerState.mSavedState);
this.mFragmentStore.resetActiveFragments();
Iterator<String> it = fragmentManagerState.mActive.iterator();
while (it.hasNext()) {
FragmentState savedState = this.mFragmentStore.setSavedState(it.next(), (FragmentState) null);
if (savedState != null) {
Fragment findRetainedFragmentByWho = this.mNonConfig.findRetainedFragmentByWho(savedState.mWho);
if (findRetainedFragmentByWho != null) {
if (isLoggingEnabled(2)) {
Log.v(TAG, "restoreSaveState: re-attaching retained " + findRetainedFragmentByWho);
}
fragmentStateManager = new FragmentStateManager(this.mLifecycleCallbacksDispatcher, this.mFragmentStore, findRetainedFragmentByWho, savedState);
} else {
fragmentStateManager = new FragmentStateManager(this.mLifecycleCallbacksDispatcher, this.mFragmentStore, this.mHost.getContext().getClassLoader(), getFragmentFactory(), savedState);
}
Fragment fragment = fragmentStateManager.getFragment();
fragment.mFragmentManager = this;
if (isLoggingEnabled(2)) {
Log.v(TAG, "restoreSaveState: active (" + fragment.mWho + "): " + fragment);
}
fragmentStateManager.restoreState(this.mHost.getContext().getClassLoader());
this.mFragmentStore.makeActive(fragmentStateManager);
fragmentStateManager.setFragmentManagerState(this.mCurState);
}
}
for (Fragment next : this.mNonConfig.getRetainedFragments()) {
if (!this.mFragmentStore.containsActiveFragment(next.mWho)) {
if (isLoggingEnabled(2)) {
Log.v(TAG, "Discarding retained Fragment " + next + " that was not found in the set of active Fragments " + fragmentManagerState.mActive);
}
this.mNonConfig.removeRetainedFragment(next);
next.mFragmentManager = this;
FragmentStateManager fragmentStateManager2 = new FragmentStateManager(this.mLifecycleCallbacksDispatcher, this.mFragmentStore, next);
fragmentStateManager2.setFragmentManagerState(1);
fragmentStateManager2.moveToExpectedState();
next.mRemoving = true;
fragmentStateManager2.moveToExpectedState();
}
}
this.mFragmentStore.restoreAddedFragments(fragmentManagerState.mAdded);
if (fragmentManagerState.mBackStack != null) {
this.mBackStack = new ArrayList<>(fragmentManagerState.mBackStack.length);
for (int i = 0; i < fragmentManagerState.mBackStack.length; i++) {
BackStackRecord instantiate = fragmentManagerState.mBackStack[i].instantiate(this);
if (isLoggingEnabled(2)) {
Log.v(TAG, "restoreAllState: back stack #" + i + " (index " + instantiate.mIndex + "): " + instantiate);
PrintWriter printWriter = new PrintWriter(new LogWriter(TAG));
instantiate.dump(" ", printWriter, false);
printWriter.close();
}
this.mBackStack.add(instantiate);
}
} else {
this.mBackStack = null;
}
this.mBackStackIndex.set(fragmentManagerState.mBackStackIndex);
if (fragmentManagerState.mPrimaryNavActiveWho != null) {
Fragment findActiveFragment = findActiveFragment(fragmentManagerState.mPrimaryNavActiveWho);
this.mPrimaryNav = findActiveFragment;
dispatchParentPrimaryNavigationFragmentChanged(findActiveFragment);
}
ArrayList<String> arrayList = fragmentManagerState.mBackStackStateKeys;
if (arrayList != null) {
for (int i2 = 0; i2 < arrayList.size(); i2++) {
this.mBackStackStates.put(arrayList.get(i2), fragmentManagerState.mBackStackStates.get(i2));
}
}
ArrayList<String> arrayList2 = fragmentManagerState.mResultKeys;
if (arrayList2 != null) {
for (int i3 = 0; i3 < arrayList2.size(); i3++) {
Bundle bundle = fragmentManagerState.mResults.get(i3);
bundle.setClassLoader(this.mHost.getContext().getClassLoader());
this.mResults.put(arrayList2.get(i3), bundle);
}
}
this.mLaunchedFragments = new ArrayDeque<>(fragmentManagerState.mLaunchedFragments);
}
}
}
public FragmentHostCallback<?> getHost() {
return this.mHost;
}
/* access modifiers changed from: package-private */
public Fragment getParent() {
return this.mParent;
}
/* access modifiers changed from: package-private */
public FragmentContainer getContainer() {
return this.mContainer;
}
/* access modifiers changed from: package-private */
public FragmentStore getFragmentStore() {
return this.mFragmentStore;
}
/* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r4v19, resolved type: androidx.activity.OnBackPressedDispatcherOwner} */
/* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r4v20, resolved type: androidx.fragment.app.Fragment} */
/* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r4v21, resolved type: androidx.fragment.app.Fragment} */
/* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r4v26, resolved type: androidx.fragment.app.Fragment} */
/* access modifiers changed from: package-private */
/* JADX WARNING: Multi-variable type inference failed */
/* Code decompiled incorrectly, please refer to instructions dump. */
public void attachController(androidx.fragment.app.FragmentHostCallback<?> r3, androidx.fragment.app.FragmentContainer r4, final androidx.fragment.app.Fragment r5) {
/*
r2 = this;
androidx.fragment.app.FragmentHostCallback<?> r0 = r2.mHost
if (r0 != 0) goto L_0x012d
r2.mHost = r3
r2.mContainer = r4
r2.mParent = r5
if (r5 == 0) goto L_0x0015
androidx.fragment.app.FragmentManager$6 r4 = new androidx.fragment.app.FragmentManager$6
r4.<init>(r5)
r2.addFragmentOnAttachListener(r4)
goto L_0x001f
L_0x0015:
boolean r4 = r3 instanceof androidx.fragment.app.FragmentOnAttachListener
if (r4 == 0) goto L_0x001f
r4 = r3
androidx.fragment.app.FragmentOnAttachListener r4 = (androidx.fragment.app.FragmentOnAttachListener) r4
r2.addFragmentOnAttachListener(r4)
L_0x001f:
androidx.fragment.app.Fragment r4 = r2.mParent
if (r4 == 0) goto L_0x0026
r2.updateOnBackPressedCallbackEnabled()
L_0x0026:
boolean r4 = r3 instanceof androidx.activity.OnBackPressedDispatcherOwner
if (r4 == 0) goto L_0x003b
r4 = r3
androidx.activity.OnBackPressedDispatcherOwner r4 = (androidx.activity.OnBackPressedDispatcherOwner) r4
androidx.activity.OnBackPressedDispatcher r0 = r4.getOnBackPressedDispatcher()
r2.mOnBackPressedDispatcher = r0
if (r5 == 0) goto L_0x0036
r4 = r5
L_0x0036:
androidx.activity.OnBackPressedCallback r1 = r2.mOnBackPressedCallback
r0.addCallback(r4, r1)
L_0x003b:
if (r5 == 0) goto L_0x0046
androidx.fragment.app.FragmentManager r3 = r5.mFragmentManager
androidx.fragment.app.FragmentManagerViewModel r3 = r3.getChildNonConfig(r5)
r2.mNonConfig = r3
goto L_0x005f
L_0x0046:
boolean r4 = r3 instanceof androidx.lifecycle.ViewModelStoreOwner
if (r4 == 0) goto L_0x0057
androidx.lifecycle.ViewModelStoreOwner r3 = (androidx.lifecycle.ViewModelStoreOwner) r3
androidx.lifecycle.ViewModelStore r3 = r3.getViewModelStore()
androidx.fragment.app.FragmentManagerViewModel r3 = androidx.fragment.app.FragmentManagerViewModel.getInstance(r3)
r2.mNonConfig = r3
goto L_0x005f
L_0x0057:
androidx.fragment.app.FragmentManagerViewModel r3 = new androidx.fragment.app.FragmentManagerViewModel
r4 = 0
r3.<init>(r4)
r2.mNonConfig = r3
L_0x005f:
androidx.fragment.app.FragmentManagerViewModel r3 = r2.mNonConfig
boolean r4 = r2.isStateSaved()
r3.setIsStateSaved(r4)
androidx.fragment.app.FragmentStore r3 = r2.mFragmentStore
androidx.fragment.app.FragmentManagerViewModel r4 = r2.mNonConfig
r3.setNonConfig(r4)
androidx.fragment.app.FragmentHostCallback<?> r3 = r2.mHost
boolean r4 = r3 instanceof androidx.savedstate.SavedStateRegistryOwner
if (r4 == 0) goto L_0x0094
if (r5 != 0) goto L_0x0094
androidx.savedstate.SavedStateRegistryOwner r3 = (androidx.savedstate.SavedStateRegistryOwner) r3
androidx.savedstate.SavedStateRegistry r3 = r3.getSavedStateRegistry()
androidx.fragment.app.FragmentManager$$ExternalSyntheticLambda0 r4 = new androidx.fragment.app.FragmentManager$$ExternalSyntheticLambda0
r4.<init>(r2)
java.lang.String r0 = "android:support:fragments"
r3.registerSavedStateProvider(r0, r4)
android.os.Bundle r3 = r3.consumeRestoredStateForKey(r0)
if (r3 == 0) goto L_0x0094
android.os.Parcelable r3 = r3.getParcelable(r0)
r2.restoreSaveStateInternal(r3)
L_0x0094:
androidx.fragment.app.FragmentHostCallback<?> r3 = r2.mHost
boolean r4 = r3 instanceof androidx.activity.result.ActivityResultRegistryOwner
if (r4 == 0) goto L_0x012c
androidx.activity.result.ActivityResultRegistryOwner r3 = (androidx.activity.result.ActivityResultRegistryOwner) r3
androidx.activity.result.ActivityResultRegistry r3 = r3.getActivityResultRegistry()
if (r5 == 0) goto L_0x00b6
java.lang.StringBuilder r4 = new java.lang.StringBuilder
r4.<init>()
java.lang.String r5 = r5.mWho
r4.append(r5)
java.lang.String r5 = ":"
r4.append(r5)
java.lang.String r4 = r4.toString()
goto L_0x00b8
L_0x00b6:
java.lang.String r4 = ""
L_0x00b8:
java.lang.StringBuilder r5 = new java.lang.StringBuilder
r5.<init>()
java.lang.String r0 = "FragmentManager:"
r5.append(r0)
r5.append(r4)
java.lang.String r4 = r5.toString()
java.lang.StringBuilder r5 = new java.lang.StringBuilder
r5.<init>()
r5.append(r4)
java.lang.String r0 = "StartActivityForResult"
r5.append(r0)
java.lang.String r5 = r5.toString()
androidx.activity.result.contract.ActivityResultContracts$StartActivityForResult r0 = new androidx.activity.result.contract.ActivityResultContracts$StartActivityForResult
r0.<init>()
androidx.fragment.app.FragmentManager$7 r1 = new androidx.fragment.app.FragmentManager$7
r1.<init>()
androidx.activity.result.ActivityResultLauncher r5 = r3.register(r5, r0, r1)
r2.mStartActivityForResult = r5
java.lang.StringBuilder r5 = new java.lang.StringBuilder
r5.<init>()
r5.append(r4)
java.lang.String r0 = "StartIntentSenderForResult"
r5.append(r0)
java.lang.String r5 = r5.toString()
androidx.fragment.app.FragmentManager$FragmentIntentSenderContract r0 = new androidx.fragment.app.FragmentManager$FragmentIntentSenderContract
r0.<init>()
androidx.fragment.app.FragmentManager$8 r1 = new androidx.fragment.app.FragmentManager$8
r1.<init>()
androidx.activity.result.ActivityResultLauncher r5 = r3.register(r5, r0, r1)
r2.mStartIntentSenderForResult = r5
java.lang.StringBuilder r5 = new java.lang.StringBuilder
r5.<init>()
r5.append(r4)
java.lang.String r4 = "RequestPermissions"
r5.append(r4)
java.lang.String r4 = r5.toString()
androidx.activity.result.contract.ActivityResultContracts$RequestMultiplePermissions r5 = new androidx.activity.result.contract.ActivityResultContracts$RequestMultiplePermissions
r5.<init>()
androidx.fragment.app.FragmentManager$9 r0 = new androidx.fragment.app.FragmentManager$9
r0.<init>()
androidx.activity.result.ActivityResultLauncher r3 = r3.register(r4, r5, r0)
r2.mRequestPermissions = r3
L_0x012c:
return
L_0x012d:
java.lang.IllegalStateException r3 = new java.lang.IllegalStateException
java.lang.String r4 = "Already attached"
r3.<init>(r4)
throw r3
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.fragment.app.FragmentManager.attachController(androidx.fragment.app.FragmentHostCallback, androidx.fragment.app.FragmentContainer, androidx.fragment.app.Fragment):void");
}
/* access modifiers changed from: package-private */
/* renamed from: lambda$attachController$0$androidx-fragment-app-FragmentManager reason: not valid java name */
public /* synthetic */ Bundle m29lambda$attachController$0$androidxfragmentappFragmentManager() {
Bundle bundle = new Bundle();
Parcelable saveAllStateInternal = saveAllStateInternal();
if (saveAllStateInternal != null) {
bundle.putParcelable(SAVED_STATE_TAG, saveAllStateInternal);
}
return bundle;
}
/* access modifiers changed from: package-private */
public void noteStateNotSaved() {
if (this.mHost != null) {
this.mStateSaved = false;
this.mStopped = false;
this.mNonConfig.setIsStateSaved(false);
for (Fragment next : this.mFragmentStore.getFragments()) {
if (next != null) {
next.noteStateNotSaved();
}
}
}
}
/* access modifiers changed from: package-private */
public void launchStartActivityForResult(Fragment fragment, Intent intent, int i, Bundle bundle) {
if (this.mStartActivityForResult != null) {
this.mLaunchedFragments.addLast(new LaunchedFragmentInfo(fragment.mWho, i));
if (!(intent == null || bundle == null)) {
intent.putExtra(ActivityResultContracts.StartActivityForResult.EXTRA_ACTIVITY_OPTIONS_BUNDLE, bundle);
}
this.mStartActivityForResult.launch(intent);
return;
}
this.mHost.onStartActivityFromFragment(fragment, intent, i, bundle);
}
/* access modifiers changed from: package-private */
public void launchStartIntentSenderForResult(Fragment fragment, IntentSender intentSender, int i, Intent intent, int i2, int i3, int i4, Bundle bundle) throws IntentSender.SendIntentException {
Intent intent2;
Fragment fragment2 = fragment;
Bundle bundle2 = bundle;
if (this.mStartIntentSenderForResult != null) {
if (bundle2 != null) {
if (intent == null) {
intent2 = new Intent();
intent2.putExtra(EXTRA_CREATED_FILLIN_INTENT, true);
} else {
intent2 = intent;
}
if (isLoggingEnabled(2)) {
Log.v(TAG, "ActivityOptions " + bundle2 + " were added to fillInIntent " + intent2 + " for fragment " + fragment);
}
intent2.putExtra(ActivityResultContracts.StartActivityForResult.EXTRA_ACTIVITY_OPTIONS_BUNDLE, bundle2);
} else {
intent2 = intent;
}
IntentSender intentSender2 = intentSender;
IntentSenderRequest build = new IntentSenderRequest.Builder(intentSender).setFillInIntent(intent2).setFlags(i3, i2).build();
int i5 = i;
this.mLaunchedFragments.addLast(new LaunchedFragmentInfo(fragment2.mWho, i));
if (isLoggingEnabled(2)) {
Log.v(TAG, "Fragment " + fragment + "is launching an IntentSender for result ");
}
this.mStartIntentSenderForResult.launch(build);
return;
}
IntentSender intentSender3 = intentSender;
int i6 = i;
int i7 = i2;
int i8 = i3;
this.mHost.onStartIntentSenderFromFragment(fragment, intentSender, i, intent, i2, i3, i4, bundle);
}
/* access modifiers changed from: package-private */
public void launchRequestPermissions(Fragment fragment, String[] strArr, int i) {
if (this.mRequestPermissions != null) {
this.mLaunchedFragments.addLast(new LaunchedFragmentInfo(fragment.mWho, i));
this.mRequestPermissions.launch(strArr);
return;
}
this.mHost.onRequestPermissionsFromFragment(fragment, strArr, i);
}
/* access modifiers changed from: package-private */
public void dispatchAttach() {
this.mStateSaved = false;
this.mStopped = false;
this.mNonConfig.setIsStateSaved(false);
dispatchStateChange(0);
}
/* access modifiers changed from: package-private */
public void dispatchCreate() {
this.mStateSaved = false;
this.mStopped = false;
this.mNonConfig.setIsStateSaved(false);
dispatchStateChange(1);
}
/* access modifiers changed from: package-private */
public void dispatchViewCreated() {
dispatchStateChange(2);
}
/* access modifiers changed from: package-private */
public void dispatchActivityCreated() {
this.mStateSaved = false;
this.mStopped = false;
this.mNonConfig.setIsStateSaved(false);
dispatchStateChange(4);
}
/* access modifiers changed from: package-private */
public void dispatchStart() {
this.mStateSaved = false;
this.mStopped = false;
this.mNonConfig.setIsStateSaved(false);
dispatchStateChange(5);
}
/* access modifiers changed from: package-private */
public void dispatchResume() {
this.mStateSaved = false;
this.mStopped = false;
this.mNonConfig.setIsStateSaved(false);
dispatchStateChange(7);
}
/* access modifiers changed from: package-private */
public void dispatchPause() {
dispatchStateChange(5);
}
/* access modifiers changed from: package-private */
public void dispatchStop() {
this.mStopped = true;
this.mNonConfig.setIsStateSaved(true);
dispatchStateChange(4);
}
/* access modifiers changed from: package-private */
public void dispatchDestroyView() {
dispatchStateChange(1);
}
/* access modifiers changed from: package-private */
public void dispatchDestroy() {
this.mDestroyed = true;
execPendingActions(true);
endAnimatingAwayFragments();
clearBackStackStateViewModels();
dispatchStateChange(-1);
this.mHost = null;
this.mContainer = null;
this.mParent = null;
if (this.mOnBackPressedDispatcher != null) {
this.mOnBackPressedCallback.remove();
this.mOnBackPressedDispatcher = null;
}
ActivityResultLauncher<Intent> activityResultLauncher = this.mStartActivityForResult;
if (activityResultLauncher != null) {
activityResultLauncher.unregister();
this.mStartIntentSenderForResult.unregister();
this.mRequestPermissions.unregister();
}
}
/* JADX INFO: finally extract failed */
private void dispatchStateChange(int i) {
try {
this.mExecutingActions = true;
this.mFragmentStore.dispatchStateChange(i);
moveToState(i, false);
for (SpecialEffectsController forceCompleteAllOperations : collectAllSpecialEffectsController()) {
forceCompleteAllOperations.forceCompleteAllOperations();
}
this.mExecutingActions = false;
execPendingActions(true);
} catch (Throwable th) {
this.mExecutingActions = false;
throw th;
}
}
/* access modifiers changed from: package-private */
public void dispatchMultiWindowModeChanged(boolean z) {
for (Fragment next : this.mFragmentStore.getFragments()) {
if (next != null) {
next.performMultiWindowModeChanged(z);
}
}
}
/* access modifiers changed from: package-private */
public void dispatchPictureInPictureModeChanged(boolean z) {
for (Fragment next : this.mFragmentStore.getFragments()) {
if (next != null) {
next.performPictureInPictureModeChanged(z);
}
}
}
/* access modifiers changed from: package-private */
public void dispatchConfigurationChanged(Configuration configuration) {
for (Fragment next : this.mFragmentStore.getFragments()) {
if (next != null) {
next.performConfigurationChanged(configuration);
}
}
}
/* access modifiers changed from: package-private */
public void dispatchLowMemory() {
for (Fragment next : this.mFragmentStore.getFragments()) {
if (next != null) {
next.performLowMemory();
}
}
}
/* access modifiers changed from: package-private */
public boolean dispatchCreateOptionsMenu(Menu menu, MenuInflater menuInflater) {
if (this.mCurState < 1) {
return false;
}
ArrayList<Fragment> arrayList = null;
boolean z = false;
for (Fragment next : this.mFragmentStore.getFragments()) {
if (next != null && isParentMenuVisible(next) && next.performCreateOptionsMenu(menu, menuInflater)) {
if (arrayList == null) {
arrayList = new ArrayList<>();
}
arrayList.add(next);
z = true;
}
}
if (this.mCreatedMenus != null) {
for (int i = 0; i < this.mCreatedMenus.size(); i++) {
Fragment fragment = this.mCreatedMenus.get(i);
if (arrayList == null || !arrayList.contains(fragment)) {
fragment.onDestroyOptionsMenu();
}
}
}
this.mCreatedMenus = arrayList;
return z;
}
/* access modifiers changed from: package-private */
public boolean dispatchPrepareOptionsMenu(Menu menu) {
boolean z = false;
if (this.mCurState < 1) {
return false;
}
for (Fragment next : this.mFragmentStore.getFragments()) {
if (next != null && isParentMenuVisible(next) && next.performPrepareOptionsMenu(menu)) {
z = true;
}
}
return z;
}
/* access modifiers changed from: package-private */
public boolean dispatchOptionsItemSelected(MenuItem menuItem) {
if (this.mCurState < 1) {
return false;
}
for (Fragment next : this.mFragmentStore.getFragments()) {
if (next != null && next.performOptionsItemSelected(menuItem)) {
return true;
}
}
return false;
}
/* access modifiers changed from: package-private */
public boolean dispatchContextItemSelected(MenuItem menuItem) {
if (this.mCurState < 1) {
return false;
}
for (Fragment next : this.mFragmentStore.getFragments()) {
if (next != null && next.performContextItemSelected(menuItem)) {
return true;
}
}
return false;
}
/* access modifiers changed from: package-private */
public void dispatchOptionsMenuClosed(Menu menu) {
if (this.mCurState >= 1) {
for (Fragment next : this.mFragmentStore.getFragments()) {
if (next != null) {
next.performOptionsMenuClosed(menu);
}
}
}
}
/* access modifiers changed from: package-private */
public void setPrimaryNavigationFragment(Fragment fragment) {
if (fragment == null || (fragment.equals(findActiveFragment(fragment.mWho)) && (fragment.mHost == null || fragment.mFragmentManager == this))) {
Fragment fragment2 = this.mPrimaryNav;
this.mPrimaryNav = fragment;
dispatchParentPrimaryNavigationFragmentChanged(fragment2);
dispatchParentPrimaryNavigationFragmentChanged(this.mPrimaryNav);
return;
}
throw new IllegalArgumentException("Fragment " + fragment + " is not an active fragment of FragmentManager " + this);
}
private void dispatchParentPrimaryNavigationFragmentChanged(Fragment fragment) {
if (fragment != null && fragment.equals(findActiveFragment(fragment.mWho))) {
fragment.performPrimaryNavigationFragmentChanged();
}
}
/* access modifiers changed from: package-private */
public void dispatchPrimaryNavigationFragmentChanged() {
updateOnBackPressedCallbackEnabled();
dispatchParentPrimaryNavigationFragmentChanged(this.mPrimaryNav);
}
public Fragment getPrimaryNavigationFragment() {
return this.mPrimaryNav;
}
/* access modifiers changed from: package-private */
public void setMaxLifecycle(Fragment fragment, Lifecycle.State state) {
if (!fragment.equals(findActiveFragment(fragment.mWho)) || !(fragment.mHost == null || fragment.mFragmentManager == this)) {
throw new IllegalArgumentException("Fragment " + fragment + " is not an active fragment of FragmentManager " + this);
}
fragment.mMaxState = state;
}
public void setFragmentFactory(FragmentFactory fragmentFactory) {
this.mFragmentFactory = fragmentFactory;
}
public FragmentFactory getFragmentFactory() {
FragmentFactory fragmentFactory = this.mFragmentFactory;
if (fragmentFactory != null) {
return fragmentFactory;
}
Fragment fragment = this.mParent;
if (fragment != null) {
return fragment.mFragmentManager.getFragmentFactory();
}
return this.mHostFragmentFactory;
}
/* access modifiers changed from: package-private */
public void setSpecialEffectsControllerFactory(SpecialEffectsControllerFactory specialEffectsControllerFactory) {
this.mSpecialEffectsControllerFactory = specialEffectsControllerFactory;
}
/* access modifiers changed from: package-private */
public SpecialEffectsControllerFactory getSpecialEffectsControllerFactory() {
SpecialEffectsControllerFactory specialEffectsControllerFactory = this.mSpecialEffectsControllerFactory;
if (specialEffectsControllerFactory != null) {
return specialEffectsControllerFactory;
}
Fragment fragment = this.mParent;
if (fragment != null) {
return fragment.mFragmentManager.getSpecialEffectsControllerFactory();
}
return this.mDefaultSpecialEffectsControllerFactory;
}
/* access modifiers changed from: package-private */
public FragmentLifecycleCallbacksDispatcher getLifecycleCallbacksDispatcher() {
return this.mLifecycleCallbacksDispatcher;
}
public void registerFragmentLifecycleCallbacks(FragmentLifecycleCallbacks fragmentLifecycleCallbacks, boolean z) {
this.mLifecycleCallbacksDispatcher.registerFragmentLifecycleCallbacks(fragmentLifecycleCallbacks, z);
}
public void unregisterFragmentLifecycleCallbacks(FragmentLifecycleCallbacks fragmentLifecycleCallbacks) {
this.mLifecycleCallbacksDispatcher.unregisterFragmentLifecycleCallbacks(fragmentLifecycleCallbacks);
}
public void addFragmentOnAttachListener(FragmentOnAttachListener fragmentOnAttachListener) {
this.mOnAttachListeners.add(fragmentOnAttachListener);
}
/* access modifiers changed from: package-private */
public void dispatchOnAttachFragment(Fragment fragment) {
Iterator<FragmentOnAttachListener> it = this.mOnAttachListeners.iterator();
while (it.hasNext()) {
it.next().onAttachFragment(this, fragment);
}
}
public void removeFragmentOnAttachListener(FragmentOnAttachListener fragmentOnAttachListener) {
this.mOnAttachListeners.remove(fragmentOnAttachListener);
}
/* access modifiers changed from: package-private */
public void dispatchOnHiddenChanged() {
for (Fragment next : this.mFragmentStore.getActiveFragments()) {
if (next != null) {
next.onHiddenChanged(next.isHidden());
next.mChildFragmentManager.dispatchOnHiddenChanged();
}
}
}
/* access modifiers changed from: package-private */
public boolean checkForMenus() {
boolean z = false;
for (Fragment next : this.mFragmentStore.getActiveFragments()) {
if (next != null) {
z = isMenuAvailable(next);
continue;
}
if (z) {
return true;
}
}
return false;
}
private boolean isMenuAvailable(Fragment fragment) {
return (fragment.mHasMenu && fragment.mMenuVisible) || fragment.mChildFragmentManager.checkForMenus();
}
/* access modifiers changed from: package-private */
public void invalidateMenuForFragment(Fragment fragment) {
if (fragment.mAdded && isMenuAvailable(fragment)) {
this.mNeedMenuInvalidate = true;
}
}
/* access modifiers changed from: package-private */
public LayoutInflater.Factory2 getLayoutInflaterFactory() {
return this.mLayoutInflaterFactory;
}
public FragmentStrictMode.Policy getStrictModePolicy() {
return this.mStrictModePolicy;
}
public void setStrictModePolicy(FragmentStrictMode.Policy policy) {
this.mStrictModePolicy = policy;
}
private class PopBackStackState implements OpGenerator {
final int mFlags;
final int mId;
final String mName;
PopBackStackState(String str, int i, int i2) {
this.mName = str;
this.mId = i;
this.mFlags = i2;
}
public boolean generateOps(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2) {
if (FragmentManager.this.mPrimaryNav != null && this.mId < 0 && this.mName == null && FragmentManager.this.mPrimaryNav.getChildFragmentManager().popBackStackImmediate()) {
return false;
}
return FragmentManager.this.popBackStackState(arrayList, arrayList2, this.mName, this.mId, this.mFlags);
}
}
private class RestoreBackStackState implements OpGenerator {
private final String mName;
RestoreBackStackState(String str) {
this.mName = str;
}
public boolean generateOps(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2) {
return FragmentManager.this.restoreBackStackState(arrayList, arrayList2, this.mName);
}
}
private class SaveBackStackState implements OpGenerator {
private final String mName;
SaveBackStackState(String str) {
this.mName = str;
}
public boolean generateOps(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2) {
return FragmentManager.this.saveBackStackState(arrayList, arrayList2, this.mName);
}
}
private class ClearBackStackState implements OpGenerator {
private final String mName;
ClearBackStackState(String str) {
this.mName = str;
}
public boolean generateOps(ArrayList<BackStackRecord> arrayList, ArrayList<Boolean> arrayList2) {
return FragmentManager.this.clearBackStackState(arrayList, arrayList2, this.mName);
}
}
static class LaunchedFragmentInfo implements Parcelable {
public static final Parcelable.Creator<LaunchedFragmentInfo> CREATOR = new Parcelable.Creator<LaunchedFragmentInfo>() {
public LaunchedFragmentInfo createFromParcel(Parcel parcel) {
return new LaunchedFragmentInfo(parcel);
}
public LaunchedFragmentInfo[] newArray(int i) {
return new LaunchedFragmentInfo[i];
}
};
int mRequestCode;
String mWho;
public int describeContents() {
return 0;
}
LaunchedFragmentInfo(String str, int i) {
this.mWho = str;
this.mRequestCode = i;
}
LaunchedFragmentInfo(Parcel parcel) {
this.mWho = parcel.readString();
this.mRequestCode = parcel.readInt();
}
public void writeToParcel(Parcel parcel, int i) {
parcel.writeString(this.mWho);
parcel.writeInt(this.mRequestCode);
}
}
static class FragmentIntentSenderContract extends ActivityResultContract<IntentSenderRequest, ActivityResult> {
FragmentIntentSenderContract() {
}
public Intent createIntent(Context context, IntentSenderRequest intentSenderRequest) {
Bundle bundleExtra;
Intent intent = new Intent(ActivityResultContracts.StartIntentSenderForResult.ACTION_INTENT_SENDER_REQUEST);
Intent fillInIntent = intentSenderRequest.getFillInIntent();
if (!(fillInIntent == null || (bundleExtra = fillInIntent.getBundleExtra(ActivityResultContracts.StartActivityForResult.EXTRA_ACTIVITY_OPTIONS_BUNDLE)) == null)) {
intent.putExtra(ActivityResultContracts.StartActivityForResult.EXTRA_ACTIVITY_OPTIONS_BUNDLE, bundleExtra);
fillInIntent.removeExtra(ActivityResultContracts.StartActivityForResult.EXTRA_ACTIVITY_OPTIONS_BUNDLE);
if (fillInIntent.getBooleanExtra(FragmentManager.EXTRA_CREATED_FILLIN_INTENT, false)) {
intentSenderRequest = new IntentSenderRequest.Builder(intentSenderRequest.getIntentSender()).setFillInIntent((Intent) null).setFlags(intentSenderRequest.getFlagsValues(), intentSenderRequest.getFlagsMask()).build();
}
}
intent.putExtra(ActivityResultContracts.StartIntentSenderForResult.EXTRA_INTENT_SENDER_REQUEST, intentSenderRequest);
if (FragmentManager.isLoggingEnabled(2)) {
Log.v(FragmentManager.TAG, "CreateIntent created the following intent: " + intent);
}
return intent;
}
public ActivityResult parseResult(int i, Intent intent) {
return new ActivityResult(i, intent);
}
}
}
Download file