2094 lines
66 KiB
Java
2094 lines
66 KiB
Java
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.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Looper;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.text.SpannableString;
|
|
import android.text.Spanned;
|
|
import android.text.SpannedString;
|
|
import android.text.TextUtils;
|
|
import android.util.AttributeSet;
|
|
import android.util.Base64;
|
|
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.core.app.SharedElementCallback;
|
|
import androidx.lifecycle.LiveData;
|
|
import com.airbnb.deeplinkdispatch.UrlTreeKt;
|
|
import java.io.FileDescriptor;
|
|
import java.io.PrintWriter;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.nio.charset.StandardCharsets;
|
|
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 o.AbstractC17389wOZ;
|
|
import o.AbstractC6423cSf;
|
|
import o.C0923Rqq;
|
|
import o.C16768rAP;
|
|
import o.C17072tgb;
|
|
import o.C17256vKb;
|
|
import o.C1982aTx;
|
|
import o.C7432coF;
|
|
import o.CVP;
|
|
import o.CWH;
|
|
import o.CeN;
|
|
import o.DYe;
|
|
import o.DyT;
|
|
import o.FNE;
|
|
import o.GvH;
|
|
import o.HLt;
|
|
import o.HeN;
|
|
import o.InterfaceC0834Plv;
|
|
import o.InterfaceC0940Ryk;
|
|
import o.InterfaceC16541pFg;
|
|
import o.InterfaceC3451axm;
|
|
import o.InterfaceC9254dgJ;
|
|
import o.LPk;
|
|
import o.NPK;
|
|
import o.RTE;
|
|
import o.VLM;
|
|
import o.Wax;
|
|
import o.Xdv;
|
|
import o.gFT;
|
|
import o.huo;
|
|
import o.iAz;
|
|
import o.mxa;
|
|
import o.sUv;
|
|
import o.vjh;
|
|
import o.wTJ;
|
|
import o.wdQ;
|
|
import o.yRS;
|
|
|
|
/* loaded from: classes.dex */
|
|
public class Fragment implements ComponentCallbacks, View.OnCreateContextMenuListener, InterfaceC0940Ryk, GvH, InterfaceC9254dgJ {
|
|
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;
|
|
static final int VIEW_CREATED = 2;
|
|
private static int c = 0;
|
|
private static byte d = 0;
|
|
private static int e = 1;
|
|
public boolean mAdded;
|
|
public Sts mAnimationInfo;
|
|
public Bundle mArguments;
|
|
public int mBackStackNesting;
|
|
public boolean mBeingSaved;
|
|
private boolean mCalled;
|
|
public yRS mChildFragmentManager;
|
|
public ViewGroup mContainer;
|
|
public int mContainerId;
|
|
private int mContentLayoutId;
|
|
public VLM.LWm mDefaultFactory;
|
|
public boolean mDeferStart;
|
|
public boolean mDetached;
|
|
public int mFragmentId;
|
|
public yRS mFragmentManager;
|
|
public boolean mFromLayout;
|
|
public boolean mHasMenu;
|
|
public boolean mHidden;
|
|
public boolean mHiddenChanged;
|
|
public vjh<?> mHost;
|
|
public boolean mInLayout;
|
|
public boolean mIsCreated;
|
|
private Boolean mIsPrimaryNavigationFragment;
|
|
LayoutInflater mLayoutInflater;
|
|
LPk mLifecycleRegistry;
|
|
public wdQ.IeS mMaxState;
|
|
public boolean mMenuVisible;
|
|
private final AtomicInteger mNextLocalRequestCode;
|
|
private final ArrayList<IeS> mOnPreAttachedListeners;
|
|
public Fragment mParentFragment;
|
|
public boolean mPerformedCreateView;
|
|
Runnable mPostponedDurationRunnable;
|
|
public String mPreviousWho;
|
|
public boolean mRemoving;
|
|
public boolean mRestored;
|
|
public boolean mRetainInstance;
|
|
public boolean mRetainInstanceChangedWhileDetached;
|
|
public Bundle mSavedFragmentState;
|
|
private final IeS mSavedStateAttachListener;
|
|
C7432coF mSavedStateRegistryController;
|
|
public Boolean mSavedUserVisibleHint;
|
|
public Bundle mSavedViewRegistryState;
|
|
public SparseArray<Parcelable> mSavedViewState;
|
|
public int mState;
|
|
public String mTag;
|
|
public Fragment mTarget;
|
|
public int mTargetRequestCode;
|
|
public String mTargetWho;
|
|
public boolean mUserVisibleHint;
|
|
public View mView;
|
|
public RTE mViewLifecycleOwner;
|
|
public HeN<InterfaceC16541pFg> mViewLifecycleOwnerLiveData;
|
|
public String mWho;
|
|
|
|
public final Bundle getArguments() {
|
|
return this.mArguments;
|
|
}
|
|
|
|
@Deprecated
|
|
public final yRS getFragmentManager() {
|
|
return this.mFragmentManager;
|
|
}
|
|
|
|
public final int getId() {
|
|
return this.mFragmentId;
|
|
}
|
|
|
|
@Override // o.InterfaceC16541pFg
|
|
public wdQ getLifecycle() {
|
|
return this.mLifecycleRegistry;
|
|
}
|
|
|
|
public final Fragment getParentFragment() {
|
|
return this.mParentFragment;
|
|
}
|
|
|
|
public final String getTag() {
|
|
return this.mTag;
|
|
}
|
|
|
|
@Deprecated
|
|
public boolean getUserVisibleHint() {
|
|
return this.mUserVisibleHint;
|
|
}
|
|
|
|
public View getView() {
|
|
return this.mView;
|
|
}
|
|
|
|
public LiveData<InterfaceC16541pFg> getViewLifecycleOwnerLiveData() {
|
|
return this.mViewLifecycleOwnerLiveData;
|
|
}
|
|
|
|
public final boolean hasOptionsMenu() {
|
|
return this.mHasMenu;
|
|
}
|
|
|
|
public final boolean isAdded() {
|
|
return this.mHost != null && this.mAdded;
|
|
}
|
|
|
|
public final boolean isDetached() {
|
|
return this.mDetached;
|
|
}
|
|
|
|
public final boolean isInBackStack() {
|
|
return this.mBackStackNesting > 0;
|
|
}
|
|
|
|
public final boolean isInLayout() {
|
|
return this.mInLayout;
|
|
}
|
|
|
|
public final boolean isRemoving() {
|
|
return this.mRemoving;
|
|
}
|
|
|
|
public final boolean isResumed() {
|
|
return this.mState >= 7;
|
|
}
|
|
|
|
@Deprecated
|
|
public void onActivityCreated(Bundle bundle) {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
@Deprecated
|
|
public void onAttach(Activity activity) {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
@Deprecated
|
|
public void onAttachFragment(Fragment fragment) {
|
|
}
|
|
|
|
@Override // android.content.ComponentCallbacks
|
|
public void onConfigurationChanged(Configuration configuration) {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
public boolean onContextItemSelected(MenuItem menuItem) {
|
|
return false;
|
|
}
|
|
|
|
public Animation onCreateAnimation(int i, boolean z, int i2) {
|
|
return null;
|
|
}
|
|
|
|
public Animator onCreateAnimator(int i, boolean z, int i2) {
|
|
return null;
|
|
}
|
|
|
|
@Deprecated
|
|
public void onCreateOptionsMenu(Menu menu, MenuInflater menuInflater) {
|
|
}
|
|
|
|
public void onDestroy() {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
@Deprecated
|
|
public void onDestroyOptionsMenu() {
|
|
}
|
|
|
|
public void onDestroyView() {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
public void onDetach() {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
public void onHiddenChanged(boolean z) {
|
|
}
|
|
|
|
@Deprecated
|
|
public void onInflate(Activity activity, AttributeSet attributeSet, Bundle bundle) {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
@Override // android.content.ComponentCallbacks
|
|
public void onLowMemory() {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
public void onMultiWindowModeChanged(boolean z) {
|
|
}
|
|
|
|
@Deprecated
|
|
public boolean onOptionsItemSelected(MenuItem menuItem) {
|
|
return false;
|
|
}
|
|
|
|
@Deprecated
|
|
public void onOptionsMenuClosed(Menu menu) {
|
|
}
|
|
|
|
public void onPause() {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
public void onPictureInPictureModeChanged(boolean z) {
|
|
}
|
|
|
|
@Deprecated
|
|
public void onPrepareOptionsMenu(Menu menu) {
|
|
}
|
|
|
|
public void onPrimaryNavigationFragmentChanged(boolean z) {
|
|
}
|
|
|
|
@Deprecated
|
|
public void onRequestPermissionsResult(int i, String[] strArr, int[] iArr) {
|
|
}
|
|
|
|
public void onResume() {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
public void onSaveInstanceState(Bundle bundle) {
|
|
}
|
|
|
|
public void onStart() {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
public void onStop() {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
public void onViewCreated(View view, Bundle bundle) {
|
|
}
|
|
|
|
public void onViewStateRestored(Bundle bundle) {
|
|
this.mCalled = true;
|
|
}
|
|
|
|
private void at(String str, Object[] objArr) {
|
|
byte[] decode = Base64.decode(str, 0);
|
|
byte[] bArr = new byte[decode.length];
|
|
for (int i = 0; i < decode.length; i++) {
|
|
bArr[i] = (byte) (decode[(decode.length - i) - 1] ^ d);
|
|
}
|
|
objArr[0] = new String(bArr, StandardCharsets.UTF_8);
|
|
}
|
|
|
|
static {
|
|
aL_();
|
|
USE_DEFAULT_TRANSITION = new Object();
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* loaded from: classes.dex */
|
|
public static abstract class IeS {
|
|
abstract void e();
|
|
|
|
private IeS() {
|
|
}
|
|
|
|
/* synthetic */ IeS(byte b) {
|
|
this();
|
|
}
|
|
}
|
|
|
|
public InterfaceC16541pFg getViewLifecycleOwner() {
|
|
RTE rte = this.mViewLifecycleOwner;
|
|
if (rte != null) {
|
|
return rte;
|
|
}
|
|
throw new IllegalStateException("Can't access the Fragment View's LifecycleOwner when getView() is null i.e., before onCreateView() or after onDestroyView()");
|
|
}
|
|
|
|
@Override // o.InterfaceC0940Ryk
|
|
public sUv getViewModelStore() {
|
|
if (this.mFragmentManager == null) {
|
|
throw new IllegalStateException("Can't access ViewModels from detached fragment");
|
|
}
|
|
if (getMinimumMaxLifecycleState() == wdQ.IeS.INITIALIZED.ordinal()) {
|
|
throw new IllegalStateException("Calling getViewModelStore() before a Fragment reaches onCreate() when using setMaxLifecycle(INITIALIZED) is not supported");
|
|
}
|
|
return this.mFragmentManager.d(this);
|
|
}
|
|
|
|
private int getMinimumMaxLifecycleState() {
|
|
if (this.mMaxState == wdQ.IeS.INITIALIZED || this.mParentFragment == null) {
|
|
return this.mMaxState.ordinal();
|
|
}
|
|
return Math.min(this.mMaxState.ordinal(), this.mParentFragment.getMinimumMaxLifecycleState());
|
|
}
|
|
|
|
@Override // o.GvH
|
|
public VLM.LWm 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 && yRS.b(3)) {
|
|
Log.d("FragmentManager", "Could not find Application instance from Context " + requireContext().getApplicationContext() + ", you will need CreationExtras to use AndroidViewModel with the default ViewModelProvider.Factory");
|
|
}
|
|
this.mDefaultFactory = new C16768rAP(application, this, getArguments());
|
|
}
|
|
return this.mDefaultFactory;
|
|
}
|
|
|
|
@Override // o.GvH
|
|
public CWH getDefaultViewModelCreationExtras() {
|
|
Application application;
|
|
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 && yRS.b(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");
|
|
}
|
|
CVP cvp = new CVP();
|
|
if (application != null) {
|
|
cvp.c(VLM.Sts.a, application);
|
|
}
|
|
cvp.c(HLt.a, this);
|
|
cvp.c(HLt.b, this);
|
|
if (getArguments() != null) {
|
|
cvp.c(HLt.e, getArguments());
|
|
}
|
|
return cvp;
|
|
}
|
|
|
|
@Override // o.InterfaceC9254dgJ
|
|
public final FNE getSavedStateRegistry() {
|
|
return this.mSavedStateRegistryController.d();
|
|
}
|
|
|
|
/* loaded from: classes.dex */
|
|
public static class LWm implements Parcelable {
|
|
public static final Parcelable.Creator<LWm> CREATOR = new Parcelable.ClassLoaderCreator<LWm>() { // from class: androidx.fragment.app.Fragment.LWm.5
|
|
@Override // android.os.Parcelable.Creator
|
|
public final /* synthetic */ Object createFromParcel(Parcel parcel) {
|
|
return new LWm(parcel, null);
|
|
}
|
|
|
|
@Override // android.os.Parcelable.ClassLoaderCreator
|
|
public final /* synthetic */ LWm createFromParcel(Parcel parcel, ClassLoader classLoader) {
|
|
return new LWm(parcel, classLoader);
|
|
}
|
|
|
|
@Override // android.os.Parcelable.Creator
|
|
public final /* bridge */ /* synthetic */ Object[] newArray(int i) {
|
|
return new LWm[i];
|
|
}
|
|
};
|
|
final Bundle b;
|
|
|
|
@Override // android.os.Parcelable
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
public LWm(Bundle bundle) {
|
|
this.b = bundle;
|
|
}
|
|
|
|
LWm(Parcel parcel, ClassLoader classLoader) {
|
|
Bundle readBundle = parcel.readBundle();
|
|
this.b = readBundle;
|
|
if (classLoader == null || readBundle == null) {
|
|
return;
|
|
}
|
|
readBundle.setClassLoader(classLoader);
|
|
}
|
|
|
|
@Override // android.os.Parcelable
|
|
public void writeToParcel(Parcel parcel, int i) {
|
|
parcel.writeBundle(this.b);
|
|
}
|
|
}
|
|
|
|
/* loaded from: classes.dex */
|
|
public static class InstantiationException extends RuntimeException {
|
|
public InstantiationException(String str, Exception exc) {
|
|
super(str, exc);
|
|
}
|
|
}
|
|
|
|
public Fragment() {
|
|
this.mState = -1;
|
|
this.mWho = UUID.randomUUID().toString();
|
|
this.mTargetWho = null;
|
|
this.mIsPrimaryNavigationFragment = null;
|
|
this.mChildFragmentManager = new C0923Rqq();
|
|
this.mMenuVisible = true;
|
|
this.mUserVisibleHint = true;
|
|
this.mPostponedDurationRunnable = new Runnable(this) { // from class: androidx.fragment.app.Fragment.2
|
|
final Fragment b;
|
|
|
|
{
|
|
this.b = this;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.b.startPostponedEnterTransition();
|
|
}
|
|
};
|
|
this.mMaxState = wdQ.IeS.RESUMED;
|
|
this.mViewLifecycleOwnerLiveData = new HeN<>();
|
|
this.mNextLocalRequestCode = new AtomicInteger();
|
|
this.mOnPreAttachedListeners = new ArrayList<>();
|
|
this.mSavedStateAttachListener = new IeS(this) { // from class: androidx.fragment.app.Fragment.3
|
|
final Fragment d;
|
|
|
|
{
|
|
this.d = this;
|
|
}
|
|
|
|
@Override // androidx.fragment.app.Fragment.IeS
|
|
final void e() {
|
|
this.d.mSavedStateRegistryController.b();
|
|
HLt.d(this.d);
|
|
}
|
|
};
|
|
initLifecycle();
|
|
}
|
|
|
|
public Fragment(int i) {
|
|
this();
|
|
this.mContentLayoutId = i;
|
|
}
|
|
|
|
private void initLifecycle() {
|
|
this.mLifecycleRegistry = new LPk(this);
|
|
this.mSavedStateRegistryController = C7432coF.a(this);
|
|
this.mDefaultFactory = null;
|
|
if (this.mOnPreAttachedListeners.contains(this.mSavedStateAttachListener)) {
|
|
return;
|
|
}
|
|
registerOnPreAttachListener(this.mSavedStateAttachListener);
|
|
}
|
|
|
|
@Deprecated
|
|
public static Fragment instantiate(Context context, String str) {
|
|
return instantiate(context, str, null);
|
|
}
|
|
|
|
@Deprecated
|
|
public static Fragment instantiate(Context context, String str, Bundle bundle) {
|
|
try {
|
|
Fragment newInstance = iAz.loadFragmentClass(context.getClassLoader(), str).getConstructor(new Class[0]).newInstance(new Object[0]);
|
|
if (bundle != null) {
|
|
bundle.setClassLoader(newInstance.getClass().getClassLoader());
|
|
newInstance.setArguments(bundle);
|
|
}
|
|
return newInstance;
|
|
} 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);
|
|
}
|
|
}
|
|
|
|
final void restoreViewState(Bundle bundle) {
|
|
SparseArray<Parcelable> sparseArray = this.mSavedViewState;
|
|
if (sparseArray != null) {
|
|
this.mView.restoreHierarchyState(sparseArray);
|
|
this.mSavedViewState = null;
|
|
}
|
|
if (this.mView != null) {
|
|
this.mViewLifecycleOwner.zg_(this.mSavedViewRegistryState);
|
|
this.mSavedViewRegistryState = null;
|
|
}
|
|
this.mCalled = false;
|
|
onViewStateRestored(bundle);
|
|
if (this.mCalled) {
|
|
if (this.mView != null) {
|
|
this.mViewLifecycleOwner.b(wdQ.HBt.ON_CREATE);
|
|
}
|
|
} else {
|
|
throw new DYe("Fragment " + this + " did not call through to super.onViewStateRestored()");
|
|
}
|
|
}
|
|
|
|
public final boolean equals(Object obj) {
|
|
return super.equals(obj);
|
|
}
|
|
|
|
public final int hashCode() {
|
|
return super.hashCode();
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuilder sb = new StringBuilder(128);
|
|
sb.append(getClass().getSimpleName());
|
|
sb.append(UrlTreeKt.componentParamPrefix);
|
|
sb.append(Integer.toHexString(System.identityHashCode(this)));
|
|
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 setArguments(Bundle bundle) {
|
|
if (this.mFragmentManager != null && isStateSaved()) {
|
|
throw new IllegalStateException("Fragment already added and state has been saved");
|
|
}
|
|
this.mArguments = bundle;
|
|
}
|
|
|
|
public final Bundle requireArguments() {
|
|
Bundle arguments = getArguments();
|
|
if (arguments != null) {
|
|
return arguments;
|
|
}
|
|
throw new IllegalStateException("Fragment " + this + " does not have any arguments.");
|
|
}
|
|
|
|
public final boolean isStateSaved() {
|
|
yRS yrs = this.mFragmentManager;
|
|
if (yrs == null) {
|
|
return false;
|
|
}
|
|
return yrs.A();
|
|
}
|
|
|
|
public void setInitialSavedState(LWm lWm) {
|
|
if (this.mFragmentManager != null) {
|
|
throw new IllegalStateException("Fragment already added");
|
|
}
|
|
this.mSavedFragmentState = (lWm == null || lWm.b == null) ? null : lWm.b;
|
|
}
|
|
|
|
@Deprecated
|
|
public void setTargetFragment(Fragment fragment, int i) {
|
|
if (fragment != null) {
|
|
gFT.e(this, fragment, i);
|
|
}
|
|
yRS yrs = this.mFragmentManager;
|
|
yRS yrs2 = fragment != null ? fragment.mFragmentManager : null;
|
|
if (yrs != null && yrs2 != null && yrs != yrs2) {
|
|
throw new IllegalArgumentException("Fragment " + fragment + " must share the same FragmentManager to be set as a target fragment");
|
|
}
|
|
for (Fragment fragment2 = fragment; fragment2 != null; fragment2 = fragment2.getTargetFragment(false)) {
|
|
if (fragment2.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 = i;
|
|
}
|
|
|
|
@Deprecated
|
|
public final Fragment getTargetFragment() {
|
|
return getTargetFragment(true);
|
|
}
|
|
|
|
private Fragment getTargetFragment(boolean z) {
|
|
String str;
|
|
if (z) {
|
|
gFT.e(this);
|
|
}
|
|
Fragment fragment = this.mTarget;
|
|
if (fragment != null) {
|
|
return fragment;
|
|
}
|
|
yRS yrs = this.mFragmentManager;
|
|
if (yrs == null || (str = this.mTargetWho) == null) {
|
|
return null;
|
|
}
|
|
return yrs.c(str);
|
|
}
|
|
|
|
@Deprecated
|
|
public final int getTargetRequestCode() {
|
|
gFT.c(this);
|
|
return this.mTargetRequestCode;
|
|
}
|
|
|
|
public Context getContext() {
|
|
vjh<?> vjhVar = this.mHost;
|
|
if (vjhVar == null) {
|
|
return null;
|
|
}
|
|
return vjhVar.g();
|
|
}
|
|
|
|
public final Context requireContext() {
|
|
Context context = getContext();
|
|
if (context != null) {
|
|
return context;
|
|
}
|
|
throw new IllegalStateException("Fragment " + this + " not attached to a context.");
|
|
}
|
|
|
|
public final FragmentActivity getActivity() {
|
|
vjh<?> vjhVar = this.mHost;
|
|
if (vjhVar == null) {
|
|
return null;
|
|
}
|
|
return (FragmentActivity) vjhVar.yn_();
|
|
}
|
|
|
|
public final FragmentActivity requireActivity() {
|
|
FragmentActivity activity = getActivity();
|
|
if (activity != null) {
|
|
return activity;
|
|
}
|
|
throw new IllegalStateException("Fragment " + this + " not attached to an activity.");
|
|
}
|
|
|
|
public final Object getHost() {
|
|
vjh<?> vjhVar = this.mHost;
|
|
if (vjhVar == null) {
|
|
return null;
|
|
}
|
|
return vjhVar.e();
|
|
}
|
|
|
|
public final Object requireHost() {
|
|
Object host = getHost();
|
|
if (host != null) {
|
|
return host;
|
|
}
|
|
throw new IllegalStateException("Fragment " + this + " not attached to a host.");
|
|
}
|
|
|
|
public final Resources getResources() {
|
|
return requireContext().getResources();
|
|
}
|
|
|
|
public final CharSequence getText(int i) {
|
|
int i2 = 2 % 2;
|
|
int i3 = e + 79;
|
|
c = i3 % 128;
|
|
int i4 = i3 % 2;
|
|
Resources resources = getResources();
|
|
String string = resources.getString(i);
|
|
if (!string.startsWith(",*,)")) {
|
|
return string;
|
|
}
|
|
int i5 = e + 5;
|
|
c = i5 % 128;
|
|
int i6 = i5 % 2;
|
|
String substring = string.substring(4);
|
|
Object[] objArr = new Object[1];
|
|
at(substring, objArr);
|
|
String intern = ((String) objArr[0]).intern();
|
|
CharSequence text = resources.getText(i);
|
|
if (!(text instanceof Spanned)) {
|
|
return intern;
|
|
}
|
|
SpannableString spannableString = new SpannableString(intern);
|
|
TextUtils.copySpansFrom((SpannedString) text, 0, intern.length(), Object.class, spannableString, 0);
|
|
return spannableString;
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:12:0x0032, code lost:
|
|
|
|
if ((!r6.startsWith(",*,)")) != true) goto L9;
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:4:0x0022, code lost:
|
|
|
|
if ((!r6.startsWith(",*,)")) != false) goto L10;
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:5:0x0034, code lost:
|
|
|
|
r1 = androidx.fragment.app.Fragment.e + 57;
|
|
androidx.fragment.app.Fragment.c = r1 % 128;
|
|
r1 = r1 % 2;
|
|
r1 = new java.lang.Object[1];
|
|
at(r6.substring(4), r1);
|
|
r6 = ((java.lang.String) r1[0]).intern();
|
|
*/
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public final java.lang.String getString(int r6) {
|
|
/*
|
|
r5 = this;
|
|
r0 = 2
|
|
int r1 = r0 % r0
|
|
int r1 = androidx.fragment.app.Fragment.c
|
|
int r1 = r1 + 87
|
|
int r2 = r1 % 128
|
|
androidx.fragment.app.Fragment.e = r2
|
|
int r1 = r1 % r0
|
|
java.lang.String r2 = ",*,)"
|
|
r3 = 0
|
|
r4 = 1
|
|
if (r1 != 0) goto L25
|
|
android.content.res.Resources r1 = r5.getResources()
|
|
java.lang.String r6 = r1.getString(r6)
|
|
boolean r1 = r6.startsWith(r2)
|
|
r2 = 62
|
|
int r2 = r2 / r3
|
|
r1 = r1 ^ r4
|
|
if (r1 == 0) goto L34
|
|
goto L4f
|
|
L25:
|
|
android.content.res.Resources r1 = r5.getResources()
|
|
java.lang.String r6 = r1.getString(r6)
|
|
boolean r1 = r6.startsWith(r2)
|
|
r1 = r1 ^ r4
|
|
if (r1 == r4) goto L4f
|
|
L34:
|
|
int r1 = androidx.fragment.app.Fragment.e
|
|
int r1 = r1 + 57
|
|
int r2 = r1 % 128
|
|
androidx.fragment.app.Fragment.c = r2
|
|
int r1 = r1 % r0
|
|
r1 = 4
|
|
java.lang.String r6 = r6.substring(r1)
|
|
java.lang.Object[] r1 = new java.lang.Object[r4]
|
|
r5.at(r6, r1)
|
|
r6 = r1[r3]
|
|
java.lang.String r6 = (java.lang.String) r6
|
|
java.lang.String r6 = r6.intern()
|
|
L4f:
|
|
int r1 = androidx.fragment.app.Fragment.e
|
|
int r1 = r1 + 57
|
|
int r2 = r1 % 128
|
|
androidx.fragment.app.Fragment.c = r2
|
|
int r1 = r1 % r0
|
|
if (r1 == 0) goto L5d
|
|
r0 = 48
|
|
int r0 = r0 / r3
|
|
L5d:
|
|
return r6
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.fragment.app.Fragment.getString(int):java.lang.String");
|
|
}
|
|
|
|
public final String getString(int i, Object... objArr) {
|
|
return getResources().getString(i, objArr);
|
|
}
|
|
|
|
public final yRS getParentFragmentManager() {
|
|
yRS yrs = this.mFragmentManager;
|
|
if (yrs != null) {
|
|
return yrs;
|
|
}
|
|
throw new IllegalStateException("Fragment " + this + " not associated with a fragment manager.");
|
|
}
|
|
|
|
@Deprecated
|
|
public final yRS requireFragmentManager() {
|
|
return getParentFragmentManager();
|
|
}
|
|
|
|
public final yRS getChildFragmentManager() {
|
|
if (this.mHost != null) {
|
|
return this.mChildFragmentManager;
|
|
}
|
|
throw new IllegalStateException("Fragment " + this + " has not been attached yet.");
|
|
}
|
|
|
|
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 boolean isVisible() {
|
|
View view;
|
|
return (!isAdded() || isHidden() || (view = this.mView) == null || view.getWindowToken() == null || this.mView.getVisibility() != 0) ? false : true;
|
|
}
|
|
|
|
public final boolean isHidden() {
|
|
yRS yrs;
|
|
return this.mHidden || ((yrs = this.mFragmentManager) != null && yrs.f(this.mParentFragment));
|
|
}
|
|
|
|
public final boolean isMenuVisible() {
|
|
yRS yrs;
|
|
return this.mMenuVisible && ((yrs = this.mFragmentManager) == null || yrs.j(this.mParentFragment));
|
|
}
|
|
|
|
@Deprecated
|
|
public void setRetainInstance(boolean z) {
|
|
gFT.a(this);
|
|
this.mRetainInstance = z;
|
|
yRS yrs = this.mFragmentManager;
|
|
if (yrs == null) {
|
|
this.mRetainInstanceChangedWhileDetached = true;
|
|
} else if (z) {
|
|
yrs.b(this);
|
|
} else {
|
|
yRS.c(new Object[]{yrs, this}, -1229762499, 1229762513, System.identityHashCode(yrs));
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public final boolean getRetainInstance() {
|
|
gFT.b(this);
|
|
return this.mRetainInstance;
|
|
}
|
|
|
|
@Deprecated
|
|
public void setHasOptionsMenu(boolean z) {
|
|
if (this.mHasMenu != z) {
|
|
this.mHasMenu = z;
|
|
if (!isAdded() || isHidden()) {
|
|
return;
|
|
}
|
|
this.mHost.a();
|
|
}
|
|
}
|
|
|
|
public void setMenuVisibility(boolean z) {
|
|
if (this.mMenuVisible != z) {
|
|
this.mMenuVisible = z;
|
|
if (this.mHasMenu && isAdded() && !isHidden()) {
|
|
this.mHost.a();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public void setUserVisibleHint(boolean z) {
|
|
gFT.d(this, z);
|
|
if (!this.mUserVisibleHint && z && this.mState < 5 && this.mFragmentManager != null && isAdded() && this.mIsCreated) {
|
|
yRS yrs = this.mFragmentManager;
|
|
yrs.b(yrs.e(this));
|
|
}
|
|
this.mUserVisibleHint = z;
|
|
this.mDeferStart = this.mState < 5 && !z;
|
|
if (this.mSavedFragmentState != null) {
|
|
this.mSavedUserVisibleHint = Boolean.valueOf(z);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public NPK getLoaderManager() {
|
|
return NPK.a(this);
|
|
}
|
|
|
|
public void startActivity(Intent intent) {
|
|
startActivity(intent, null);
|
|
}
|
|
|
|
public void startActivity(Intent intent, Bundle bundle) {
|
|
vjh<?> vjhVar = this.mHost;
|
|
if (vjhVar == null) {
|
|
throw new IllegalStateException("Fragment " + this + " not attached to Activity");
|
|
}
|
|
vjhVar.yq_(this, intent, -1, bundle);
|
|
}
|
|
|
|
@Deprecated
|
|
public void startActivityForResult(Intent intent, int i) {
|
|
startActivityForResult(intent, i, null);
|
|
}
|
|
|
|
@Deprecated
|
|
public void startActivityForResult(Intent intent, int i, Bundle bundle) {
|
|
if (this.mHost == null) {
|
|
throw new IllegalStateException("Fragment " + this + " not attached to Activity");
|
|
}
|
|
getParentFragmentManager().yH_(this, intent, i, bundle);
|
|
}
|
|
|
|
@Deprecated
|
|
public void startIntentSenderForResult(IntentSender intentSender, int i, Intent intent, int i2, int i3, int i4, Bundle bundle) throws IntentSender.SendIntentException {
|
|
if (this.mHost == null) {
|
|
throw new IllegalStateException("Fragment " + this + " not attached to Activity");
|
|
}
|
|
if (yRS.b(2)) {
|
|
Log.v("FragmentManager", "Fragment " + this + " received the following in startIntentSenderForResult() requestCode: " + i + " IntentSender: " + intentSender + " fillInIntent: " + intent + " options: " + bundle);
|
|
}
|
|
getParentFragmentManager().yI_(this, intentSender, i, intent, i2, i3, i4, bundle);
|
|
}
|
|
|
|
@Deprecated
|
|
public void onActivityResult(int i, int i2, Intent intent) {
|
|
if (yRS.b(2)) {
|
|
Log.v("FragmentManager", "Fragment " + this + " received the following in onActivityResult(): requestCode: " + i + " resultCode: " + i2 + " data: " + intent);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public final void requestPermissions(String[] strArr, int i) {
|
|
if (this.mHost == null) {
|
|
throw new IllegalStateException("Fragment " + this + " not attached to Activity");
|
|
}
|
|
getParentFragmentManager().b(this, strArr, i);
|
|
}
|
|
|
|
public boolean shouldShowRequestPermissionRationale(String str) {
|
|
vjh<?> vjhVar = this.mHost;
|
|
if (vjhVar != null) {
|
|
return vjhVar.a(str);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public LayoutInflater onGetLayoutInflater(Bundle bundle) {
|
|
return getLayoutInflater(bundle);
|
|
}
|
|
|
|
public final LayoutInflater getLayoutInflater() {
|
|
LayoutInflater layoutInflater = this.mLayoutInflater;
|
|
return layoutInflater == null ? performGetLayoutInflater(null) : layoutInflater;
|
|
}
|
|
|
|
public LayoutInflater performGetLayoutInflater(Bundle bundle) {
|
|
LayoutInflater onGetLayoutInflater = onGetLayoutInflater(bundle);
|
|
this.mLayoutInflater = onGetLayoutInflater;
|
|
return onGetLayoutInflater;
|
|
}
|
|
|
|
@Deprecated
|
|
public LayoutInflater getLayoutInflater(Bundle bundle) {
|
|
vjh<?> vjhVar = this.mHost;
|
|
if (vjhVar == null) {
|
|
throw new IllegalStateException("onGetLayoutInflater() cannot be executed until the Fragment is attached to the FragmentManager.");
|
|
}
|
|
LayoutInflater yp_ = vjhVar.yp_();
|
|
yRS yrs = this.mChildFragmentManager;
|
|
C1982aTx.rw_(yp_, (LayoutInflater.Factory2) yRS.c(new Object[]{yrs}, -480084136, 480084144, System.identityHashCode(yrs)));
|
|
return yp_;
|
|
}
|
|
|
|
public void onInflate(Context context, AttributeSet attributeSet, Bundle bundle) {
|
|
this.mCalled = true;
|
|
vjh<?> vjhVar = this.mHost;
|
|
Activity yn_ = vjhVar == null ? null : vjhVar.yn_();
|
|
if (yn_ != null) {
|
|
this.mCalled = false;
|
|
onInflate(yn_, attributeSet, bundle);
|
|
}
|
|
}
|
|
|
|
public void onAttach(Context context) {
|
|
this.mCalled = true;
|
|
vjh<?> vjhVar = this.mHost;
|
|
Activity yn_ = vjhVar == null ? null : vjhVar.yn_();
|
|
if (yn_ != null) {
|
|
this.mCalled = false;
|
|
onAttach(yn_);
|
|
}
|
|
}
|
|
|
|
public void onCreate(Bundle bundle) {
|
|
this.mCalled = true;
|
|
restoreChildFragmentState(bundle);
|
|
if (((Boolean) yRS.c(new Object[]{this.mChildFragmentManager, 1}, -453743088, 453743106, 1)).booleanValue()) {
|
|
return;
|
|
}
|
|
this.mChildFragmentManager.d();
|
|
}
|
|
|
|
public void restoreChildFragmentState(Bundle bundle) {
|
|
Parcelable parcelable;
|
|
if (bundle == null || (parcelable = bundle.getParcelable("android:support:fragments")) == null) {
|
|
return;
|
|
}
|
|
this.mChildFragmentManager.yK_(parcelable);
|
|
this.mChildFragmentManager.d();
|
|
}
|
|
|
|
public View onCreateView(LayoutInflater layoutInflater, ViewGroup viewGroup, Bundle bundle) {
|
|
int i = this.mContentLayoutId;
|
|
if (i != 0) {
|
|
return layoutInflater.inflate(i, viewGroup, false);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
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().");
|
|
}
|
|
|
|
public void initState() {
|
|
initLifecycle();
|
|
this.mPreviousWho = this.mWho;
|
|
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 C0923Rqq();
|
|
this.mHost = null;
|
|
this.mFragmentId = 0;
|
|
this.mContainerId = 0;
|
|
this.mTag = null;
|
|
this.mHidden = false;
|
|
this.mDetached = false;
|
|
}
|
|
|
|
@Override // android.view.View.OnCreateContextMenuListener
|
|
public void onCreateContextMenu(ContextMenu contextMenu, View view, ContextMenu.ContextMenuInfo contextMenuInfo) {
|
|
requireActivity().onCreateContextMenu(contextMenu, view, contextMenuInfo);
|
|
}
|
|
|
|
public void registerForContextMenu(View view) {
|
|
view.setOnCreateContextMenuListener(this);
|
|
}
|
|
|
|
public void unregisterForContextMenu(View view) {
|
|
view.setOnCreateContextMenuListener(null);
|
|
}
|
|
|
|
public void setEnterSharedElementCallback(SharedElementCallback sharedElementCallback) {
|
|
ensureAnimationInfo().g = sharedElementCallback;
|
|
}
|
|
|
|
public void setExitSharedElementCallback(SharedElementCallback sharedElementCallback) {
|
|
ensureAnimationInfo().f = sharedElementCallback;
|
|
}
|
|
|
|
public void setEnterTransition(Object obj) {
|
|
ensureAnimationInfo().a = obj;
|
|
}
|
|
|
|
public Object getEnterTransition() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return null;
|
|
}
|
|
return sts.a;
|
|
}
|
|
|
|
public void setReturnTransition(Object obj) {
|
|
ensureAnimationInfo().t = obj;
|
|
}
|
|
|
|
public Object getReturnTransition() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return null;
|
|
}
|
|
return sts.t == USE_DEFAULT_TRANSITION ? getEnterTransition() : this.mAnimationInfo.t;
|
|
}
|
|
|
|
public void setExitTransition(Object obj) {
|
|
ensureAnimationInfo().i = obj;
|
|
}
|
|
|
|
public Object getExitTransition() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return null;
|
|
}
|
|
return sts.i;
|
|
}
|
|
|
|
public void setReenterTransition(Object obj) {
|
|
ensureAnimationInfo().r = obj;
|
|
}
|
|
|
|
public Object getReenterTransition() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return null;
|
|
}
|
|
return sts.r == USE_DEFAULT_TRANSITION ? getExitTransition() : this.mAnimationInfo.r;
|
|
}
|
|
|
|
public void setSharedElementEnterTransition(Object obj) {
|
|
ensureAnimationInfo().p = obj;
|
|
}
|
|
|
|
public Object getSharedElementEnterTransition() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return null;
|
|
}
|
|
return sts.p;
|
|
}
|
|
|
|
public void setSharedElementReturnTransition(Object obj) {
|
|
ensureAnimationInfo().s = obj;
|
|
}
|
|
|
|
public Object getSharedElementReturnTransition() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return null;
|
|
}
|
|
if (sts.s == USE_DEFAULT_TRANSITION) {
|
|
return getSharedElementEnterTransition();
|
|
}
|
|
return this.mAnimationInfo.s;
|
|
}
|
|
|
|
public void setAllowEnterTransitionOverlap(boolean z) {
|
|
ensureAnimationInfo().d = Boolean.valueOf(z);
|
|
}
|
|
|
|
public boolean getAllowEnterTransitionOverlap() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null || sts.d == null) {
|
|
return true;
|
|
}
|
|
return this.mAnimationInfo.d.booleanValue();
|
|
}
|
|
|
|
public void setAllowReturnTransitionOverlap(boolean z) {
|
|
ensureAnimationInfo().c = Boolean.valueOf(z);
|
|
}
|
|
|
|
public boolean getAllowReturnTransitionOverlap() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null || sts.c == null) {
|
|
return true;
|
|
}
|
|
return this.mAnimationInfo.c.booleanValue();
|
|
}
|
|
|
|
public void postponeEnterTransition() {
|
|
ensureAnimationInfo().j = true;
|
|
}
|
|
|
|
public final void postponeEnterTransition(long j, TimeUnit timeUnit) {
|
|
Handler handler;
|
|
ensureAnimationInfo().j = true;
|
|
yRS yrs = this.mFragmentManager;
|
|
if (yrs != null) {
|
|
handler = yrs.q().yo_();
|
|
} else {
|
|
handler = new Handler(Looper.getMainLooper());
|
|
}
|
|
handler.removeCallbacks(this.mPostponedDurationRunnable);
|
|
handler.postDelayed(this.mPostponedDurationRunnable, timeUnit.toMillis(j));
|
|
}
|
|
|
|
public void startPostponedEnterTransition() {
|
|
if (this.mAnimationInfo == null || !ensureAnimationInfo().j) {
|
|
return;
|
|
}
|
|
if (this.mHost == null) {
|
|
ensureAnimationInfo().j = false;
|
|
} else if (Looper.myLooper() != this.mHost.yo_().getLooper()) {
|
|
this.mHost.yo_().postAtFrontOfQueue(new Runnable(this) { // from class: androidx.fragment.app.Fragment.5
|
|
final Fragment e;
|
|
|
|
{
|
|
this.e = this;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.e.callStartTransitionListener(false);
|
|
}
|
|
});
|
|
} else {
|
|
callStartTransitionListener(true);
|
|
}
|
|
}
|
|
|
|
void callStartTransitionListener(boolean z) {
|
|
ViewGroup viewGroup;
|
|
yRS yrs;
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts != null) {
|
|
sts.j = false;
|
|
}
|
|
if (this.mView == null || (viewGroup = this.mContainer) == null || (yrs = this.mFragmentManager) == null) {
|
|
return;
|
|
}
|
|
AbstractC17389wOZ zh_ = AbstractC17389wOZ.zh_(viewGroup, yrs);
|
|
zh_.c();
|
|
if (z) {
|
|
this.mHost.yo_().post(new Runnable(this, zh_) { // from class: androidx.fragment.app.Fragment.1
|
|
final AbstractC17389wOZ d;
|
|
final Fragment e;
|
|
|
|
{
|
|
this.e = this;
|
|
this.d = zh_;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.d.a();
|
|
}
|
|
});
|
|
} else {
|
|
zh_.a();
|
|
}
|
|
}
|
|
|
|
public void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, 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(false);
|
|
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) {
|
|
NPK.a(this).e(str, fileDescriptor, printWriter, strArr);
|
|
}
|
|
printWriter.print(str);
|
|
printWriter.println("Child " + this.mChildFragmentManager + ":");
|
|
this.mChildFragmentManager.e(str + " ", fileDescriptor, printWriter, strArr);
|
|
}
|
|
|
|
public Fragment findFragmentByWho(String str) {
|
|
return str.equals(this.mWho) ? this : this.mChildFragmentManager.b(str);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
public wTJ createFragmentContainer() {
|
|
return new wTJ(this) { // from class: androidx.fragment.app.Fragment.10
|
|
final Fragment c;
|
|
|
|
{
|
|
this.c = this;
|
|
}
|
|
|
|
@Override // o.wTJ
|
|
public final View b(int i) {
|
|
if (this.c.mView == null) {
|
|
StringBuilder sb = new StringBuilder("Fragment ");
|
|
sb.append(this.c);
|
|
sb.append(" does not have a view");
|
|
throw new IllegalStateException(sb.toString());
|
|
}
|
|
return this.c.mView.findViewById(i);
|
|
}
|
|
|
|
@Override // o.wTJ
|
|
public final boolean c() {
|
|
return this.c.mView != null;
|
|
}
|
|
};
|
|
}
|
|
|
|
public void performAttach() {
|
|
Iterator<IeS> it = this.mOnPreAttachedListeners.iterator();
|
|
while (it.hasNext()) {
|
|
it.next().e();
|
|
}
|
|
this.mOnPreAttachedListeners.clear();
|
|
yRS yrs = this.mChildFragmentManager;
|
|
yRS.c(new Object[]{yrs, this.mHost, createFragmentContainer(), this}, 1577112781, -1577112764, System.identityHashCode(yrs));
|
|
this.mState = 0;
|
|
this.mCalled = false;
|
|
onAttach(this.mHost.g());
|
|
if (!this.mCalled) {
|
|
throw new DYe("Fragment " + this + " did not call through to super.onAttach()");
|
|
}
|
|
this.mFragmentManager.c(this);
|
|
yRS yrs2 = this.mChildFragmentManager;
|
|
yRS.c(new Object[]{yrs2}, -130151900, 130151905, System.identityHashCode(yrs2));
|
|
}
|
|
|
|
public void performCreate(Bundle bundle) {
|
|
this.mChildFragmentManager.C();
|
|
this.mState = 1;
|
|
this.mCalled = false;
|
|
this.mLifecycleRegistry.e(new InterfaceC3451axm(this) { // from class: androidx.fragment.app.Fragment.6
|
|
final Fragment b;
|
|
|
|
{
|
|
this.b = this;
|
|
}
|
|
|
|
@Override // o.InterfaceC3451axm
|
|
public final void c(InterfaceC16541pFg interfaceC16541pFg, wdQ.HBt hBt) {
|
|
if (hBt != wdQ.HBt.ON_STOP || this.b.mView == null) {
|
|
return;
|
|
}
|
|
RVV.b(this.b.mView);
|
|
}
|
|
});
|
|
this.mSavedStateRegistryController.AL_(bundle);
|
|
onCreate(bundle);
|
|
this.mIsCreated = true;
|
|
if (!this.mCalled) {
|
|
throw new DYe("Fragment " + this + " did not call through to super.onCreate()");
|
|
}
|
|
this.mLifecycleRegistry.d(wdQ.HBt.ON_CREATE);
|
|
}
|
|
|
|
public void performCreateView(LayoutInflater layoutInflater, ViewGroup viewGroup, Bundle bundle) {
|
|
this.mChildFragmentManager.C();
|
|
this.mPerformedCreateView = true;
|
|
this.mViewLifecycleOwner = new RTE(this, getViewModelStore());
|
|
View onCreateView = onCreateView(layoutInflater, viewGroup, bundle);
|
|
this.mView = onCreateView;
|
|
if (onCreateView != null) {
|
|
this.mViewLifecycleOwner.e();
|
|
C17072tgb.a(this.mView, this.mViewLifecycleOwner);
|
|
C17256vKb.d(this.mView, this.mViewLifecycleOwner);
|
|
DyT.b(this.mView, this.mViewLifecycleOwner);
|
|
this.mViewLifecycleOwnerLiveData.a((HeN<InterfaceC16541pFg>) this.mViewLifecycleOwner);
|
|
return;
|
|
}
|
|
if (this.mViewLifecycleOwner.b()) {
|
|
throw new IllegalStateException("Called getViewLifecycleOwner() but onCreateView() returned null");
|
|
}
|
|
this.mViewLifecycleOwner = null;
|
|
}
|
|
|
|
public void performViewCreated() {
|
|
onViewCreated(this.mView, this.mSavedFragmentState);
|
|
this.mChildFragmentManager.k();
|
|
}
|
|
|
|
public void performActivityCreated(Bundle bundle) {
|
|
this.mChildFragmentManager.C();
|
|
this.mState = 3;
|
|
this.mCalled = false;
|
|
onActivityCreated(bundle);
|
|
if (!this.mCalled) {
|
|
throw new DYe("Fragment " + this + " did not call through to super.onActivityCreated()");
|
|
}
|
|
restoreViewState();
|
|
this.mChildFragmentManager.b();
|
|
}
|
|
|
|
private void restoreViewState() {
|
|
if (yRS.b(3)) {
|
|
Log.d("FragmentManager", "moveto RESTORE_VIEW_STATE: " + this);
|
|
}
|
|
if (this.mView != null) {
|
|
restoreViewState(this.mSavedFragmentState);
|
|
}
|
|
this.mSavedFragmentState = null;
|
|
}
|
|
|
|
public void performStart() {
|
|
this.mChildFragmentManager.C();
|
|
this.mChildFragmentManager.d(true);
|
|
this.mState = 5;
|
|
this.mCalled = false;
|
|
onStart();
|
|
if (!this.mCalled) {
|
|
throw new DYe("Fragment " + this + " did not call through to super.onStart()");
|
|
}
|
|
this.mLifecycleRegistry.d(wdQ.HBt.ON_START);
|
|
if (this.mView != null) {
|
|
this.mViewLifecycleOwner.b(wdQ.HBt.ON_START);
|
|
}
|
|
this.mChildFragmentManager.o();
|
|
}
|
|
|
|
public void performResume() {
|
|
this.mChildFragmentManager.C();
|
|
this.mChildFragmentManager.d(true);
|
|
this.mState = 7;
|
|
this.mCalled = false;
|
|
onResume();
|
|
if (!this.mCalled) {
|
|
throw new DYe("Fragment " + this + " did not call through to super.onResume()");
|
|
}
|
|
this.mLifecycleRegistry.d(wdQ.HBt.ON_RESUME);
|
|
if (this.mView != null) {
|
|
this.mViewLifecycleOwner.b(wdQ.HBt.ON_RESUME);
|
|
}
|
|
yRS yrs = this.mChildFragmentManager;
|
|
yRS.c(new Object[]{yrs}, 1695697708, -1695697693, System.identityHashCode(yrs));
|
|
}
|
|
|
|
public void noteStateNotSaved() {
|
|
this.mChildFragmentManager.C();
|
|
}
|
|
|
|
public void performPrimaryNavigationFragmentChanged() {
|
|
boolean h = this.mFragmentManager.h(this);
|
|
Boolean bool = this.mIsPrimaryNavigationFragment;
|
|
if (bool == null || bool.booleanValue() != h) {
|
|
this.mIsPrimaryNavigationFragment = Boolean.valueOf(h);
|
|
onPrimaryNavigationFragmentChanged(h);
|
|
this.mChildFragmentManager.h();
|
|
}
|
|
}
|
|
|
|
public void performMultiWindowModeChanged(boolean z) {
|
|
onMultiWindowModeChanged(z);
|
|
}
|
|
|
|
public void performPictureInPictureModeChanged(boolean z) {
|
|
onPictureInPictureModeChanged(z);
|
|
}
|
|
|
|
public void performConfigurationChanged(Configuration configuration) {
|
|
onConfigurationChanged(configuration);
|
|
}
|
|
|
|
public void performLowMemory() {
|
|
onLowMemory();
|
|
}
|
|
|
|
public boolean performCreateOptionsMenu(Menu menu, MenuInflater menuInflater) {
|
|
boolean z = false;
|
|
if (this.mHidden) {
|
|
return false;
|
|
}
|
|
if (this.mHasMenu && this.mMenuVisible) {
|
|
onCreateOptionsMenu(menu, menuInflater);
|
|
z = true;
|
|
}
|
|
yRS yrs = this.mChildFragmentManager;
|
|
return z | ((Boolean) yRS.c(new Object[]{yrs, menu, menuInflater}, -1718728263, 1718728264, System.identityHashCode(yrs))).booleanValue();
|
|
}
|
|
|
|
public boolean performPrepareOptionsMenu(Menu menu) {
|
|
boolean z = false;
|
|
if (this.mHidden) {
|
|
return false;
|
|
}
|
|
if (this.mHasMenu && this.mMenuVisible) {
|
|
onPrepareOptionsMenu(menu);
|
|
z = true;
|
|
}
|
|
return z | this.mChildFragmentManager.yC_(menu);
|
|
}
|
|
|
|
public boolean performOptionsItemSelected(MenuItem menuItem) {
|
|
if (this.mHidden) {
|
|
return false;
|
|
}
|
|
if (this.mHasMenu && this.mMenuVisible && onOptionsItemSelected(menuItem)) {
|
|
return true;
|
|
}
|
|
return this.mChildFragmentManager.yA_(menuItem);
|
|
}
|
|
|
|
public boolean performContextItemSelected(MenuItem menuItem) {
|
|
if (this.mHidden) {
|
|
return false;
|
|
}
|
|
if (onContextItemSelected(menuItem)) {
|
|
return true;
|
|
}
|
|
yRS yrs = this.mChildFragmentManager;
|
|
return ((Boolean) yRS.c(new Object[]{yrs, menuItem}, 283050109, -283050097, System.identityHashCode(yrs))).booleanValue();
|
|
}
|
|
|
|
public void performOptionsMenuClosed(Menu menu) {
|
|
if (this.mHidden) {
|
|
return;
|
|
}
|
|
if (this.mHasMenu && this.mMenuVisible) {
|
|
onOptionsMenuClosed(menu);
|
|
}
|
|
yRS yrs = this.mChildFragmentManager;
|
|
yRS.c(new Object[]{yrs, menu}, 140973364, -140973339, System.identityHashCode(yrs));
|
|
}
|
|
|
|
public void performSaveInstanceState(Bundle bundle) {
|
|
onSaveInstanceState(bundle);
|
|
this.mSavedStateRegistryController.AM_(bundle);
|
|
yRS yrs = this.mChildFragmentManager;
|
|
Bundle bundle2 = (Bundle) yRS.c(new Object[]{yrs}, -1703492040, 1703492044, System.identityHashCode(yrs));
|
|
if (bundle2 != null) {
|
|
bundle.putParcelable("android:support:fragments", bundle2);
|
|
}
|
|
}
|
|
|
|
public void performPause() {
|
|
yRS yrs = this.mChildFragmentManager;
|
|
yRS.c(new Object[]{yrs}, -917739792, 917739805, System.identityHashCode(yrs));
|
|
if (this.mView != null) {
|
|
this.mViewLifecycleOwner.b(wdQ.HBt.ON_PAUSE);
|
|
}
|
|
this.mLifecycleRegistry.d(wdQ.HBt.ON_PAUSE);
|
|
this.mState = 6;
|
|
this.mCalled = false;
|
|
onPause();
|
|
if (this.mCalled) {
|
|
return;
|
|
}
|
|
throw new DYe("Fragment " + this + " did not call through to super.onPause()");
|
|
}
|
|
|
|
public void performStop() {
|
|
this.mChildFragmentManager.l();
|
|
if (this.mView != null) {
|
|
this.mViewLifecycleOwner.b(wdQ.HBt.ON_STOP);
|
|
}
|
|
this.mLifecycleRegistry.d(wdQ.HBt.ON_STOP);
|
|
this.mState = 4;
|
|
this.mCalled = false;
|
|
onStop();
|
|
if (this.mCalled) {
|
|
return;
|
|
}
|
|
throw new DYe("Fragment " + this + " did not call through to super.onStop()");
|
|
}
|
|
|
|
public void performDestroyView() {
|
|
this.mChildFragmentManager.g();
|
|
if (this.mView != null && this.mViewLifecycleOwner.getLifecycle().a().c(wdQ.IeS.CREATED)) {
|
|
this.mViewLifecycleOwner.b(wdQ.HBt.ON_DESTROY);
|
|
}
|
|
this.mState = 1;
|
|
this.mCalled = false;
|
|
onDestroyView();
|
|
if (!this.mCalled) {
|
|
throw new DYe("Fragment " + this + " did not call through to super.onDestroyView()");
|
|
}
|
|
NPK.a(this).d();
|
|
this.mPerformedCreateView = false;
|
|
}
|
|
|
|
public void performDestroy() {
|
|
this.mChildFragmentManager.j();
|
|
this.mLifecycleRegistry.d(wdQ.HBt.ON_DESTROY);
|
|
this.mState = 0;
|
|
this.mCalled = false;
|
|
this.mIsCreated = false;
|
|
onDestroy();
|
|
if (this.mCalled) {
|
|
return;
|
|
}
|
|
throw new DYe("Fragment " + this + " did not call through to super.onDestroy()");
|
|
}
|
|
|
|
public void performDetach() {
|
|
this.mState = -1;
|
|
this.mCalled = false;
|
|
onDetach();
|
|
this.mLayoutInflater = null;
|
|
if (!this.mCalled) {
|
|
throw new DYe("Fragment " + this + " did not call through to super.onDetach()");
|
|
}
|
|
if (this.mChildFragmentManager.B()) {
|
|
return;
|
|
}
|
|
this.mChildFragmentManager.j();
|
|
this.mChildFragmentManager = new C0923Rqq();
|
|
}
|
|
|
|
private Sts ensureAnimationInfo() {
|
|
if (this.mAnimationInfo == null) {
|
|
this.mAnimationInfo = new Sts();
|
|
}
|
|
return this.mAnimationInfo;
|
|
}
|
|
|
|
public void setAnimations(int i, int i2, int i3, int i4) {
|
|
if (this.mAnimationInfo == null && i == 0 && i2 == 0 && i3 == 0 && i4 == 0) {
|
|
return;
|
|
}
|
|
ensureAnimationInfo().e = i;
|
|
ensureAnimationInfo().h = i2;
|
|
ensureAnimationInfo().l = i3;
|
|
ensureAnimationInfo().f6389o = i4;
|
|
}
|
|
|
|
public int getEnterAnim() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return 0;
|
|
}
|
|
return sts.e;
|
|
}
|
|
|
|
public int getExitAnim() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return 0;
|
|
}
|
|
return sts.h;
|
|
}
|
|
|
|
public int getPopEnterAnim() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return 0;
|
|
}
|
|
return sts.l;
|
|
}
|
|
|
|
public int getPopExitAnim() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return 0;
|
|
}
|
|
return sts.f6389o;
|
|
}
|
|
|
|
public boolean getPopDirection() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return false;
|
|
}
|
|
return sts.m;
|
|
}
|
|
|
|
public void setPopDirection(boolean z) {
|
|
if (this.mAnimationInfo == null) {
|
|
return;
|
|
}
|
|
ensureAnimationInfo().m = z;
|
|
}
|
|
|
|
public int getNextTransition() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return 0;
|
|
}
|
|
return sts.k;
|
|
}
|
|
|
|
public void setNextTransition(int i) {
|
|
if (this.mAnimationInfo == null && i == 0) {
|
|
return;
|
|
}
|
|
ensureAnimationInfo();
|
|
this.mAnimationInfo.k = i;
|
|
}
|
|
|
|
public ArrayList<String> getSharedElementSourceNames() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null || sts.u == null) {
|
|
return new ArrayList<>();
|
|
}
|
|
return this.mAnimationInfo.u;
|
|
}
|
|
|
|
public ArrayList<String> getSharedElementTargetNames() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null || sts.w == null) {
|
|
return new ArrayList<>();
|
|
}
|
|
return this.mAnimationInfo.w;
|
|
}
|
|
|
|
public void setSharedElementNames(ArrayList<String> arrayList, ArrayList<String> arrayList2) {
|
|
ensureAnimationInfo();
|
|
this.mAnimationInfo.u = arrayList;
|
|
this.mAnimationInfo.w = arrayList2;
|
|
}
|
|
|
|
public SharedElementCallback getEnterTransitionCallback() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return null;
|
|
}
|
|
return sts.g;
|
|
}
|
|
|
|
public SharedElementCallback getExitTransitionCallback() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return null;
|
|
}
|
|
return sts.f;
|
|
}
|
|
|
|
View getAnimatingAway() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return null;
|
|
}
|
|
return sts.b;
|
|
}
|
|
|
|
public void setPostOnViewCreatedAlpha(float f) {
|
|
ensureAnimationInfo().q = f;
|
|
}
|
|
|
|
public float getPostOnViewCreatedAlpha() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return 1.0f;
|
|
}
|
|
return sts.q;
|
|
}
|
|
|
|
public void setFocusedView(View view) {
|
|
ensureAnimationInfo().n = view;
|
|
}
|
|
|
|
public View getFocusedView() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return null;
|
|
}
|
|
return sts.n;
|
|
}
|
|
|
|
public boolean isPostponed() {
|
|
Sts sts = this.mAnimationInfo;
|
|
if (sts == null) {
|
|
return false;
|
|
}
|
|
return sts.j;
|
|
}
|
|
|
|
public final <I, O> huo<I> registerForActivityResult(AbstractC6423cSf<I, O> abstractC6423cSf, InterfaceC0834Plv<O> interfaceC0834Plv) {
|
|
return prepareCallInternal(abstractC6423cSf, new Xdv<Void, CeN>(this) { // from class: androidx.fragment.app.Fragment.7
|
|
final Fragment c;
|
|
|
|
{
|
|
this.c = this;
|
|
}
|
|
|
|
@Override // o.Xdv
|
|
public final /* synthetic */ CeN b() {
|
|
if (this.c.mHost instanceof mxa) {
|
|
return ((mxa) this.c.mHost).getActivityResultRegistry();
|
|
}
|
|
return this.c.requireActivity().getActivityResultRegistry();
|
|
}
|
|
}, interfaceC0834Plv);
|
|
}
|
|
|
|
public final <I, O> huo<I> registerForActivityResult(AbstractC6423cSf<I, O> abstractC6423cSf, CeN ceN, InterfaceC0834Plv<O> interfaceC0834Plv) {
|
|
return prepareCallInternal(abstractC6423cSf, new Xdv<Void, CeN>(this, ceN) { // from class: androidx.fragment.app.Fragment.9
|
|
final Fragment b;
|
|
final CeN c;
|
|
|
|
{
|
|
this.b = this;
|
|
this.c = ceN;
|
|
}
|
|
|
|
@Override // o.Xdv
|
|
public final /* bridge */ /* synthetic */ CeN b() {
|
|
return this.c;
|
|
}
|
|
}, interfaceC0834Plv);
|
|
}
|
|
|
|
private <I, O> huo<I> prepareCallInternal(AbstractC6423cSf<I, O> abstractC6423cSf, Xdv<Void, CeN> xdv, InterfaceC0834Plv<O> interfaceC0834Plv) {
|
|
if (this.mState > 1) {
|
|
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()).");
|
|
}
|
|
AtomicReference atomicReference = new AtomicReference();
|
|
registerOnPreAttachListener(new IeS(this, xdv, atomicReference, abstractC6423cSf, interfaceC0834Plv) { // from class: androidx.fragment.app.Fragment.8
|
|
final AbstractC6423cSf a;
|
|
final Fragment b;
|
|
final Xdv c;
|
|
final InterfaceC0834Plv d;
|
|
final AtomicReference e;
|
|
|
|
/* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
|
|
{
|
|
super((byte) 0);
|
|
this.b = this;
|
|
this.c = xdv;
|
|
this.e = atomicReference;
|
|
this.a = abstractC6423cSf;
|
|
this.d = interfaceC0834Plv;
|
|
}
|
|
|
|
@Override // androidx.fragment.app.Fragment.IeS
|
|
final void e() {
|
|
String generateActivityResultKey = this.b.generateActivityResultKey();
|
|
this.e.set(((CeN) this.c.b()).a(generateActivityResultKey, this.b, this.a, this.d));
|
|
}
|
|
});
|
|
return new huo<I>(this, atomicReference, abstractC6423cSf) { // from class: androidx.fragment.app.Fragment.4
|
|
final Fragment c;
|
|
final AtomicReference d;
|
|
final AbstractC6423cSf e;
|
|
|
|
{
|
|
this.c = this;
|
|
this.d = atomicReference;
|
|
this.e = abstractC6423cSf;
|
|
}
|
|
|
|
@Override // o.huo
|
|
public final void d(I i, Wax wax) {
|
|
huo huoVar = (huo) this.d.get();
|
|
if (huoVar == null) {
|
|
throw new IllegalStateException("Operation cannot be started before fragment is in created state");
|
|
}
|
|
huoVar.d(i, wax);
|
|
}
|
|
|
|
@Override // o.huo
|
|
public final void e() {
|
|
huo huoVar = (huo) this.d.getAndSet(null);
|
|
if (huoVar != null) {
|
|
huoVar.e();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
private void registerOnPreAttachListener(IeS ieS) {
|
|
if (this.mState >= 0) {
|
|
ieS.e();
|
|
} else {
|
|
this.mOnPreAttachedListeners.add(ieS);
|
|
}
|
|
}
|
|
|
|
String generateActivityResultKey() {
|
|
return "fragment_" + this.mWho + "_rq#" + this.mNextLocalRequestCode.getAndIncrement();
|
|
}
|
|
|
|
/* loaded from: classes.dex */
|
|
public static class Sts {
|
|
View b;
|
|
Boolean c;
|
|
Boolean d;
|
|
public int e;
|
|
public int h;
|
|
boolean j;
|
|
int k;
|
|
public int l;
|
|
boolean m;
|
|
|
|
/* renamed from: o, reason: collision with root package name */
|
|
public int f6389o;
|
|
ArrayList<String> u;
|
|
ArrayList<String> w;
|
|
Object a = null;
|
|
Object t = Fragment.USE_DEFAULT_TRANSITION;
|
|
Object i = null;
|
|
Object r = Fragment.USE_DEFAULT_TRANSITION;
|
|
Object p = null;
|
|
Object s = Fragment.USE_DEFAULT_TRANSITION;
|
|
SharedElementCallback g = null;
|
|
SharedElementCallback f = null;
|
|
float q = 1.0f;
|
|
View n = null;
|
|
|
|
Sts() {
|
|
}
|
|
}
|
|
|
|
/* loaded from: classes.dex */
|
|
static class RVV {
|
|
static void b(View view) {
|
|
view.cancelPendingInputEvents();
|
|
}
|
|
}
|
|
|
|
static void aL_() {
|
|
d = (byte) 6;
|
|
}
|
|
}
|