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