package androidx.fragment.app; import android.animation.Animator; import android.annotation.SuppressLint; import android.app.Activity; import android.app.Application; import android.content.ComponentCallbacks; import android.content.Context; import android.content.ContextWrapper; import android.content.Intent; import android.content.IntentSender; import android.content.res.Configuration; import android.content.res.Resources; import android.os.Bundle; import android.os.Handler; import android.os.Looper; import android.os.Parcel; import android.os.Parcelable; import android.util.AttributeSet; import android.util.Log; import android.util.SparseArray; import android.view.ContextMenu; 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.animation.Animation; import androidx.activity.result.ActivityResultCallback; import androidx.activity.result.ActivityResultCaller; import androidx.activity.result.ActivityResultLauncher; import androidx.activity.result.ActivityResultRegistry; import androidx.activity.result.ActivityResultRegistryOwner; import androidx.activity.result.contract.ActivityResultContract; import androidx.annotation.CallSuper; import androidx.annotation.ContentView; import androidx.annotation.LayoutRes; import androidx.annotation.MainThread; import androidx.annotation.NonNull; import androidx.annotation.Nullable; import androidx.annotation.RestrictTo; import androidx.annotation.StringRes; import androidx.annotation.UiThread; import androidx.arch.core.util.Function; import androidx.core.app.ActivityOptionsCompat; import androidx.core.app.SharedElementCallback; import androidx.core.view.LayoutInflaterCompat; import androidx.lifecycle.HasDefaultViewModelProviderFactory; import androidx.lifecycle.Lifecycle; import androidx.lifecycle.LifecycleEventObserver; import androidx.lifecycle.LifecycleOwner; import androidx.lifecycle.LifecycleRegistry; import androidx.lifecycle.LiveData; import androidx.lifecycle.MutableLiveData; import androidx.lifecycle.SavedStateViewModelFactory; import androidx.lifecycle.ViewModelProvider; import androidx.lifecycle.ViewModelStore; import androidx.lifecycle.ViewModelStoreOwner; import androidx.lifecycle.ViewTreeLifecycleOwner; import androidx.lifecycle.ViewTreeViewModelStoreOwner; import androidx.loader.app.LoaderManager; import androidx.savedstate.SavedStateRegistry; import androidx.savedstate.SavedStateRegistryController; import androidx.savedstate.SavedStateRegistryOwner; import androidx.savedstate.ViewTreeSavedStateRegistryOwner; import java.io.FileDescriptor; import java.io.PrintWriter; import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; import java.util.Iterator; import java.util.UUID; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; /* JADX INFO: loaded from: classes.dex */ public class Fragment implements ComponentCallbacks, View.OnCreateContextMenuListener, LifecycleOwner, ViewModelStoreOwner, HasDefaultViewModelProviderFactory, SavedStateRegistryOwner, ActivityResultCaller { static final int ACTIVITY_CREATED = 4; static final int ATTACHED = 0; static final int AWAITING_ENTER_EFFECTS = 6; static final int AWAITING_EXIT_EFFECTS = 3; static final int CREATED = 1; static final int INITIALIZING = -1; static final int RESUMED = 7; static final int STARTED = 5; static final Object USE_DEFAULT_TRANSITION = new Object(); static final int VIEW_CREATED = 2; boolean mAdded; AnimationInfo mAnimationInfo; Bundle mArguments; int mBackStackNesting; private boolean mCalled; @NonNull FragmentManager mChildFragmentManager; ViewGroup mContainer; int mContainerId; @LayoutRes private int mContentLayoutId; ViewModelProvider.Factory mDefaultFactory; boolean mDeferStart; boolean mDetached; int mFragmentId; FragmentManager mFragmentManager; boolean mFromLayout; boolean mHasMenu; boolean mHidden; boolean mHiddenChanged; FragmentHostCallback mHost; boolean mInLayout; boolean mIsCreated; boolean mIsNewlyAdded; private Boolean mIsPrimaryNavigationFragment; LayoutInflater mLayoutInflater; LifecycleRegistry mLifecycleRegistry; Lifecycle.State mMaxState; boolean mMenuVisible; private final AtomicInteger mNextLocalRequestCode; private final ArrayList mOnPreAttachedListeners; Fragment mParentFragment; boolean mPerformedCreateView; float mPostponedAlpha; Runnable mPostponedDurationRunnable; boolean mRemoving; boolean mRestored; boolean mRetainInstance; boolean mRetainInstanceChangedWhileDetached; Bundle mSavedFragmentState; SavedStateRegistryController mSavedStateRegistryController; @Nullable Boolean mSavedUserVisibleHint; Bundle mSavedViewRegistryState; SparseArray mSavedViewState; int mState; String mTag; Fragment mTarget; int mTargetRequestCode; String mTargetWho; boolean mUserVisibleHint; View mView; @Nullable FragmentViewLifecycleOwner mViewLifecycleOwner; MutableLiveData mViewLifecycleOwnerLiveData; @NonNull String mWho; static class AnimationInfo { Boolean mAllowEnterTransitionOverlap; Boolean mAllowReturnTransitionOverlap; View mAnimatingAway; Animator mAnimator; int mEnterAnim; Object mEnterTransition = null; SharedElementCallback mEnterTransitionCallback; boolean mEnterTransitionPostponed; int mExitAnim; Object mExitTransition; SharedElementCallback mExitTransitionCallback; View mFocusedView; boolean mIsHideReplaced; boolean mIsPop; int mNextTransition; int mPopEnterAnim; int mPopExitAnim; float mPostOnViewCreatedAlpha; Object mReenterTransition; Object mReturnTransition; Object mSharedElementEnterTransition; Object mSharedElementReturnTransition; ArrayList mSharedElementSourceNames; ArrayList mSharedElementTargetNames; OnStartEnterTransitionListener mStartEnterTransitionListener; AnimationInfo() { Object obj = Fragment.USE_DEFAULT_TRANSITION; this.mReturnTransition = obj; this.mExitTransition = null; this.mReenterTransition = obj; this.mSharedElementEnterTransition = null; this.mSharedElementReturnTransition = obj; this.mEnterTransitionCallback = null; this.mExitTransitionCallback = null; this.mPostOnViewCreatedAlpha = 1.0f; this.mFocusedView = null; } } public static class InstantiationException extends RuntimeException { public InstantiationException(@NonNull String str, @Nullable Exception exc) { super(str, exc); } } private static abstract class OnPreAttachedListener { private OnPreAttachedListener() { } abstract void onPreAttached(); } interface OnStartEnterTransitionListener { void onStartEnterTransition(); void startListening(); } public Fragment() { this.mState = -1; this.mWho = UUID.randomUUID().toString(); this.mTargetWho = null; this.mIsPrimaryNavigationFragment = null; this.mChildFragmentManager = new FragmentManagerImpl(); this.mMenuVisible = true; this.mUserVisibleHint = true; this.mPostponedDurationRunnable = new Runnable() { // from class: androidx.fragment.app.Fragment.1 @Override // java.lang.Runnable public void run() { Fragment.this.startPostponedEnterTransition(); } }; this.mMaxState = Lifecycle.State.RESUMED; this.mViewLifecycleOwnerLiveData = new MutableLiveData<>(); this.mNextLocalRequestCode = new AtomicInteger(); this.mOnPreAttachedListeners = new ArrayList<>(); initLifecycle(); } private AnimationInfo ensureAnimationInfo() { if (this.mAnimationInfo == null) { this.mAnimationInfo = new AnimationInfo(); } return this.mAnimationInfo; } private int getMinimumMaxLifecycleState() { Lifecycle.State state = this.mMaxState; return (state == Lifecycle.State.INITIALIZED || this.mParentFragment == null) ? state.ordinal() : Math.min(state.ordinal(), this.mParentFragment.getMinimumMaxLifecycleState()); } private void initLifecycle() { this.mLifecycleRegistry = new LifecycleRegistry(this); this.mSavedStateRegistryController = SavedStateRegistryController.create(this); this.mDefaultFactory = null; } @NonNull @Deprecated public static Fragment instantiate(@NonNull Context context, @NonNull String str) { return instantiate(context, str, null); } @NonNull private ActivityResultLauncher prepareCallInternal(@NonNull final ActivityResultContract activityResultContract, @NonNull final Function function, @NonNull final ActivityResultCallback activityResultCallback) { if (this.mState <= 1) { final AtomicReference atomicReference = new AtomicReference(); registerOnPreAttachListener(new OnPreAttachedListener() { // from class: androidx.fragment.app.Fragment.8 /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */ { super(); } @Override // androidx.fragment.app.Fragment.OnPreAttachedListener void onPreAttached() { String strGenerateActivityResultKey = Fragment.this.generateActivityResultKey(); atomicReference.set(((ActivityResultRegistry) function.apply(null)).register(strGenerateActivityResultKey, Fragment.this, activityResultContract, activityResultCallback)); } }); return new ActivityResultLauncher() { // from class: androidx.fragment.app.Fragment.9 @Override // androidx.activity.result.ActivityResultLauncher @NonNull public ActivityResultContract getContract() { return activityResultContract; } @Override // androidx.activity.result.ActivityResultLauncher public void launch(I i2, @Nullable ActivityOptionsCompat activityOptionsCompat) { ActivityResultLauncher activityResultLauncher = (ActivityResultLauncher) atomicReference.get(); if (activityResultLauncher == null) { throw new IllegalStateException("Operation cannot be started before fragment is in created state"); } activityResultLauncher.launch(i2, activityOptionsCompat); } @Override // androidx.activity.result.ActivityResultLauncher public void unregister() { ActivityResultLauncher activityResultLauncher = (ActivityResultLauncher) atomicReference.getAndSet(null); if (activityResultLauncher != null) { activityResultLauncher.unregister(); } } }; } throw new IllegalStateException("Fragment " + this + " is attempting to registerForActivityResult after being created. Fragments must call registerForActivityResult() before they are created (i.e. initialization, onAttach(), or onCreate())."); } private void registerOnPreAttachListener(@NonNull OnPreAttachedListener onPreAttachedListener) { if (this.mState >= 0) { onPreAttachedListener.onPreAttached(); } else { this.mOnPreAttachedListeners.add(onPreAttachedListener); } } void callStartTransitionListener(boolean z2) { ViewGroup viewGroup; FragmentManager fragmentManager; AnimationInfo animationInfo = this.mAnimationInfo; OnStartEnterTransitionListener onStartEnterTransitionListener = null; if (animationInfo != null) { animationInfo.mEnterTransitionPostponed = false; OnStartEnterTransitionListener onStartEnterTransitionListener2 = animationInfo.mStartEnterTransitionListener; animationInfo.mStartEnterTransitionListener = null; onStartEnterTransitionListener = onStartEnterTransitionListener2; } if (onStartEnterTransitionListener != null) { onStartEnterTransitionListener.onStartEnterTransition(); return; } if (!FragmentManager.USE_STATE_MANAGER || this.mView == null || (viewGroup = this.mContainer) == null || (fragmentManager = this.mFragmentManager) == null) { return; } final SpecialEffectsController orCreateController = SpecialEffectsController.getOrCreateController(viewGroup, fragmentManager); orCreateController.markPostponedState(); if (z2) { this.mHost.getHandler().post(new Runnable() { // from class: androidx.fragment.app.Fragment.3 @Override // java.lang.Runnable public void run() { orCreateController.executePendingOperations(); } }); } else { orCreateController.executePendingOperations(); } } @NonNull FragmentContainer createFragmentContainer() { return new FragmentContainer() { // from class: androidx.fragment.app.Fragment.4 @Override // androidx.fragment.app.FragmentContainer @Nullable public View onFindViewById(int i2) { View view = Fragment.this.mView; if (view != null) { return view.findViewById(i2); } throw new IllegalStateException("Fragment " + Fragment.this + " does not have a view"); } @Override // androidx.fragment.app.FragmentContainer public boolean onHasView() { return Fragment.this.mView != null; } }; } public void dump(@NonNull String str, @Nullable FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @Nullable String[] strArr) { printWriter.print(str); printWriter.print("mFragmentId=#"); printWriter.print(Integer.toHexString(this.mFragmentId)); printWriter.print(" mContainerId=#"); printWriter.print(Integer.toHexString(this.mContainerId)); printWriter.print(" mTag="); printWriter.println(this.mTag); printWriter.print(str); printWriter.print("mState="); printWriter.print(this.mState); printWriter.print(" mWho="); printWriter.print(this.mWho); printWriter.print(" mBackStackNesting="); printWriter.println(this.mBackStackNesting); printWriter.print(str); printWriter.print("mAdded="); printWriter.print(this.mAdded); printWriter.print(" mRemoving="); printWriter.print(this.mRemoving); printWriter.print(" mFromLayout="); printWriter.print(this.mFromLayout); printWriter.print(" mInLayout="); printWriter.println(this.mInLayout); printWriter.print(str); printWriter.print("mHidden="); printWriter.print(this.mHidden); printWriter.print(" mDetached="); printWriter.print(this.mDetached); printWriter.print(" mMenuVisible="); printWriter.print(this.mMenuVisible); printWriter.print(" mHasMenu="); printWriter.println(this.mHasMenu); printWriter.print(str); printWriter.print("mRetainInstance="); printWriter.print(this.mRetainInstance); printWriter.print(" mUserVisibleHint="); printWriter.println(this.mUserVisibleHint); if (this.mFragmentManager != null) { printWriter.print(str); printWriter.print("mFragmentManager="); printWriter.println(this.mFragmentManager); } if (this.mHost != null) { printWriter.print(str); printWriter.print("mHost="); printWriter.println(this.mHost); } if (this.mParentFragment != null) { printWriter.print(str); printWriter.print("mParentFragment="); printWriter.println(this.mParentFragment); } if (this.mArguments != null) { printWriter.print(str); printWriter.print("mArguments="); printWriter.println(this.mArguments); } if (this.mSavedFragmentState != null) { printWriter.print(str); printWriter.print("mSavedFragmentState="); printWriter.println(this.mSavedFragmentState); } if (this.mSavedViewState != null) { printWriter.print(str); printWriter.print("mSavedViewState="); printWriter.println(this.mSavedViewState); } if (this.mSavedViewRegistryState != null) { printWriter.print(str); printWriter.print("mSavedViewRegistryState="); printWriter.println(this.mSavedViewRegistryState); } Fragment targetFragment = getTargetFragment(); if (targetFragment != null) { printWriter.print(str); printWriter.print("mTarget="); printWriter.print(targetFragment); printWriter.print(" mTargetRequestCode="); printWriter.println(this.mTargetRequestCode); } printWriter.print(str); printWriter.print("mPopDirection="); printWriter.println(getPopDirection()); if (getEnterAnim() != 0) { printWriter.print(str); printWriter.print("getEnterAnim="); printWriter.println(getEnterAnim()); } if (getExitAnim() != 0) { printWriter.print(str); printWriter.print("getExitAnim="); printWriter.println(getExitAnim()); } if (getPopEnterAnim() != 0) { printWriter.print(str); printWriter.print("getPopEnterAnim="); printWriter.println(getPopEnterAnim()); } if (getPopExitAnim() != 0) { printWriter.print(str); printWriter.print("getPopExitAnim="); printWriter.println(getPopExitAnim()); } if (this.mContainer != null) { printWriter.print(str); printWriter.print("mContainer="); printWriter.println(this.mContainer); } if (this.mView != null) { printWriter.print(str); printWriter.print("mView="); printWriter.println(this.mView); } if (getAnimatingAway() != null) { printWriter.print(str); printWriter.print("mAnimatingAway="); printWriter.println(getAnimatingAway()); } if (getContext() != null) { LoaderManager.getInstance(this).dump(str, fileDescriptor, printWriter, strArr); } printWriter.print(str); printWriter.println("Child " + this.mChildFragmentManager + ":"); this.mChildFragmentManager.dump(str + " ", fileDescriptor, printWriter, strArr); } public final boolean equals(@Nullable Object obj) { return super.equals(obj); } @Nullable Fragment findFragmentByWho(@NonNull String str) { return str.equals(this.mWho) ? this : this.mChildFragmentManager.findFragmentByWho(str); } @NonNull String generateActivityResultKey() { return "fragment_" + this.mWho + "_rq#" + this.mNextLocalRequestCode.getAndIncrement(); } @Nullable public final FragmentActivity getActivity() { FragmentHostCallback fragmentHostCallback = this.mHost; if (fragmentHostCallback == null) { return null; } return (FragmentActivity) fragmentHostCallback.getActivity(); } public boolean getAllowEnterTransitionOverlap() { Boolean bool; AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null || (bool = animationInfo.mAllowEnterTransitionOverlap) == null) { return true; } return bool.booleanValue(); } public boolean getAllowReturnTransitionOverlap() { Boolean bool; AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null || (bool = animationInfo.mAllowReturnTransitionOverlap) == null) { return true; } return bool.booleanValue(); } View getAnimatingAway() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } return animationInfo.mAnimatingAway; } Animator getAnimator() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } return animationInfo.mAnimator; } @Nullable public final Bundle getArguments() { return this.mArguments; } @NonNull public final FragmentManager getChildFragmentManager() { if (this.mHost != null) { return this.mChildFragmentManager; } throw new IllegalStateException("Fragment " + this + " has not been attached yet."); } @Nullable public Context getContext() { FragmentHostCallback fragmentHostCallback = this.mHost; if (fragmentHostCallback == null) { return null; } return fragmentHostCallback.getContext(); } @Override // androidx.lifecycle.HasDefaultViewModelProviderFactory @NonNull public ViewModelProvider.Factory getDefaultViewModelProviderFactory() { Application application; if (this.mFragmentManager == null) { throw new IllegalStateException("Can't access ViewModels from detached fragment"); } if (this.mDefaultFactory == null) { Context applicationContext = requireContext().getApplicationContext(); while (true) { if (!(applicationContext instanceof ContextWrapper)) { application = null; break; } if (applicationContext instanceof Application) { application = (Application) applicationContext; break; } applicationContext = ((ContextWrapper) applicationContext).getBaseContext(); } if (application == null && FragmentManager.isLoggingEnabled(3)) { Log.d("FragmentManager", "Could not find Application instance from Context " + requireContext().getApplicationContext() + ", you will not be able to use AndroidViewModel with the default ViewModelProvider.Factory"); } this.mDefaultFactory = new SavedStateViewModelFactory(application, this, getArguments()); } return this.mDefaultFactory; } int getEnterAnim() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return 0; } return animationInfo.mEnterAnim; } @Nullable public Object getEnterTransition() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } return animationInfo.mEnterTransition; } SharedElementCallback getEnterTransitionCallback() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } return animationInfo.mEnterTransitionCallback; } int getExitAnim() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return 0; } return animationInfo.mExitAnim; } @Nullable public Object getExitTransition() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } return animationInfo.mExitTransition; } SharedElementCallback getExitTransitionCallback() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } return animationInfo.mExitTransitionCallback; } View getFocusedView() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } return animationInfo.mFocusedView; } @Nullable @Deprecated public final FragmentManager getFragmentManager() { return this.mFragmentManager; } @Nullable public final Object getHost() { FragmentHostCallback fragmentHostCallback = this.mHost; if (fragmentHostCallback == null) { return null; } return fragmentHostCallback.onGetHost(); } public final int getId() { return this.mFragmentId; } @NonNull public final LayoutInflater getLayoutInflater() { LayoutInflater layoutInflater = this.mLayoutInflater; return layoutInflater == null ? performGetLayoutInflater(null) : layoutInflater; } @Override // androidx.lifecycle.LifecycleOwner @NonNull public Lifecycle getLifecycle() { return this.mLifecycleRegistry; } @NonNull @Deprecated public LoaderManager getLoaderManager() { return LoaderManager.getInstance(this); } int getNextTransition() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return 0; } return animationInfo.mNextTransition; } @Nullable public final Fragment getParentFragment() { return this.mParentFragment; } @NonNull public final FragmentManager getParentFragmentManager() { FragmentManager fragmentManager = this.mFragmentManager; if (fragmentManager != null) { return fragmentManager; } throw new IllegalStateException("Fragment " + this + " not associated with a fragment manager."); } boolean getPopDirection() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return false; } return animationInfo.mIsPop; } int getPopEnterAnim() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return 0; } return animationInfo.mPopEnterAnim; } int getPopExitAnim() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return 0; } return animationInfo.mPopExitAnim; } float getPostOnViewCreatedAlpha() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return 1.0f; } return animationInfo.mPostOnViewCreatedAlpha; } @Nullable public Object getReenterTransition() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } Object obj = animationInfo.mReenterTransition; return obj == USE_DEFAULT_TRANSITION ? getExitTransition() : obj; } @NonNull public final Resources getResources() { return requireContext().getResources(); } @Deprecated public final boolean getRetainInstance() { return this.mRetainInstance; } @Nullable public Object getReturnTransition() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } Object obj = animationInfo.mReturnTransition; return obj == USE_DEFAULT_TRANSITION ? getEnterTransition() : obj; } @Override // androidx.savedstate.SavedStateRegistryOwner @NonNull public final SavedStateRegistry getSavedStateRegistry() { return this.mSavedStateRegistryController.getSavedStateRegistry(); } @Nullable public Object getSharedElementEnterTransition() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } return animationInfo.mSharedElementEnterTransition; } @Nullable public Object getSharedElementReturnTransition() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return null; } Object obj = animationInfo.mSharedElementReturnTransition; return obj == USE_DEFAULT_TRANSITION ? getSharedElementEnterTransition() : obj; } @NonNull ArrayList getSharedElementSourceNames() { ArrayList arrayList; AnimationInfo animationInfo = this.mAnimationInfo; return (animationInfo == null || (arrayList = animationInfo.mSharedElementSourceNames) == null) ? new ArrayList<>() : arrayList; } @NonNull ArrayList getSharedElementTargetNames() { ArrayList arrayList; AnimationInfo animationInfo = this.mAnimationInfo; return (animationInfo == null || (arrayList = animationInfo.mSharedElementTargetNames) == null) ? new ArrayList<>() : arrayList; } @NonNull public final String getString(@StringRes int i2) { return getResources().getString(i2); } @Nullable public final String getTag() { return this.mTag; } @Nullable @Deprecated public final Fragment getTargetFragment() { String str; Fragment fragment = this.mTarget; if (fragment != null) { return fragment; } FragmentManager fragmentManager = this.mFragmentManager; if (fragmentManager == null || (str = this.mTargetWho) == null) { return null; } return fragmentManager.findActiveFragment(str); } @Deprecated public final int getTargetRequestCode() { return this.mTargetRequestCode; } @NonNull public final CharSequence getText(@StringRes int i2) { return getResources().getText(i2); } @Deprecated public boolean getUserVisibleHint() { return this.mUserVisibleHint; } @Nullable public View getView() { return this.mView; } @NonNull @MainThread public LifecycleOwner getViewLifecycleOwner() { FragmentViewLifecycleOwner fragmentViewLifecycleOwner = this.mViewLifecycleOwner; if (fragmentViewLifecycleOwner != null) { return fragmentViewLifecycleOwner; } throw new IllegalStateException("Can't access the Fragment View's LifecycleOwner when getView() is null i.e., before onCreateView() or after onDestroyView()"); } @NonNull public LiveData getViewLifecycleOwnerLiveData() { return this.mViewLifecycleOwnerLiveData; } @Override // androidx.lifecycle.ViewModelStoreOwner @NonNull public ViewModelStore getViewModelStore() { if (this.mFragmentManager == null) { throw new IllegalStateException("Can't access ViewModels from detached fragment"); } if (getMinimumMaxLifecycleState() != Lifecycle.State.INITIALIZED.ordinal()) { return this.mFragmentManager.getViewModelStore(this); } throw new IllegalStateException("Calling getViewModelStore() before a Fragment reaches onCreate() when using setMaxLifecycle(INITIALIZED) is not supported"); } @SuppressLint({"KotlinPropertyAccess"}) @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX}) public final boolean hasOptionsMenu() { return this.mHasMenu; } public final int hashCode() { return super.hashCode(); } void initState() { initLifecycle(); this.mWho = UUID.randomUUID().toString(); this.mAdded = false; this.mRemoving = false; this.mFromLayout = false; this.mInLayout = false; this.mRestored = false; this.mBackStackNesting = 0; this.mFragmentManager = null; this.mChildFragmentManager = new FragmentManagerImpl(); this.mHost = null; this.mFragmentId = 0; this.mContainerId = 0; this.mTag = null; this.mHidden = false; this.mDetached = false; } public final boolean isAdded() { return this.mHost != null && this.mAdded; } public final boolean isDetached() { return this.mDetached; } public final boolean isHidden() { return this.mHidden; } boolean isHideReplaced() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return false; } return animationInfo.mIsHideReplaced; } final boolean isInBackStack() { return this.mBackStackNesting > 0; } public final boolean isInLayout() { return this.mInLayout; } @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX}) public final boolean isMenuVisible() { FragmentManager fragmentManager; return this.mMenuVisible && ((fragmentManager = this.mFragmentManager) == null || fragmentManager.isParentMenuVisible(this.mParentFragment)); } boolean isPostponed() { AnimationInfo animationInfo = this.mAnimationInfo; if (animationInfo == null) { return false; } return animationInfo.mEnterTransitionPostponed; } public final boolean isRemoving() { return this.mRemoving; } final boolean isRemovingParent() { Fragment parentFragment = getParentFragment(); return parentFragment != null && (parentFragment.isRemoving() || parentFragment.isRemovingParent()); } public final boolean isResumed() { return this.mState >= 7; } public final boolean isStateSaved() { FragmentManager fragmentManager = this.mFragmentManager; if (fragmentManager == null) { return false; } return fragmentManager.isStateSaved(); } public final boolean isVisible() { View view; return (!isAdded() || isHidden() || (view = this.mView) == null || view.getWindowToken() == null || this.mView.getVisibility() != 0) ? false : true; } void noteStateNotSaved() { this.mChildFragmentManager.noteStateNotSaved(); } @CallSuper @MainThread @Deprecated public void onActivityCreated(@Nullable Bundle bundle) { this.mCalled = true; } @Deprecated public void onActivityResult(int i2, int i3, @Nullable Intent intent) { if (FragmentManager.isLoggingEnabled(2)) { Log.v("FragmentManager", "Fragment " + this + " received the following in onActivityResult(): requestCode: " + i2 + " resultCode: " + i3 + " data: " + intent); } } @CallSuper @MainThread public void onAttach(@NonNull Context context) { this.mCalled = true; FragmentHostCallback fragmentHostCallback = this.mHost; Activity activity = fragmentHostCallback == null ? null : fragmentHostCallback.getActivity(); if (activity != null) { this.mCalled = false; onAttach(activity); } } @MainThread @Deprecated public void onAttachFragment(@NonNull Fragment fragment) { } @Override // android.content.ComponentCallbacks @CallSuper public void onConfigurationChanged(@NonNull Configuration configuration) { this.mCalled = true; } @MainThread public boolean onContextItemSelected(@NonNull MenuItem menuItem) { return false; } @CallSuper @MainThread public void onCreate(@Nullable Bundle bundle) { this.mCalled = true; restoreChildFragmentState(bundle); if (this.mChildFragmentManager.isStateAtLeast(1)) { return; } this.mChildFragmentManager.dispatchCreate(); } @Nullable @MainThread public Animation onCreateAnimation(int i2, boolean z2, int i3) { return null; } @Nullable @MainThread public Animator onCreateAnimator(int i2, boolean z2, int i3) { return null; } @Override // android.view.View.OnCreateContextMenuListener @MainThread public void onCreateContextMenu(@NonNull ContextMenu contextMenu, @NonNull View view, @Nullable ContextMenu.ContextMenuInfo contextMenuInfo) { requireActivity().onCreateContextMenu(contextMenu, view, contextMenuInfo); } @MainThread public void onCreateOptionsMenu(@NonNull Menu menu, @NonNull MenuInflater menuInflater) { } @Nullable @MainThread public View onCreateView(@NonNull LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) { int i2 = this.mContentLayoutId; if (i2 != 0) { return layoutInflater.inflate(i2, viewGroup, false); } return null; } @CallSuper @MainThread public void onDestroy() { this.mCalled = true; } @MainThread public void onDestroyOptionsMenu() { } @CallSuper @MainThread public void onDestroyView() { this.mCalled = true; } @CallSuper @MainThread public void onDetach() { this.mCalled = true; } @NonNull public LayoutInflater onGetLayoutInflater(@Nullable Bundle bundle) { return getLayoutInflater(bundle); } @MainThread public void onHiddenChanged(boolean z2) { } @CallSuper @UiThread public void onInflate(@NonNull Context context, @NonNull AttributeSet attributeSet, @Nullable Bundle bundle) { this.mCalled = true; FragmentHostCallback fragmentHostCallback = this.mHost; Activity activity = fragmentHostCallback == null ? null : fragmentHostCallback.getActivity(); if (activity != null) { this.mCalled = false; onInflate(activity, attributeSet, bundle); } } @Override // android.content.ComponentCallbacks @CallSuper @MainThread public void onLowMemory() { this.mCalled = true; } public void onMultiWindowModeChanged(boolean z2) { } @MainThread public boolean onOptionsItemSelected(@NonNull MenuItem menuItem) { return false; } @MainThread public void onOptionsMenuClosed(@NonNull Menu menu) { } @CallSuper @MainThread public void onPause() { this.mCalled = true; } public void onPictureInPictureModeChanged(boolean z2) { } @MainThread public void onPrepareOptionsMenu(@NonNull Menu menu) { } @MainThread public void onPrimaryNavigationFragmentChanged(boolean z2) { } @Deprecated public void onRequestPermissionsResult(int i2, @NonNull String[] strArr, @NonNull int[] iArr) { } @CallSuper @MainThread public void onResume() { this.mCalled = true; } @MainThread public void onSaveInstanceState(@NonNull Bundle bundle) { } @CallSuper @MainThread public void onStart() { this.mCalled = true; } @CallSuper @MainThread public void onStop() { this.mCalled = true; } @MainThread public void onViewCreated(@NonNull View view, @Nullable Bundle bundle) { } @CallSuper @MainThread public void onViewStateRestored(@Nullable Bundle bundle) { this.mCalled = true; } void performActivityCreated(Bundle bundle) { this.mChildFragmentManager.noteStateNotSaved(); this.mState = 3; this.mCalled = false; onActivityCreated(bundle); if (this.mCalled) { restoreViewState(); this.mChildFragmentManager.dispatchActivityCreated(); } else { throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onActivityCreated()"); } } void performAttach() { Iterator it = this.mOnPreAttachedListeners.iterator(); while (it.hasNext()) { it.next().onPreAttached(); } this.mOnPreAttachedListeners.clear(); this.mChildFragmentManager.attachController(this.mHost, createFragmentContainer(), this); this.mState = 0; this.mCalled = false; onAttach(this.mHost.getContext()); if (this.mCalled) { this.mFragmentManager.dispatchOnAttachFragment(this); this.mChildFragmentManager.dispatchAttach(); } else { throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onAttach()"); } } void performConfigurationChanged(@NonNull Configuration configuration) { onConfigurationChanged(configuration); this.mChildFragmentManager.dispatchConfigurationChanged(configuration); } boolean performContextItemSelected(@NonNull MenuItem menuItem) { if (this.mHidden) { return false; } if (onContextItemSelected(menuItem)) { return true; } return this.mChildFragmentManager.dispatchContextItemSelected(menuItem); } void performCreate(Bundle bundle) { this.mChildFragmentManager.noteStateNotSaved(); this.mState = 1; this.mCalled = false; this.mLifecycleRegistry.addObserver(new LifecycleEventObserver() { // from class: androidx.fragment.app.Fragment.5 @Override // androidx.lifecycle.LifecycleEventObserver public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner, @NonNull Lifecycle.Event event) { View view; if (event != Lifecycle.Event.ON_STOP || (view = Fragment.this.mView) == null) { return; } view.cancelPendingInputEvents(); } }); this.mSavedStateRegistryController.performRestore(bundle); onCreate(bundle); this.mIsCreated = true; if (this.mCalled) { this.mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE); return; } throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onCreate()"); } boolean performCreateOptionsMenu(@NonNull Menu menu, @NonNull MenuInflater menuInflater) { boolean z2 = false; if (this.mHidden) { return false; } if (this.mHasMenu && this.mMenuVisible) { onCreateOptionsMenu(menu, menuInflater); z2 = true; } return z2 | this.mChildFragmentManager.dispatchCreateOptionsMenu(menu, menuInflater); } void performCreateView(@NonNull LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) { this.mChildFragmentManager.noteStateNotSaved(); this.mPerformedCreateView = true; this.mViewLifecycleOwner = new FragmentViewLifecycleOwner(this, getViewModelStore()); View viewOnCreateView = onCreateView(layoutInflater, viewGroup, bundle); this.mView = viewOnCreateView; if (viewOnCreateView == null) { if (this.mViewLifecycleOwner.isInitialized()) { throw new IllegalStateException("Called getViewLifecycleOwner() but onCreateView() returned null"); } this.mViewLifecycleOwner = null; } else { this.mViewLifecycleOwner.initialize(); ViewTreeLifecycleOwner.set(this.mView, this.mViewLifecycleOwner); ViewTreeViewModelStoreOwner.set(this.mView, this.mViewLifecycleOwner); ViewTreeSavedStateRegistryOwner.set(this.mView, this.mViewLifecycleOwner); this.mViewLifecycleOwnerLiveData.setValue(this.mViewLifecycleOwner); } } void performDestroy() { this.mChildFragmentManager.dispatchDestroy(); this.mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY); this.mState = 0; this.mCalled = false; this.mIsCreated = false; onDestroy(); if (this.mCalled) { return; } throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onDestroy()"); } void performDestroyView() { this.mChildFragmentManager.dispatchDestroyView(); if (this.mView != null && this.mViewLifecycleOwner.getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.CREATED)) { this.mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY); } this.mState = 1; this.mCalled = false; onDestroyView(); if (this.mCalled) { LoaderManager.getInstance(this).markForRedelivery(); this.mPerformedCreateView = false; } else { throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onDestroyView()"); } } void performDetach() { this.mState = -1; this.mCalled = false; onDetach(); this.mLayoutInflater = null; if (this.mCalled) { if (this.mChildFragmentManager.isDestroyed()) { return; } this.mChildFragmentManager.dispatchDestroy(); this.mChildFragmentManager = new FragmentManagerImpl(); return; } throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onDetach()"); } @NonNull LayoutInflater performGetLayoutInflater(@Nullable Bundle bundle) { LayoutInflater layoutInflaterOnGetLayoutInflater = onGetLayoutInflater(bundle); this.mLayoutInflater = layoutInflaterOnGetLayoutInflater; return layoutInflaterOnGetLayoutInflater; } void performLowMemory() { onLowMemory(); this.mChildFragmentManager.dispatchLowMemory(); } void performMultiWindowModeChanged(boolean z2) { onMultiWindowModeChanged(z2); this.mChildFragmentManager.dispatchMultiWindowModeChanged(z2); } boolean performOptionsItemSelected(@NonNull MenuItem menuItem) { if (this.mHidden) { return false; } if (this.mHasMenu && this.mMenuVisible && onOptionsItemSelected(menuItem)) { return true; } return this.mChildFragmentManager.dispatchOptionsItemSelected(menuItem); } void performOptionsMenuClosed(@NonNull Menu menu) { if (this.mHidden) { return; } if (this.mHasMenu && this.mMenuVisible) { onOptionsMenuClosed(menu); } this.mChildFragmentManager.dispatchOptionsMenuClosed(menu); } void performPause() { this.mChildFragmentManager.dispatchPause(); if (this.mView != null) { this.mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE); } this.mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE); this.mState = 6; this.mCalled = false; onPause(); if (this.mCalled) { return; } throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onPause()"); } void performPictureInPictureModeChanged(boolean z2) { onPictureInPictureModeChanged(z2); this.mChildFragmentManager.dispatchPictureInPictureModeChanged(z2); } boolean performPrepareOptionsMenu(@NonNull Menu menu) { boolean z2 = false; if (this.mHidden) { return false; } if (this.mHasMenu && this.mMenuVisible) { onPrepareOptionsMenu(menu); z2 = true; } return z2 | this.mChildFragmentManager.dispatchPrepareOptionsMenu(menu); } void performPrimaryNavigationFragmentChanged() { boolean zIsPrimaryNavigation = this.mFragmentManager.isPrimaryNavigation(this); Boolean bool = this.mIsPrimaryNavigationFragment; if (bool == null || bool.booleanValue() != zIsPrimaryNavigation) { this.mIsPrimaryNavigationFragment = Boolean.valueOf(zIsPrimaryNavigation); onPrimaryNavigationFragmentChanged(zIsPrimaryNavigation); this.mChildFragmentManager.dispatchPrimaryNavigationFragmentChanged(); } } void performResume() { this.mChildFragmentManager.noteStateNotSaved(); this.mChildFragmentManager.execPendingActions(true); this.mState = 7; this.mCalled = false; onResume(); if (!this.mCalled) { throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onResume()"); } LifecycleRegistry lifecycleRegistry = this.mLifecycleRegistry; Lifecycle.Event event = Lifecycle.Event.ON_RESUME; lifecycleRegistry.handleLifecycleEvent(event); if (this.mView != null) { this.mViewLifecycleOwner.handleLifecycleEvent(event); } this.mChildFragmentManager.dispatchResume(); } void performSaveInstanceState(Bundle bundle) { onSaveInstanceState(bundle); this.mSavedStateRegistryController.performSave(bundle); Parcelable parcelableSaveAllState = this.mChildFragmentManager.saveAllState(); if (parcelableSaveAllState != null) { bundle.putParcelable("android:support:fragments", parcelableSaveAllState); } } void performStart() { this.mChildFragmentManager.noteStateNotSaved(); this.mChildFragmentManager.execPendingActions(true); this.mState = 5; this.mCalled = false; onStart(); if (!this.mCalled) { throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onStart()"); } LifecycleRegistry lifecycleRegistry = this.mLifecycleRegistry; Lifecycle.Event event = Lifecycle.Event.ON_START; lifecycleRegistry.handleLifecycleEvent(event); if (this.mView != null) { this.mViewLifecycleOwner.handleLifecycleEvent(event); } this.mChildFragmentManager.dispatchStart(); } void performStop() { this.mChildFragmentManager.dispatchStop(); if (this.mView != null) { this.mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_STOP); } this.mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP); this.mState = 4; this.mCalled = false; onStop(); if (this.mCalled) { return; } throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onStop()"); } void performViewCreated() { onViewCreated(this.mView, this.mSavedFragmentState); this.mChildFragmentManager.dispatchViewCreated(); } public void postponeEnterTransition() { ensureAnimationInfo().mEnterTransitionPostponed = true; } @Override // androidx.activity.result.ActivityResultCaller @NonNull @MainThread public final ActivityResultLauncher registerForActivityResult(@NonNull ActivityResultContract activityResultContract, @NonNull ActivityResultCallback activityResultCallback) { return prepareCallInternal(activityResultContract, new Function() { // from class: androidx.fragment.app.Fragment.6 @Override // androidx.arch.core.util.Function public ActivityResultRegistry apply(Void r3) { Fragment fragment = Fragment.this; Object obj = fragment.mHost; return obj instanceof ActivityResultRegistryOwner ? ((ActivityResultRegistryOwner) obj).getActivityResultRegistry() : fragment.requireActivity().getActivityResultRegistry(); } }, activityResultCallback); } public void registerForContextMenu(@NonNull View view) { view.setOnCreateContextMenuListener(this); } @Deprecated public final void requestPermissions(@NonNull String[] strArr, int i2) { if (this.mHost != null) { getParentFragmentManager().launchRequestPermissions(this, strArr, i2); return; } throw new IllegalStateException("Fragment " + this + " not attached to Activity"); } @NonNull public final FragmentActivity requireActivity() { FragmentActivity activity = getActivity(); if (activity != null) { return activity; } throw new IllegalStateException("Fragment " + this + " not attached to an activity."); } @NonNull public final Bundle requireArguments() { Bundle arguments = getArguments(); if (arguments != null) { return arguments; } throw new IllegalStateException("Fragment " + this + " does not have any arguments."); } @NonNull public final Context requireContext() { Context context = getContext(); if (context != null) { return context; } throw new IllegalStateException("Fragment " + this + " not attached to a context."); } @NonNull @Deprecated public final FragmentManager requireFragmentManager() { return getParentFragmentManager(); } @NonNull public final Object requireHost() { Object host = getHost(); if (host != null) { return host; } throw new IllegalStateException("Fragment " + this + " not attached to a host."); } @NonNull public final Fragment requireParentFragment() { Fragment parentFragment = getParentFragment(); if (parentFragment != null) { return parentFragment; } if (getContext() == null) { throw new IllegalStateException("Fragment " + this + " is not attached to any Fragment or host"); } throw new IllegalStateException("Fragment " + this + " is not a child Fragment, it is directly attached to " + getContext()); } @NonNull public final View requireView() { View view = getView(); if (view != null) { return view; } throw new IllegalStateException("Fragment " + this + " did not return a View from onCreateView() or this was called before onCreateView()."); } void restoreChildFragmentState(@Nullable Bundle bundle) { Parcelable parcelable; if (bundle == null || (parcelable = bundle.getParcelable("android:support:fragments")) == null) { return; } this.mChildFragmentManager.restoreSaveState(parcelable); this.mChildFragmentManager.dispatchCreate(); } final void restoreViewState(Bundle bundle) { SparseArray sparseArray = this.mSavedViewState; if (sparseArray != null) { this.mView.restoreHierarchyState(sparseArray); this.mSavedViewState = null; } if (this.mView != null) { this.mViewLifecycleOwner.performRestore(this.mSavedViewRegistryState); this.mSavedViewRegistryState = null; } this.mCalled = false; onViewStateRestored(bundle); if (this.mCalled) { if (this.mView != null) { this.mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_CREATE); } } else { throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onViewStateRestored()"); } } public void setAllowEnterTransitionOverlap(boolean z2) { ensureAnimationInfo().mAllowEnterTransitionOverlap = Boolean.valueOf(z2); } public void setAllowReturnTransitionOverlap(boolean z2) { ensureAnimationInfo().mAllowReturnTransitionOverlap = Boolean.valueOf(z2); } void setAnimatingAway(View view) { ensureAnimationInfo().mAnimatingAway = view; } void setAnimations(int i2, int i3, int i4, int i5) { if (this.mAnimationInfo == null && i2 == 0 && i3 == 0 && i4 == 0 && i5 == 0) { return; } ensureAnimationInfo().mEnterAnim = i2; ensureAnimationInfo().mExitAnim = i3; ensureAnimationInfo().mPopEnterAnim = i4; ensureAnimationInfo().mPopExitAnim = i5; } void setAnimator(Animator animator) { ensureAnimationInfo().mAnimator = animator; } public void setArguments(@Nullable Bundle bundle) { if (this.mFragmentManager != null && isStateSaved()) { throw new IllegalStateException("Fragment already added and state has been saved"); } this.mArguments = bundle; } public void setEnterSharedElementCallback(@Nullable SharedElementCallback sharedElementCallback) { ensureAnimationInfo().mEnterTransitionCallback = sharedElementCallback; } public void setEnterTransition(@Nullable Object obj) { ensureAnimationInfo().mEnterTransition = obj; } public void setExitSharedElementCallback(@Nullable SharedElementCallback sharedElementCallback) { ensureAnimationInfo().mExitTransitionCallback = sharedElementCallback; } public void setExitTransition(@Nullable Object obj) { ensureAnimationInfo().mExitTransition = obj; } void setFocusedView(View view) { ensureAnimationInfo().mFocusedView = view; } public void setHasOptionsMenu(boolean z2) { if (this.mHasMenu != z2) { this.mHasMenu = z2; if (!isAdded() || isHidden()) { return; } this.mHost.onSupportInvalidateOptionsMenu(); } } void setHideReplaced(boolean z2) { ensureAnimationInfo().mIsHideReplaced = z2; } public void setInitialSavedState(@Nullable SavedState savedState) { Bundle bundle; if (this.mFragmentManager != null) { throw new IllegalStateException("Fragment already added"); } if (savedState == null || (bundle = savedState.mState) == null) { bundle = null; } this.mSavedFragmentState = bundle; } public void setMenuVisibility(boolean z2) { if (this.mMenuVisible != z2) { this.mMenuVisible = z2; if (this.mHasMenu && isAdded() && !isHidden()) { this.mHost.onSupportInvalidateOptionsMenu(); } } } void setNextTransition(int i2) { if (this.mAnimationInfo == null && i2 == 0) { return; } ensureAnimationInfo(); this.mAnimationInfo.mNextTransition = i2; } void setOnStartEnterTransitionListener(OnStartEnterTransitionListener onStartEnterTransitionListener) { ensureAnimationInfo(); AnimationInfo animationInfo = this.mAnimationInfo; OnStartEnterTransitionListener onStartEnterTransitionListener2 = animationInfo.mStartEnterTransitionListener; if (onStartEnterTransitionListener == onStartEnterTransitionListener2) { return; } if (onStartEnterTransitionListener != null && onStartEnterTransitionListener2 != null) { throw new IllegalStateException("Trying to set a replacement startPostponedEnterTransition on " + this); } if (animationInfo.mEnterTransitionPostponed) { animationInfo.mStartEnterTransitionListener = onStartEnterTransitionListener; } if (onStartEnterTransitionListener != null) { onStartEnterTransitionListener.startListening(); } } void setPopDirection(boolean z2) { if (this.mAnimationInfo == null) { return; } ensureAnimationInfo().mIsPop = z2; } void setPostOnViewCreatedAlpha(float f2) { ensureAnimationInfo().mPostOnViewCreatedAlpha = f2; } public void setReenterTransition(@Nullable Object obj) { ensureAnimationInfo().mReenterTransition = obj; } @Deprecated public void setRetainInstance(boolean z2) { this.mRetainInstance = z2; FragmentManager fragmentManager = this.mFragmentManager; if (fragmentManager == null) { this.mRetainInstanceChangedWhileDetached = true; } else if (z2) { fragmentManager.addRetainedFragment(this); } else { fragmentManager.removeRetainedFragment(this); } } public void setReturnTransition(@Nullable Object obj) { ensureAnimationInfo().mReturnTransition = obj; } public void setSharedElementEnterTransition(@Nullable Object obj) { ensureAnimationInfo().mSharedElementEnterTransition = obj; } void setSharedElementNames(@Nullable ArrayList arrayList, @Nullable ArrayList arrayList2) { ensureAnimationInfo(); AnimationInfo animationInfo = this.mAnimationInfo; animationInfo.mSharedElementSourceNames = arrayList; animationInfo.mSharedElementTargetNames = arrayList2; } public void setSharedElementReturnTransition(@Nullable Object obj) { ensureAnimationInfo().mSharedElementReturnTransition = obj; } @Deprecated public void setTargetFragment(@Nullable Fragment fragment, int i2) { FragmentManager fragmentManager = this.mFragmentManager; FragmentManager fragmentManager2 = fragment != null ? fragment.mFragmentManager : null; if (fragmentManager != null && fragmentManager2 != null && fragmentManager != fragmentManager2) { throw new IllegalArgumentException("Fragment " + fragment + " must share the same FragmentManager to be set as a target fragment"); } for (Fragment targetFragment = fragment; targetFragment != null; targetFragment = targetFragment.getTargetFragment()) { if (targetFragment.equals(this)) { throw new IllegalArgumentException("Setting " + fragment + " as the target of " + this + " would create a target cycle"); } } if (fragment == null) { this.mTargetWho = null; this.mTarget = null; } else if (this.mFragmentManager == null || fragment.mFragmentManager == null) { this.mTargetWho = null; this.mTarget = fragment; } else { this.mTargetWho = fragment.mWho; this.mTarget = null; } this.mTargetRequestCode = i2; } @Deprecated public void setUserVisibleHint(boolean z2) { if (!this.mUserVisibleHint && z2 && this.mState < 5 && this.mFragmentManager != null && isAdded() && this.mIsCreated) { FragmentManager fragmentManager = this.mFragmentManager; fragmentManager.performPendingDeferredStart(fragmentManager.createOrGetFragmentStateManager(this)); } this.mUserVisibleHint = z2; this.mDeferStart = this.mState < 5 && !z2; if (this.mSavedFragmentState != null) { this.mSavedUserVisibleHint = Boolean.valueOf(z2); } } public boolean shouldShowRequestPermissionRationale(@NonNull String str) { FragmentHostCallback fragmentHostCallback = this.mHost; if (fragmentHostCallback != null) { return fragmentHostCallback.onShouldShowRequestPermissionRationale(str); } return false; } public void startActivity(@SuppressLint({"UnknownNullness"}) Intent intent) { startActivity(intent, null); } @Deprecated public void startActivityForResult(@SuppressLint({"UnknownNullness"}) Intent intent, int i2) { startActivityForResult(intent, i2, null); } @Deprecated public void startIntentSenderForResult(@SuppressLint({"UnknownNullness"}) IntentSender intentSender, int i2, @Nullable Intent intent, int i3, int i4, int i5, @Nullable Bundle bundle) throws IntentSender.SendIntentException { if (this.mHost == null) { throw new IllegalStateException("Fragment " + this + " not attached to Activity"); } if (FragmentManager.isLoggingEnabled(2)) { Log.v("FragmentManager", "Fragment " + this + " received the following in startIntentSenderForResult() requestCode: " + i2 + " IntentSender: " + intentSender + " fillInIntent: " + intent + " options: " + bundle); } getParentFragmentManager().launchStartIntentSenderForResult(this, intentSender, i2, intent, i3, i4, i5, bundle); } public void startPostponedEnterTransition() { if (this.mAnimationInfo == null || !ensureAnimationInfo().mEnterTransitionPostponed) { return; } if (this.mHost == null) { ensureAnimationInfo().mEnterTransitionPostponed = false; } else if (Looper.myLooper() != this.mHost.getHandler().getLooper()) { this.mHost.getHandler().postAtFrontOfQueue(new Runnable() { // from class: androidx.fragment.app.Fragment.2 @Override // java.lang.Runnable public void run() { Fragment.this.callStartTransitionListener(false); } }); } else { callStartTransitionListener(true); } } @NonNull public String toString() { StringBuilder sb = new StringBuilder(128); sb.append(getClass().getSimpleName()); sb.append("{"); sb.append(Integer.toHexString(System.identityHashCode(this))); sb.append("}"); sb.append(" ("); sb.append(this.mWho); if (this.mFragmentId != 0) { sb.append(" id=0x"); sb.append(Integer.toHexString(this.mFragmentId)); } if (this.mTag != null) { sb.append(" tag="); sb.append(this.mTag); } sb.append(")"); return sb.toString(); } public void unregisterForContextMenu(@NonNull View view) { view.setOnCreateContextMenuListener(null); } @SuppressLint({"BanParcelableUsage, ParcelClassLoader"}) public static class SavedState implements Parcelable { @NonNull public static final Parcelable.Creator CREATOR = new Parcelable.ClassLoaderCreator() { // from class: androidx.fragment.app.Fragment.SavedState.1 @Override // android.os.Parcelable.Creator public SavedState[] newArray(int i2) { return new SavedState[i2]; } @Override // android.os.Parcelable.Creator public SavedState createFromParcel(Parcel parcel) { return new SavedState(parcel, null); } /* JADX WARN: Can't rename method to resolve collision */ @Override // android.os.Parcelable.ClassLoaderCreator public SavedState createFromParcel(Parcel parcel, ClassLoader classLoader) { return new SavedState(parcel, classLoader); } }; final Bundle mState; SavedState(Bundle bundle) { this.mState = bundle; } @Override // android.os.Parcelable public int describeContents() { return 0; } @Override // android.os.Parcelable public void writeToParcel(@NonNull Parcel parcel, int i2) { parcel.writeBundle(this.mState); } SavedState(@NonNull Parcel parcel, @Nullable ClassLoader classLoader) { Bundle bundle = parcel.readBundle(); this.mState = bundle; if (classLoader == null || bundle == null) { return; } bundle.setClassLoader(classLoader); } } @NonNull @Deprecated public static Fragment instantiate(@NonNull Context context, @NonNull String str, @Nullable Bundle bundle) { try { Fragment fragmentNewInstance = FragmentFactory.loadFragmentClass(context.getClassLoader(), str).getConstructor(null).newInstance(null); if (bundle != null) { bundle.setClassLoader(fragmentNewInstance.getClass().getClassLoader()); fragmentNewInstance.setArguments(bundle); } return fragmentNewInstance; } catch (IllegalAccessException e2) { throw new InstantiationException("Unable to instantiate fragment " + str + ": make sure class name exists, is public, and has an empty constructor that is public", e2); } catch (java.lang.InstantiationException e3) { throw new InstantiationException("Unable to instantiate fragment " + str + ": make sure class name exists, is public, and has an empty constructor that is public", e3); } catch (NoSuchMethodException e4) { throw new InstantiationException("Unable to instantiate fragment " + str + ": could not find Fragment constructor", e4); } catch (InvocationTargetException e5) { throw new InstantiationException("Unable to instantiate fragment " + str + ": calling Fragment constructor caused an exception", e5); } } @NonNull public final String getString(@StringRes int i2, @Nullable Object... objArr) { return getResources().getString(i2, objArr); } public final void postponeEnterTransition(long j2, @NonNull TimeUnit timeUnit) { ensureAnimationInfo().mEnterTransitionPostponed = true; FragmentManager fragmentManager = this.mFragmentManager; Handler handler = fragmentManager != null ? fragmentManager.getHost().getHandler() : new Handler(Looper.getMainLooper()); handler.removeCallbacks(this.mPostponedDurationRunnable); handler.postDelayed(this.mPostponedDurationRunnable, timeUnit.toMillis(j2)); } @Override // androidx.activity.result.ActivityResultCaller @NonNull @MainThread public final ActivityResultLauncher registerForActivityResult(@NonNull ActivityResultContract activityResultContract, @NonNull final ActivityResultRegistry activityResultRegistry, @NonNull ActivityResultCallback activityResultCallback) { return prepareCallInternal(activityResultContract, new Function() { // from class: androidx.fragment.app.Fragment.7 @Override // androidx.arch.core.util.Function public ActivityResultRegistry apply(Void r12) { return activityResultRegistry; } }, activityResultCallback); } public void startActivity(@SuppressLint({"UnknownNullness"}) Intent intent, @Nullable Bundle bundle) { FragmentHostCallback fragmentHostCallback = this.mHost; if (fragmentHostCallback != null) { fragmentHostCallback.onStartActivityFromFragment(this, intent, -1, bundle); return; } throw new IllegalStateException("Fragment " + this + " not attached to Activity"); } @Deprecated public void startActivityForResult(@SuppressLint({"UnknownNullness"}) Intent intent, int i2, @Nullable Bundle bundle) { if (this.mHost != null) { getParentFragmentManager().launchStartActivityForResult(this, intent, i2, bundle); return; } throw new IllegalStateException("Fragment " + this + " not attached to Activity"); } @NonNull @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX}) @Deprecated public LayoutInflater getLayoutInflater(@Nullable Bundle bundle) { FragmentHostCallback fragmentHostCallback = this.mHost; if (fragmentHostCallback != null) { LayoutInflater layoutInflaterOnGetLayoutInflater = fragmentHostCallback.onGetLayoutInflater(); LayoutInflaterCompat.setFactory2(layoutInflaterOnGetLayoutInflater, this.mChildFragmentManager.getLayoutInflaterFactory()); return layoutInflaterOnGetLayoutInflater; } throw new IllegalStateException("onGetLayoutInflater() cannot be executed until the Fragment is attached to the FragmentManager."); } @CallSuper @MainThread @Deprecated public void onAttach(@NonNull Activity activity) { this.mCalled = true; } @CallSuper @UiThread @Deprecated public void onInflate(@NonNull Activity activity, @NonNull AttributeSet attributeSet, @Nullable Bundle bundle) { this.mCalled = true; } private void restoreViewState() { if (FragmentManager.isLoggingEnabled(3)) { Log.d("FragmentManager", "moveto RESTORE_VIEW_STATE: " + this); } if (this.mView != null) { restoreViewState(this.mSavedFragmentState); } this.mSavedFragmentState = null; } @ContentView public Fragment(@LayoutRes int i2) { this(); this.mContentLayoutId = i2; } }