content: package androidx.fragment.app;
  
  import android.animation.Animator;
  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.Build;
  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.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;
  import mt.Log1F380D;
  
  /* compiled from: 0005 */
  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;
      FragmentManager mChildFragmentManager;
      ViewGroup mContainer;
      int mContainerId;
      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<OnPreAttachedListener> mOnPreAttachedListeners;
      Fragment mParentFragment;
      boolean mPerformedCreateView;
      float mPostponedAlpha;
      Runnable mPostponedDurationRunnable;
      boolean mRemoving;
      boolean mRestored;
      boolean mRetainInstance;
      boolean mRetainInstanceChangedWhileDetached;
      Bundle mSavedFragmentState;
      SavedStateRegistryController mSavedStateRegistryController;
      Boolean mSavedUserVisibleHint;
      Bundle mSavedViewRegistryState;
      SparseArray<Parcelable> mSavedViewState;
      int mState;
      String mTag;
      Fragment mTarget;
      int mTargetRequestCode;
      String mTargetWho;
      boolean mUserVisibleHint;
      View mView;
      FragmentViewLifecycleOwner mViewLifecycleOwner;
      MutableLiveData<LifecycleOwner> mViewLifecycleOwnerLiveData;
      String mWho;
  
      static class AnimationInfo {
          Boolean mAllowEnterTransitionOverlap;
          Boolean mAllowReturnTransitionOverlap;
          View mAnimatingAway;
          Animator mAnimator;
          int mEnterAnim;
          Object mEnterTransition = null;
          SharedElementCallback mEnterTransitionCallback = null;
          boolean mEnterTransitionPostponed;
          int mExitAnim;
          Object mExitTransition = null;
          SharedElementCallback mExitTransitionCallback = null;
          View mFocusedView = null;
          boolean mIsHideReplaced;
          boolean mIsPop;
          int mNextTransition;
          int mPopEnterAnim;
          int mPopExitAnim;
          float mPostOnViewCreatedAlpha = 1.0f;
          Object mReenterTransition = Fragment.USE_DEFAULT_TRANSITION;
          Object mReturnTransition = Fragment.USE_DEFAULT_TRANSITION;
          Object mSharedElementEnterTransition = null;
          Object mSharedElementReturnTransition = Fragment.USE_DEFAULT_TRANSITION;
          ArrayList<String> mSharedElementSourceNames;
          ArrayList<String> mSharedElementTargetNames;
          OnStartEnterTransitionListener mStartEnterTransitionListener;
  
          AnimationInfo() {
          }
      }
  
      public static class InstantiationException extends RuntimeException {
          public InstantiationException(String msg, Exception cause) {
              super(msg, cause);
          }
      }
  
      private static abstract class OnPreAttachedListener {
          private OnPreAttachedListener() {
          }
  
          /* access modifiers changed from: package-private */
          public abstract void onPreAttached();
      }
  
      interface OnStartEnterTransitionListener {
          void onStartEnterTransition();
  
          void startListening();
      }
  
      public static class SavedState implements Parcelable {
          public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.ClassLoaderCreator<SavedState>() {
              public SavedState createFromParcel(Parcel in) {
                  return new SavedState(in, (ClassLoader) null);
              }
  
              public SavedState createFromParcel(Parcel in, ClassLoader loader) {
                  return new SavedState(in, loader);
              }
  
              public SavedState[] newArray(int size) {
                  return new SavedState[size];
              }
          };
          final Bundle mState;
  
          SavedState(Bundle state) {
              this.mState = state;
          }
  
          SavedState(Parcel in, ClassLoader loader) {
              Bundle readBundle = in.readBundle();
              this.mState = readBundle;
              if (loader != null && readBundle != null) {
                  readBundle.setClassLoader(loader);
              }
          }
  
          public int describeContents() {
              return 0;
          }
  
          public void writeToParcel(Parcel dest, int flags) {
              dest.writeBundle(this.mState);
          }
      }
  
      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() {
              public void run() {
                  Fragment.this.startPostponedEnterTransition();
              }
          };
          this.mMaxState = Lifecycle.State.RESUMED;
          this.mViewLifecycleOwnerLiveData = new MutableLiveData<>();
          this.mNextLocalRequestCode = new AtomicInteger();
          this.mOnPreAttachedListeners = new ArrayList<>();
          initLifecycle();
      }
  
      public Fragment(int contentLayoutId) {
          this();
          this.mContentLayoutId = contentLayoutId;
      }
  
      private AnimationInfo ensureAnimationInfo() {
          if (this.mAnimationInfo == null) {
              this.mAnimationInfo = new AnimationInfo();
          }
          return this.mAnimationInfo;
      }
  
      private int getMinimumMaxLifecycleState() {
          return (this.mMaxState == Lifecycle.State.INITIALIZED || this.mParentFragment == null) ? this.mMaxState.ordinal() : Math.min(this.mMaxState.ordinal(), this.mParentFragment.getMinimumMaxLifecycleState());
      }
  
      private void initLifecycle() {
          this.mLifecycleRegistry = new LifecycleRegistry(this);
          this.mSavedStateRegistryController = SavedStateRegistryController.create(this);
          this.mDefaultFactory = null;
      }
  
      @Deprecated
      public static Fragment instantiate(Context context, String fname) {
          return instantiate(context, fname, (Bundle) null);
      }
  
      @Deprecated
      public static Fragment instantiate(Context context, String fname, Bundle args) {
          try {
              Fragment fragment = (Fragment) FragmentFactory.loadFragmentClass(context.getClassLoader(), fname).getConstructor(new Class[0]).newInstance(new Object[0]);
              if (args != null) {
                  args.setClassLoader(fragment.getClass().getClassLoader());
                  fragment.setArguments(args);
              }
              return fragment;
          } catch (InstantiationException e) {
              throw new InstantiationException("Unable to instantiate fragment " + fname + ": make sure class name exists, is public, and has an empty constructor that is public", e);
          } catch (IllegalAccessException e2) {
              throw new InstantiationException("Unable to instantiate fragment " + fname + ": make sure class name exists, is public, and has an empty constructor that is public", e2);
          } catch (NoSuchMethodException e3) {
              throw new InstantiationException("Unable to instantiate fragment " + fname + ": could not find Fragment constructor", e3);
          } catch (InvocationTargetException e4) {
              throw new InstantiationException("Unable to instantiate fragment " + fname + ": calling Fragment constructor caused an exception", e4);
          }
      }
  
      private <I, O> ActivityResultLauncher<I> prepareCallInternal(final ActivityResultContract<I, O> activityResultContract, Function<Void, ActivityResultRegistry> function, ActivityResultCallback<O> activityResultCallback) {
          if (this.mState <= 1) {
              final AtomicReference atomicReference = new AtomicReference();
              final Function<Void, ActivityResultRegistry> function2 = function;
              final AtomicReference atomicReference2 = atomicReference;
              final ActivityResultContract<I, O> activityResultContract2 = activityResultContract;
              final ActivityResultCallback<O> activityResultCallback2 = activityResultCallback;
              registerOnPreAttachListener(new OnPreAttachedListener() {
                  /* access modifiers changed from: package-private */
                  public void onPreAttached() {
                      atomicReference2.set(((ActivityResultRegistry) function2.apply(null)).register(Fragment.this.generateActivityResultKey(), Fragment.this, activityResultContract2, activityResultCallback2));
                  }
              });
              return new ActivityResultLauncher<I>() {
                  public ActivityResultContract<I, ?> getContract() {
                      return activityResultContract;
                  }
  
                  public void launch(I i, ActivityOptionsCompat options) {
                      ActivityResultLauncher activityResultLauncher = (ActivityResultLauncher) atomicReference.get();
                      if (activityResultLauncher != null) {
                          activityResultLauncher.launch(i, options);
                          return;
                      }
                      throw new IllegalStateException("Operation cannot be started before fragment is in created state");
                  }
  
                  public void unregister() {
                      ActivityResultLauncher activityResultLauncher = (ActivityResultLauncher) atomicReference.getAndSet((Object) 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(OnPreAttachedListener callback) {
          if (this.mState >= 0) {
              callback.onPreAttached();
          } else {
              this.mOnPreAttachedListeners.add(callback);
          }
      }
  
      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;
      }
  
      /* access modifiers changed from: package-private */
      public void callStartTransitionListener(boolean calledDirectly) {
          OnStartEnterTransitionListener onStartEnterTransitionListener;
          ViewGroup viewGroup;
          FragmentManager fragmentManager;
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              onStartEnterTransitionListener = null;
          } else {
              animationInfo.mEnterTransitionPostponed = false;
              onStartEnterTransitionListener = this.mAnimationInfo.mStartEnterTransitionListener;
              this.mAnimationInfo.mStartEnterTransitionListener = null;
          }
          if (onStartEnterTransitionListener != null) {
              onStartEnterTransitionListener.onStartEnterTransition();
          } else if (FragmentManager.USE_STATE_MANAGER && this.mView != null && (viewGroup = this.mContainer) != null && (fragmentManager = this.mFragmentManager) != null) {
              final SpecialEffectsController orCreateController = SpecialEffectsController.getOrCreateController(viewGroup, fragmentManager);
              orCreateController.markPostponedState();
              if (calledDirectly) {
                  this.mHost.getHandler().post(new Runnable() {
                      public void run() {
                          orCreateController.executePendingOperations();
                      }
                  });
              } else {
                  orCreateController.executePendingOperations();
              }
          }
      }
  
      /* access modifiers changed from: package-private */
      public FragmentContainer createFragmentContainer() {
          return new FragmentContainer() {
              public View onFindViewById(int id) {
                  if (Fragment.this.mView != null) {
                      return Fragment.this.mView.findViewById(id);
                  }
                  throw new IllegalStateException("Fragment " + Fragment.this + " does not have a view");
              }
  
              public boolean onHasView() {
                  return Fragment.this.mView != null;
              }
          };
      }
  
      public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
          writer.print(prefix);
          writer.print("mFragmentId=#");
          String hexString = Integer.toHexString(this.mFragmentId);
          Log1F380D.a((Object) hexString);
          writer.print(hexString);
          writer.print(" mContainerId=#");
          String hexString2 = Integer.toHexString(this.mContainerId);
          Log1F380D.a((Object) hexString2);
          writer.print(hexString2);
          writer.print(" mTag=");
          writer.println(this.mTag);
          writer.print(prefix);
          writer.print("mState=");
          writer.print(this.mState);
          writer.print(" mWho=");
          writer.print(this.mWho);
          writer.print(" mBackStackNesting=");
          writer.println(this.mBackStackNesting);
          writer.print(prefix);
          writer.print("mAdded=");
          writer.print(this.mAdded);
          writer.print(" mRemoving=");
          writer.print(this.mRemoving);
          writer.print(" mFromLayout=");
          writer.print(this.mFromLayout);
          writer.print(" mInLayout=");
          writer.println(this.mInLayout);
          writer.print(prefix);
          writer.print("mHidden=");
          writer.print(this.mHidden);
          writer.print(" mDetached=");
          writer.print(this.mDetached);
          writer.print(" mMenuVisible=");
          writer.print(this.mMenuVisible);
          writer.print(" mHasMenu=");
          writer.println(this.mHasMenu);
          writer.print(prefix);
          writer.print("mRetainInstance=");
          writer.print(this.mRetainInstance);
          writer.print(" mUserVisibleHint=");
          writer.println(this.mUserVisibleHint);
          if (this.mFragmentManager != null) {
              writer.print(prefix);
              writer.print("mFragmentManager=");
              writer.println(this.mFragmentManager);
          }
          if (this.mHost != null) {
              writer.print(prefix);
              writer.print("mHost=");
              writer.println(this.mHost);
          }
          if (this.mParentFragment != null) {
              writer.print(prefix);
              writer.print("mParentFragment=");
              writer.println(this.mParentFragment);
          }
          if (this.mArguments != null) {
              writer.print(prefix);
              writer.print("mArguments=");
              writer.println(this.mArguments);
          }
          if (this.mSavedFragmentState != null) {
              writer.print(prefix);
              writer.print("mSavedFragmentState=");
              writer.println(this.mSavedFragmentState);
          }
          if (this.mSavedViewState != null) {
              writer.print(prefix);
              writer.print("mSavedViewState=");
              writer.println(this.mSavedViewState);
          }
          if (this.mSavedViewRegistryState != null) {
              writer.print(prefix);
              writer.print("mSavedViewRegistryState=");
              writer.println(this.mSavedViewRegistryState);
          }
          Fragment targetFragment = getTargetFragment();
          if (targetFragment != null) {
              writer.print(prefix);
              writer.print("mTarget=");
              writer.print(targetFragment);
              writer.print(" mTargetRequestCode=");
              writer.println(this.mTargetRequestCode);
          }
          writer.print(prefix);
          writer.print("mPopDirection=");
          writer.println(getPopDirection());
          if (getEnterAnim() != 0) {
              writer.print(prefix);
              writer.print("getEnterAnim=");
              writer.println(getEnterAnim());
          }
          if (getExitAnim() != 0) {
              writer.print(prefix);
              writer.print("getExitAnim=");
              writer.println(getExitAnim());
          }
          if (getPopEnterAnim() != 0) {
              writer.print(prefix);
              writer.print("getPopEnterAnim=");
              writer.println(getPopEnterAnim());
          }
          if (getPopExitAnim() != 0) {
              writer.print(prefix);
              writer.print("getPopExitAnim=");
              writer.println(getPopExitAnim());
          }
          if (this.mContainer != null) {
              writer.print(prefix);
              writer.print("mContainer=");
              writer.println(this.mContainer);
          }
          if (this.mView != null) {
              writer.print(prefix);
              writer.print("mView=");
              writer.println(this.mView);
          }
          if (getAnimatingAway() != null) {
              writer.print(prefix);
              writer.print("mAnimatingAway=");
              writer.println(getAnimatingAway());
          }
          if (getContext() != null) {
              LoaderManager.getInstance(this).dump(prefix, fd, writer, args);
          }
          writer.print(prefix);
          writer.println("Child " + this.mChildFragmentManager + ":");
          this.mChildFragmentManager.dump(prefix + "  ", fd, writer, args);
      }
  
      public final boolean equals(Object o) {
          return super.equals(o);
      }
  
      /* access modifiers changed from: package-private */
      public Fragment findFragmentByWho(String who) {
          return who.equals(this.mWho) ? this : this.mChildFragmentManager.findFragmentByWho(who);
      }
  
      /* access modifiers changed from: package-private */
      public String generateActivityResultKey() {
          return "fragment_" + this.mWho + "_rq#" + this.mNextLocalRequestCode.getAndIncrement();
      }
  
      public final FragmentActivity getActivity() {
          FragmentHostCallback<?> fragmentHostCallback = this.mHost;
          if (fragmentHostCallback == null) {
              return null;
          }
          return (FragmentActivity) fragmentHostCallback.getActivity();
      }
  
      public boolean getAllowEnterTransitionOverlap() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null || animationInfo.mAllowEnterTransitionOverlap == null) {
              return true;
          }
          return this.mAnimationInfo.mAllowEnterTransitionOverlap.booleanValue();
      }
  
      public boolean getAllowReturnTransitionOverlap() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null || animationInfo.mAllowReturnTransitionOverlap == null) {
              return true;
          }
          return this.mAnimationInfo.mAllowReturnTransitionOverlap.booleanValue();
      }
  
      /* access modifiers changed from: package-private */
      public View getAnimatingAway() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mAnimatingAway;
      }
  
      /* access modifiers changed from: package-private */
      public Animator getAnimator() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mAnimator;
      }
  
      public final Bundle getArguments() {
          return this.mArguments;
      }
  
      public final FragmentManager getChildFragmentManager() {
          if (this.mHost != null) {
              return this.mChildFragmentManager;
          }
          throw new IllegalStateException("Fragment " + this + " has not been attached yet.");
      }
  
      public Context getContext() {
          FragmentHostCallback<?> fragmentHostCallback = this.mHost;
          if (fragmentHostCallback == null) {
              return null;
          }
          return fragmentHostCallback.getContext();
      }
  
      public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
          if (this.mFragmentManager != null) {
              if (this.mDefaultFactory == null) {
                  Application application = null;
                  Context context = requireContext().getApplicationContext();
                  while (true) {
                      if (!(context instanceof ContextWrapper)) {
                          break;
                      } else if (context instanceof Application) {
                          application = (Application) context;
                          break;
                      } else {
                          context = ((ContextWrapper) context).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;
          }
          throw new IllegalStateException("Can't access ViewModels from detached fragment");
      }
  
      /* access modifiers changed from: package-private */
      public int getEnterAnim() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return 0;
          }
          return animationInfo.mEnterAnim;
      }
  
      public Object getEnterTransition() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mEnterTransition;
      }
  
      /* access modifiers changed from: package-private */
      public SharedElementCallback getEnterTransitionCallback() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mEnterTransitionCallback;
      }
  
      /* access modifiers changed from: package-private */
      public int getExitAnim() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return 0;
          }
          return animationInfo.mExitAnim;
      }
  
      public Object getExitTransition() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mExitTransition;
      }
  
      /* access modifiers changed from: package-private */
      public SharedElementCallback getExitTransitionCallback() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mExitTransitionCallback;
      }
  
      /* access modifiers changed from: package-private */
      public View getFocusedView() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mFocusedView;
      }
  
      @Deprecated
      public final FragmentManager getFragmentManager() {
          return this.mFragmentManager;
      }
  
      public final Object getHost() {
          FragmentHostCallback<?> fragmentHostCallback = this.mHost;
          if (fragmentHostCallback == null) {
              return null;
          }
          return fragmentHostCallback.onGetHost();
      }
  
      public final int getId() {
          return this.mFragmentId;
      }
  
      public final LayoutInflater getLayoutInflater() {
          LayoutInflater layoutInflater = this.mLayoutInflater;
          return layoutInflater == null ? performGetLayoutInflater((Bundle) null) : layoutInflater;
      }
  
      @Deprecated
      public LayoutInflater getLayoutInflater(Bundle savedFragmentState) {
          FragmentHostCallback<?> fragmentHostCallback = this.mHost;
          if (fragmentHostCallback != null) {
              LayoutInflater onGetLayoutInflater = fragmentHostCallback.onGetLayoutInflater();
              LayoutInflaterCompat.setFactory2(onGetLayoutInflater, this.mChildFragmentManager.getLayoutInflaterFactory());
              return onGetLayoutInflater;
          }
          throw new IllegalStateException("onGetLayoutInflater() cannot be executed until the Fragment is attached to the FragmentManager.");
      }
  
      public Lifecycle getLifecycle() {
          return this.mLifecycleRegistry;
      }
  
      @Deprecated
      public LoaderManager getLoaderManager() {
          return LoaderManager.getInstance(this);
      }
  
      /* access modifiers changed from: package-private */
      public int getNextTransition() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return 0;
          }
          return animationInfo.mNextTransition;
      }
  
      public final Fragment getParentFragment() {
          return this.mParentFragment;
      }
  
      public final FragmentManager getParentFragmentManager() {
          FragmentManager fragmentManager = this.mFragmentManager;
          if (fragmentManager != null) {
              return fragmentManager;
          }
          throw new IllegalStateException("Fragment " + this + " not associated with a fragment manager.");
      }
  
      /* access modifiers changed from: package-private */
      public boolean getPopDirection() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return false;
          }
          return animationInfo.mIsPop;
      }
  
      /* access modifiers changed from: package-private */
      public int getPopEnterAnim() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return 0;
          }
          return animationInfo.mPopEnterAnim;
      }
  
      /* access modifiers changed from: package-private */
      public int getPopExitAnim() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return 0;
          }
          return animationInfo.mPopExitAnim;
      }
  
      /* access modifiers changed from: package-private */
      public float getPostOnViewCreatedAlpha() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return 1.0f;
          }
          return animationInfo.mPostOnViewCreatedAlpha;
      }
  
      public Object getReenterTransition() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mReenterTransition == USE_DEFAULT_TRANSITION ? getExitTransition() : this.mAnimationInfo.mReenterTransition;
      }
  
      public final Resources getResources() {
          return requireContext().getResources();
      }
  
      @Deprecated
      public final boolean getRetainInstance() {
          return this.mRetainInstance;
      }
  
      public Object getReturnTransition() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mReturnTransition == USE_DEFAULT_TRANSITION ? getEnterTransition() : this.mAnimationInfo.mReturnTransition;
      }
  
      public final SavedStateRegistry getSavedStateRegistry() {
          return this.mSavedStateRegistryController.getSavedStateRegistry();
      }
  
      public Object getSharedElementEnterTransition() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mSharedElementEnterTransition;
      }
  
      public Object getSharedElementReturnTransition() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return null;
          }
          return animationInfo.mSharedElementReturnTransition == USE_DEFAULT_TRANSITION ? getSharedElementEnterTransition() : this.mAnimationInfo.mSharedElementReturnTransition;
      }
  
      /* access modifiers changed from: package-private */
      public ArrayList<String> getSharedElementSourceNames() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          return (animationInfo == null || animationInfo.mSharedElementSourceNames == null) ? new ArrayList<>() : this.mAnimationInfo.mSharedElementSourceNames;
      }
  
      /* access modifiers changed from: package-private */
      public ArrayList<String> getSharedElementTargetNames() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          return (animationInfo == null || animationInfo.mSharedElementTargetNames == null) ? new ArrayList<>() : this.mAnimationInfo.mSharedElementTargetNames;
      }
  
      public final String getString(int resId) {
          return getResources().getString(resId);
      }
  
      public final String getString(int resId, Object... formatArgs) {
          return getResources().getString(resId, formatArgs);
      }
  
      public final String getTag() {
          return this.mTag;
      }
  
      @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;
      }
  
      public final CharSequence getText(int resId) {
          return getResources().getText(resId);
      }
  
      @Deprecated
      public boolean getUserVisibleHint() {
          return this.mUserVisibleHint;
      }
  
      public View getView() {
          return this.mView;
      }
  
      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()");
      }
  
      public LiveData<LifecycleOwner> getViewLifecycleOwnerLiveData() {
          return this.mViewLifecycleOwnerLiveData;
      }
  
      public ViewModelStore getViewModelStore() {
          if (this.mFragmentManager == null) {
              throw new IllegalStateException("Can't access ViewModels from detached fragment");
          } else if (getMinimumMaxLifecycleState() != Lifecycle.State.INITIALIZED.ordinal()) {
              return this.mFragmentManager.getViewModelStore(this);
          } else {
              throw new IllegalStateException("Calling getViewModelStore() before a Fragment reaches onCreate() when using setMaxLifecycle(INITIALIZED) is not supported");
          }
      }
  
      public final boolean hasOptionsMenu() {
          return this.mHasMenu;
      }
  
      public final int hashCode() {
          return super.hashCode();
      }
  
      /* access modifiers changed from: package-private */
      public 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;
      }
  
      /* access modifiers changed from: package-private */
      public boolean isHideReplaced() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return false;
          }
          return animationInfo.mIsHideReplaced;
      }
  
      /* access modifiers changed from: package-private */
      public final boolean isInBackStack() {
          return this.mBackStackNesting > 0;
      }
  
      public final boolean isInLayout() {
          return this.mInLayout;
      }
  
      /* JADX WARNING: Code restructure failed: missing block: B:2:0x0004, code lost:
          r0 = r2.mFragmentManager;
       */
      /* Code decompiled incorrectly, please refer to instructions dump. */
      public final boolean isMenuVisible() {
          /*
              r2 = this;
              boolean r0 = r2.mMenuVisible
              if (r0 == 0) goto L_0x0012
              androidx.fragment.app.FragmentManager r0 = r2.mFragmentManager
              if (r0 == 0) goto L_0x0010
              androidx.fragment.app.Fragment r1 = r2.mParentFragment
              boolean r0 = r0.isParentMenuVisible(r1)
              if (r0 == 0) goto L_0x0012
          L_0x0010:
              r0 = 1
              goto L_0x0013
          L_0x0012:
              r0 = 0
          L_0x0013:
              return r0
          */
          throw new UnsupportedOperationException("Method not decompiled: androidx.fragment.app.Fragment.isMenuVisible():boolean");
      }
  
      /* access modifiers changed from: package-private */
      public boolean isPostponed() {
          AnimationInfo animationInfo = this.mAnimationInfo;
          if (animationInfo == null) {
              return false;
          }
          return animationInfo.mEnterTransitionPostponed;
      }
  
      public final boolean isRemoving() {
          return this.mRemoving;
      }
  
      /* access modifiers changed from: package-private */
      public 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();
      }
  
      /* JADX WARNING: Code restructure failed: missing block: B:4:0x000c, code lost:
          r0 = r1.mView;
       */
      /* Code decompiled incorrectly, please refer to instructions dump. */
      public final boolean isVisible() {
          /*
              r1 = this;
              boolean r0 = r1.isAdded()
              if (r0 == 0) goto L_0x0020
              boolean r0 = r1.isHidden()
              if (r0 != 0) goto L_0x0020
              android.view.View r0 = r1.mView
              if (r0 == 0) goto L_0x0020
              android.os.IBinder r0 = r0.getWindowToken()
              if (r0 == 0) goto L_0x0020
              android.view.View r0 = r1.mView
              int r0 = r0.getVisibility()
              if (r0 != 0) goto L_0x0020
              r0 = 1
              goto L_0x0021
          L_0x0020:
              r0 = 0
          L_0x0021:
              return r0
          */
          throw new UnsupportedOperationException("Method not decompiled: androidx.fragment.app.Fragment.isVisible():boolean");
      }
  
      /* access modifiers changed from: package-private */
      public void noteStateNotSaved() {
          this.mChildFragmentManager.noteStateNotSaved();
      }
  
      @Deprecated
      public void onActivityCreated(Bundle savedInstanceState) {
          this.mCalled = true;
      }
  
      @Deprecated
      public void onActivityResult(int requestCode, int resultCode, Intent data) {
          if (FragmentManager.isLoggingEnabled(2)) {
              Log.v("FragmentManager", "Fragment " + this + " received the following in onActivityResult(): requestCode: " + requestCode + " resultCode: " + resultCode + " data: " + data);
          }
      }
  
      @Deprecated
      public void onAttach(Activity activity) {
          this.mCalled = true;
      }
  
      public void onAttach(Context context) {
          this.mCalled = true;
          FragmentHostCallback<?> fragmentHostCallback = this.mHost;
          Activity activity = fragmentHostCallback == null ? null : fragmentHostCallback.getActivity();
          if (activity != null) {
              this.mCalled = false;
              onAttach(activity);
          }
      }
  
      @Deprecated
      public void onAttachFragment(Fragment childFragment) {
      }
  
      public void onConfigurationChanged(Configuration newConfig) {
          this.mCalled = true;
      }
  
      public boolean onContextItemSelected(MenuItem item) {
          return false;
      }
  
      public void onCreate(Bundle savedInstanceState) {
          this.mCalled = true;
          restoreChildFragmentState(savedInstanceState);
          if (!this.mChildFragmentManager.isStateAtLeast(1)) {
              this.mChildFragmentManager.dispatchCreate();
          }
      }
  
      public Animation onCreateAnimation(int transit, boolean enter, int nextAnim) {
          return null;
      }
  
      public Animator onCreateAnimator(int transit, boolean enter, int nextAnim) {
          return null;
      }
  
      public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
          requireActivity().onCreateContextMenu(menu, v, menuInfo);
      }
  
      public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
      }
  
      public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
          int i = this.mContentLayoutId;
          if (i != 0) {
              return inflater.inflate(i, container, false);
          }
          return null;
      }
  
      public void onDestroy() {
          this.mCalled = true;
      }
  
      public void onDestroyOptionsMenu() {
      }
  
      public void onDestroyView() {
          this.mCalled = true;
      }
  
      public void onDetach() {
          this.mCalled = true;
      }
  
      public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
          return getLayoutInflater(savedInstanceState);
      }
  
      public void onHiddenChanged(boolean hidden) {
      }
  
      @Deprecated
      public void onInflate(Activity activity, AttributeSet attrs, Bundle savedInstanceState) {
          this.mCalled = true;
      }
  
      public void onInflate(Context context, AttributeSet attrs, Bundle savedInstanceState) {
          this.mCalled = true;
          FragmentHostCallback<?> fragmentHostCallback = this.mHost;
          Activity activity = fragmentHostCallback == null ? null : fragmentHostCallback.getActivity();
          if (activity != null) {
              this.mCalled = false;
              onInflate(activity, attrs, savedInstanceState);
          }
      }
  
      public void onLowMemory() {
          this.mCalled = true;
      }
  
      public void onMultiWindowModeChanged(boolean isInMultiWindowMode) {
      }
  
      public boolean onOptionsItemSelected(MenuItem item) {
          return false;
      }
  
      public void onOptionsMenuClosed(Menu menu) {
      }
  
      public void onPause() {
          this.mCalled = true;
      }
  
      public void onPictureInPictureModeChanged(boolean isInPictureInPictureMode) {
      }
  
      public void onPrepareOptionsMenu(Menu menu) {
      }
  
      public void onPrimaryNavigationFragmentChanged(boolean isPrimaryNavigationFragment) {
      }
  
      @Deprecated
      public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
      }
  
      public void onResume() {
          this.mCalled = true;
      }
  
      public void onSaveInstanceState(Bundle outState) {
      }
  
      public void onStart() {
          this.mCalled = true;
      }
  
      public void onStop() {
          this.mCalled = true;
      }
  
      public void onViewCreated(View view, Bundle savedInstanceState) {
      }
  
      public void onViewStateRestored(Bundle savedInstanceState) {
          this.mCalled = true;
      }
  
      /* access modifiers changed from: package-private */
      public void performActivityCreated(Bundle savedInstanceState) {
          this.mChildFragmentManager.noteStateNotSaved();
          this.mState = 3;
          this.mCalled = false;
          onActivityCreated(savedInstanceState);
          if (this.mCalled) {
              restoreViewState();
              this.mChildFragmentManager.dispatchActivityCreated();
              return;
          }
          throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onActivityCreated()");
      }
  
      /* access modifiers changed from: package-private */
      public void performAttach() {
          Iterator<OnPreAttachedListener> 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();
              return;
          }
          throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onAttach()");
      }
  
      /* access modifiers changed from: package-private */
      public void performConfigurationChanged(Configuration newConfig) {
          onConfigurationChanged(newConfig);
          this.mChildFragmentManager.dispatchConfigurationChanged(newConfig);
      }
  
      /* access modifiers changed from: package-private */
      public boolean performContextItemSelected(MenuItem item) {
          if (this.mHidden) {
              return false;
          }
          if (onContextItemSelected(item)) {
              return true;
          }
          return this.mChildFragmentManager.dispatchContextItemSelected(item);
      }
  
      /* access modifiers changed from: package-private */
      public void performCreate(Bundle savedInstanceState) {
          this.mChildFragmentManager.noteStateNotSaved();
          this.mState = 1;
          this.mCalled = false;
          if (Build.VERSION.SDK_INT >= 19) {
              this.mLifecycleRegistry.addObserver(new LifecycleEventObserver() {
                  public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
                      if (event == Lifecycle.Event.ON_STOP && Fragment.this.mView != null) {
                          Fragment.this.mView.cancelPendingInputEvents();
                      }
                  }
              });
          }
          this.mSavedStateRegistryController.performRestore(savedInstanceState);
          onCreate(savedInstanceState);
          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()");
      }
  
      /* access modifiers changed from: package-private */
      public boolean performCreateOptionsMenu(Menu menu, MenuInflater inflater) {
          boolean z = false;
          if (this.mHidden) {
              return false;
          }
          if (this.mHasMenu && this.mMenuVisible) {
              z = true;
              onCreateOptionsMenu(menu, inflater);
          }
          return z | this.mChildFragmentManager.dispatchCreateOptionsMenu(menu, inflater);
      }
  
      /* access modifiers changed from: package-private */
      public void performCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
          this.mChildFragmentManager.noteStateNotSaved();
          this.mPerformedCreateView = true;
          this.mViewLifecycleOwner = new FragmentViewLifecycleOwner(this, getViewModelStore());
          View onCreateView = onCreateView(inflater, container, savedInstanceState);
          this.mView = onCreateView;
          if (onCreateView != null) {
              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);
          } else if (!this.mViewLifecycleOwner.isInitialized()) {
              this.mViewLifecycleOwner = null;
          } else {
              throw new IllegalStateException("Called getViewLifecycleOwner() but onCreateView() returned null");
          }
      }
  
      /* access modifiers changed from: package-private */
      public 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) {
              throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onDestroy()");
          }
      }
  
      /* access modifiers changed from: package-private */
      public 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;
              return;
          }
          throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onDestroyView()");
      }
  
      /* access modifiers changed from: package-private */
      public void performDetach() {
          this.mState = -1;
          this.mCalled = false;
          onDetach();
          this.mLayoutInflater = null;
          if (!this.mCalled) {
              throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onDetach()");
          } else if (!this.mChildFragmentManager.isDestroyed()) {
              this.mChildFragmentManager.dispatchDestroy();
              this.mChildFragmentManager = new FragmentManagerImpl();
          }
      }
  
      /* access modifiers changed from: package-private */
      public LayoutInflater performGetLayoutInflater(Bundle savedInstanceState) {
          LayoutInflater onGetLayoutInflater = onGetLayoutInflater(savedInstanceState);
          this.mLayoutInflater = onGetLayoutInflater;
          return onGetLayoutInflater;
      }
  
      /* access modifiers changed from: package-private */
      public void performLowMemory() {
          onLowMemory();
          this.mChildFragmentManager.dispatchLowMemory();
      }
  
      /* access modifiers changed from: package-private */
      public void performMultiWindowModeChanged(boolean isInMultiWindowMode) {
          onMultiWindowModeChanged(isInMultiWindowMode);
          this.mChildFragmentManager.dispatchMultiWindowModeChanged(isInMultiWindowMode);
      }
  
      /* access modifiers changed from: package-private */
      public boolean performOptionsItemSelected(MenuItem item) {
          if (this.mHidden) {
              return false;
          }
          if (!this.mHasMenu || !this.mMenuVisible || !onOptionsItemSelected(item)) {
              return this.mChildFragmentManager.dispatchOptionsItemSelected(item);
          }
          return true;
      }
  
      /* access modifiers changed from: package-private */
      public void performOptionsMenuClosed(Menu menu) {
          if (!this.mHidden) {
              if (this.mHasMenu && this.mMenuVisible) {
                  onOptionsMenuClosed(menu);
              }
              this.mChildFragmentManager.dispatchOptionsMenuClosed(menu);
          }
      }
  
      /* access modifiers changed from: package-private */
      public 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) {
              throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onPause()");
          }
      }
  
      /* access modifiers changed from: package-private */
      public void performPictureInPictureModeChanged(boolean isInPictureInPictureMode) {
          onPictureInPictureModeChanged(isInPictureInPictureMode);
          this.mChildFragmentManager.dispatchPictureInPictureModeChanged(isInPictureInPictureMode);
      }
  
      /* access modifiers changed from: package-private */
      public boolean performPrepareOptionsMenu(Menu menu) {
          boolean z = false;
          if (this.mHidden) {
              return false;
          }
          if (this.mHasMenu && this.mMenuVisible) {
              z = true;
              onPrepareOptionsMenu(menu);
          }
          return z | this.mChildFragmentManager.dispatchPrepareOptionsMenu(menu);
      }
  
      /* access modifiers changed from: package-private */
      public void performPrimaryNavigationFragmentChanged() {
          boolean isPrimaryNavigation = this.mFragmentManager.isPrimaryNavigation(this);
          Boolean bool = this.mIsPrimaryNavigationFragment;
          if (bool == null || bool.booleanValue() != isPrimaryNavigation) {
              this.mIsPrimaryNavigationFragment = Boolean.valueOf(isPrimaryNavigation);
              onPrimaryNavigationFragmentChanged(isPrimaryNavigation);
              this.mChildFragmentManager.dispatchPrimaryNavigationFragmentChanged();
          }
      }
  
      /* access modifiers changed from: package-private */
      public void performResume() {
          this.mChildFragmentManager.noteStateNotSaved();
          this.mChildFragmentManager.execPendingActions(true);
          this.mState = 7;
          this.mCalled = false;
          onResume();
          if (this.mCalled) {
              this.mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
              if (this.mView != null) {
                  this.mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
              }
              this.mChildFragmentManager.dispatchResume();
              return;
          }
          throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onResume()");
      }
  
      /* access modifiers changed from: package-private */
      public void performSaveInstanceState(Bundle outState) {
          onSaveInstanceState(outState);
          this.mSavedStateRegistryController.performSave(outState);
          Parcelable saveAllState = this.mChildFragmentManager.saveAllState();
          if (saveAllState != null) {
              outState.putParcelable("android:support:fragments", saveAllState);
          }
      }
  
      /* access modifiers changed from: package-private */
      public void performStart() {
          this.mChildFragmentManager.noteStateNotSaved();
          this.mChildFragmentManager.execPendingActions(true);
          this.mState = 5;
          this.mCalled = false;
          onStart();
          if (this.mCalled) {
              this.mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
              if (this.mView != null) {
                  this.mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_START);
              }
              this.mChildFragmentManager.dispatchStart();
              return;
          }
          throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onStart()");
      }
  
      /* access modifiers changed from: package-private */
      public 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) {
              throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onStop()");
          }
      }
  
      /* access modifiers changed from: package-private */
      public void performViewCreated() {
          onViewCreated(this.mView, this.mSavedFragmentState);
          this.mChildFragmentManager.dispatchViewCreated();
      }
  
      public void postponeEnterTransition() {
          ensureAnimationInfo().mEnterTransitionPostponed = true;
      }
  
      public final void postponeEnterTransition(long duration, 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(duration));
      }
  
      public final <I, O> ActivityResultLauncher<I> registerForActivityResult(ActivityResultContract<I, O> activityResultContract, ActivityResultCallback<O> activityResultCallback) {
          return prepareCallInternal(activityResultContract, new Function<Void, ActivityResultRegistry>() {
              public ActivityResultRegistry apply(Void input) {
                  return Fragment.this.mHost instanceof ActivityResultRegistryOwner ? ((ActivityResultRegistryOwner) Fragment.this.mHost).getActivityResultRegistry() : Fragment.this.requireActivity().getActivityResultRegistry();
              }
          }, activityResultCallback);
      }
  
      public final <I, O> ActivityResultLauncher<I> registerForActivityResult(ActivityResultContract<I, O> activityResultContract, final ActivityResultRegistry registry, ActivityResultCallback<O> activityResultCallback) {
          return prepareCallInternal(activityResultContract, new Function<Void, ActivityResultRegistry>() {
              public ActivityResultRegistry apply(Void input) {
                  return registry;
              }
          }, activityResultCallback);
      }
  
      public void registerForContextMenu(View view) {
          view.setOnCreateContextMenuListener(this);
      }
  
      @Deprecated
      public final void requestPermissions(String[] permissions, int requestCode) {
          if (this.mHost != null) {
              getParentFragmentManager().launchRequestPermissions(this, permissions, requestCode);
              return;
          }
          throw new IllegalStateException("Fragment " + this + " not attached to Activity");
      }
  
      public final FragmentActivity requireActivity() {
          FragmentActivity activity = getActivity();
          if (activity != null) {
              return activity;
          }
          throw new IllegalStateException("Fragment " + this + " not attached to an activity.");
      }
  
      public final Bundle requireArguments() {
          Bundle arguments = getArguments();
          if (arguments != null) {
              return arguments;
          }
          throw new IllegalStateException("Fragment " + this + " does not have any arguments.");
      }
  
      public final Context requireContext() {
          Context context = getContext();
          if (context != null) {
              return context;
          }
          throw new IllegalStateException("Fragment " + this + " not attached to a context.");
      }
  
      @Deprecated
      public final FragmentManager requireFragmentManager() {
          return getParentFragmentManager();
      }
  
      public final Object requireHost() {
          Object host = getHost();
          if (host != null) {
              return host;
          }
          throw new IllegalStateException("Fragment " + this + " not attached to a host.");
      }
  
      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());
      }
  
      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().");
      }
  
      /* access modifiers changed from: package-private */
      public void restoreChildFragmentState(Bundle savedInstanceState) {
          Parcelable parcelable;
          if (savedInstanceState != null && (parcelable = savedInstanceState.getParcelable("android:support:fragments")) != null) {
              this.mChildFragmentManager.restoreSaveState(parcelable);
              this.mChildFragmentManager.dispatchCreate();
          }
      }
  
      /* access modifiers changed from: package-private */
      public final void restoreViewState(Bundle savedInstanceState) {
          SparseArray<Parcelable> 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(savedInstanceState);
          if (!this.mCalled) {
              throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onViewStateRestored()");
          } else if (this.mView != null) {
              this.mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
          }
      }
  
      public void setAllowEnterTransitionOverlap(boolean allow) {
          ensureAnimationInfo().mAllowEnterTransitionOverlap = Boolean.valueOf(allow);
      }
  
      public void setAllowReturnTransitionOverlap(boolean allow) {
          ensureAnimationInfo().mAllowReturnTransitionOverlap = Boolean.valueOf(allow);
      }
  
      /* access modifiers changed from: package-private */
      public void setAnimatingAway(View view) {
          ensureAnimationInfo().mAnimatingAway = view;
      }
  
      /* access modifiers changed from: package-private */
      public void setAnimations(int enter, int exit, int popEnter, int popExit) {
          if (this.mAnimationInfo != null || enter != 0 || exit != 0 || popEnter != 0 || popExit != 0) {
              ensureAnimationInfo().mEnterAnim = enter;
              ensureAnimationInfo().mExitAnim = exit;
              ensureAnimationInfo().mPopEnterAnim = popEnter;
              ensureAnimationInfo().mPopExitAnim = popExit;
          }
      }
  
      /* access modifiers changed from: package-private */
      public void setAnimator(Animator animator) {
          ensureAnimationInfo().mAnimator = animator;
      }
  
      public void setArguments(Bundle args) {
          if (this.mFragmentManager == null || !isStateSaved()) {
              this.mArguments = args;
              return;
          }
          throw new IllegalStateException("Fragment already added and state has been saved");
      }
  
      public void setEnterSharedElementCallback(SharedElementCallback callback) {
          ensureAnimationInfo().mEnterTransitionCallback = callback;
      }
  
      public void setEnterTransition(Object transition) {
          ensureAnimationInfo().mEnterTransition = transition;
      }
  
      public void setExitSharedElementCallback(SharedElementCallback callback) {
          ensureAnimationInfo().mExitTransitionCallback = callback;
      }
  
      public void setExitTransition(Object transition) {
          ensureAnimationInfo().mExitTransition = transition;
      }
  
      /* access modifiers changed from: package-private */
      public void setFocusedView(View view) {
          ensureAnimationInfo().mFocusedView = view;
      }
  
      public void setHasOptionsMenu(boolean hasMenu) {
          if (this.mHasMenu != hasMenu) {
              this.mHasMenu = hasMenu;
              if (isAdded() && !isHidden()) {
                  this.mHost.onSupportInvalidateOptionsMenu();
              }
          }
      }
  
      /* access modifiers changed from: package-private */
      public void setHideReplaced(boolean replaced) {
          ensureAnimationInfo().mIsHideReplaced = replaced;
      }
  
      public void setInitialSavedState(SavedState state) {
          if (this.mFragmentManager == null) {
              this.mSavedFragmentState = (state == null || state.mState == null) ? null : state.mState;
              return;
          }
          throw new IllegalStateException("Fragment already added");
      }
  
      public void setMenuVisibility(boolean menuVisible) {
          if (this.mMenuVisible != menuVisible) {
              this.mMenuVisible = menuVisible;
              if (this.mHasMenu && isAdded() && !isHidden()) {
                  this.mHost.onSupportInvalidateOptionsMenu();
              }
          }
      }
  
      /* access modifiers changed from: package-private */
      public void setNextTransition(int nextTransition) {
          if (this.mAnimationInfo != null || nextTransition != 0) {
              ensureAnimationInfo();
              this.mAnimationInfo.mNextTransition = nextTransition;
          }
      }
  
      /* access modifiers changed from: package-private */
      public void setOnStartEnterTransitionListener(OnStartEnterTransitionListener listener) {
          ensureAnimationInfo();
          if (listener != this.mAnimationInfo.mStartEnterTransitionListener) {
              if (listener == null || this.mAnimationInfo.mStartEnterTransitionListener == null) {
                  if (this.mAnimationInfo.mEnterTransitionPostponed) {
                      this.mAnimationInfo.mStartEnterTransitionListener = listener;
                  }
                  if (listener != null) {
                      listener.startListening();
                      return;
                  }
                  return;
              }
              throw new IllegalStateException("Trying to set a replacement startPostponedEnterTransition on " + this);
          }
      }
  
      /* access modifiers changed from: package-private */
      public void setPopDirection(boolean isPop) {
          if (this.mAnimationInfo != null) {
              ensureAnimationInfo().mIsPop = isPop;
          }
      }
  
      /* access modifiers changed from: package-private */
      public void setPostOnViewCreatedAlpha(float alpha) {
          ensureAnimationInfo().mPostOnViewCreatedAlpha = alpha;
      }
  
      public void setReenterTransition(Object transition) {
          ensureAnimationInfo().mReenterTransition = transition;
      }
  
      @Deprecated
      public void setRetainInstance(boolean retain) {
          this.mRetainInstance = retain;
          FragmentManager fragmentManager = this.mFragmentManager;
          if (fragmentManager == null) {
              this.mRetainInstanceChangedWhileDetached = true;
          } else if (retain) {
              fragmentManager.addRetainedFragment(this);
          } else {
              fragmentManager.removeRetainedFragment(this);
          }
      }
  
      public void setReturnTransition(Object transition) {
          ensureAnimationInfo().mReturnTransition = transition;
      }
  
      public void setSharedElementEnterTransition(Object transition) {
          ensureAnimationInfo().mSharedElementEnterTransition = transition;
      }
  
      /* access modifiers changed from: package-private */
      public void setSharedElementNames(ArrayList<String> arrayList, ArrayList<String> arrayList2) {
          ensureAnimationInfo();
          this.mAnimationInfo.mSharedElementSourceNames = arrayList;
          this.mAnimationInfo.mSharedElementTargetNames = arrayList2;
      }
  
      public void setSharedElementReturnTransition(Object transition) {
          ensureAnimationInfo().mSharedElementReturnTransition = transition;
      }
  
      @Deprecated
      public void setTargetFragment(Fragment fragment, int requestCode) {
          FragmentManager fragmentManager = this.mFragmentManager;
          FragmentManager fragmentManager2 = fragment != null ? fragment.mFragmentManager : null;
          if (fragmentManager == null || fragmentManager2 == null || fragmentManager == fragmentManager2) {
              Fragment fragment2 = fragment;
              while (fragment2 != null) {
                  if (!fragment2.equals(this)) {
                      fragment2 = fragment2.getTargetFragment();
                  } else {
                      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 = requestCode;
              return;
          }
          throw new IllegalArgumentException("Fragment " + fragment + " must share the same FragmentManager to be set as a target fragment");
      }
  
      @Deprecated
      public void setUserVisibleHint(boolean isVisibleToUser) {
          if (!this.mUserVisibleHint && isVisibleToUser && this.mState < 5 && this.mFragmentManager != null && isAdded() && this.mIsCreated) {
              FragmentManager fragmentManager = this.mFragmentManager;
              fragmentManager.performPendingDeferredStart(fragmentManager.createOrGetFragmentStateManager(this));
          }
          this.mUserVisibleHint = isVisibleToUser;
          this.mDeferStart = this.mState < 5 && !isVisibleToUser;
          if (this.mSavedFragmentState != null) {
              this.mSavedUserVisibleHint = Boolean.valueOf(isVisibleToUser);
          }
      }
  
      public boolean shouldShowRequestPermissionRationale(String permission) {
          FragmentHostCallback<?> fragmentHostCallback = this.mHost;
          if (fragmentHostCallback != null) {
              return fragmentHostCallback.onShouldShowRequestPermissionRationale(permission);
          }
          return false;
      }
  
      public void startActivity(Intent intent) {
          startActivity(intent, (Bundle) null);
      }
  
      public void startActivity(Intent intent, Bundle options) {
          FragmentHostCallback<?> fragmentHostCallback = this.mHost;
          if (fragmentHostCallback != null) {
              fragmentHostCallback.onStartActivityFromFragment(this, intent, -1, options);
              return;
          }
          throw new IllegalStateException("Fragment " + this + " not attached to Activity");
      }
  
      @Deprecated
      public void startActivityForResult(Intent intent, int requestCode) {
          startActivityForResult(intent, requestCode, (Bundle) null);
      }
  
      @Deprecated
      public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
          if (this.mHost != null) {
              getParentFragmentManager().launchStartActivityForResult(this, intent, requestCode, options);
              return;
          }
          throw new IllegalStateException("Fragment " + this + " not attached to Activity");
      }
  
      @Deprecated
      public void startIntentSenderForResult(IntentSender intent, int requestCode, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) throws IntentSender.SendIntentException {
          if (this.mHost != null) {
              if (FragmentManager.isLoggingEnabled(2)) {
                  IntentSender intentSender = intent;
                  Log.v("FragmentManager", "Fragment " + this + " received the following in startIntentSenderForResult() requestCode: " + requestCode + " IntentSender: " + intent + " fillInIntent: " + fillInIntent + " options: " + options);
              } else {
                  IntentSender intentSender2 = intent;
                  int i = requestCode;
                  Intent intent2 = fillInIntent;
                  Bundle bundle = options;
              }
              getParentFragmentManager().launchStartIntentSenderForResult(this, intent, requestCode, fillInIntent, flagsMask, flagsValues, extraFlags, options);
              return;
          }
          IntentSender intentSender3 = intent;
          int i2 = requestCode;
          Intent intent3 = fillInIntent;
          Bundle bundle2 = options;
          throw new IllegalStateException("Fragment " + this + " not attached to Activity");
      }
  
      public void startPostponedEnterTransition() {
          if (this.mAnimationInfo != null && ensureAnimationInfo().mEnterTransitionPostponed) {
              if (this.mHost == null) {
                  ensureAnimationInfo().mEnterTransitionPostponed = false;
              } else if (Looper.myLooper() != this.mHost.getHandler().getLooper()) {
                  this.mHost.getHandler().postAtFrontOfQueue(new Runnable() {
                      public void run() {
                          Fragment.this.callStartTransitionListener(false);
                      }
                  });
              } else {
                  callStartTransitionListener(true);
              }
          }
      }
  
      public void unregisterForContextMenu(View view) {
          view.setOnCreateContextMenuListener((View.OnCreateContextMenuListener) null);
      }
  
      public String toString() {
          StringBuilder sb = new StringBuilder(128);
          sb.append(getClass().getSimpleName());
          sb.append("{");
          String hexString = Integer.toHexString(System.identityHashCode(this));
          Log1F380D.a((Object) hexString);
          sb.append(hexString);
          sb.append("}");
          sb.append(" (");
          sb.append(this.mWho);
          if (this.mFragmentId != 0) {
              sb.append(" id=0x");
              String hexString2 = Integer.toHexString(this.mFragmentId);
              Log1F380D.a((Object) hexString2);
              sb.append(hexString2);
          }
          if (this.mTag != null) {
              sb.append(" tag=");
              sb.append(this.mTag);
          }
          sb.append(")");
          return sb.toString();
      }
  }
  