Fragment 灵魂拷问：Fragment 是如何进行事务管理的？

static final int INITIALIZING = 0;     // Not yet created.static final int CREATED = 1;          // Created.static final int ACTIVITY_CREATED = 2; // Fully created, not started.static final int STARTED = 3;          // Created and started, not resumed.static final int RESUMED = 4;          // Created started and resumed.//Fragment 默认的状态是 INITIALIZING，也是代表当前的生命周期状态int mState = INITIALIZING;

static final int OP_NULL = 0;static final int OP_ADD = 1;static final int OP_REPLACE = 2;static final int OP_REMOVE = 3;static final int OP_HIDE = 4;static final int OP_SHOW = 5;static final int OP_DETACH = 6;static final int OP_ATTACH = 7;static final int OP_SET_PRIMARY_NAV = 8;static final int OP_UNSET_PRIMARY_NAV = 9;static final int OP_SET_MAX_LIFECYCLE = 10;

static final class Op {    int mCmd;    Fragment mFragment;    int mEnterAnim;    int mExitAnim;    int mPopEnterAnim;    int mPopExitAnim;    Lifecycle.State mOldMaxState;    Lifecycle.State mCurrentMaxState;
    Op() {    }
    Op(int cmd, Fragment fragment) {        this.mCmd = cmd;        this.mFragment = fragment;        this.mOldMaxState = Lifecycle.State.RESUMED;        this.mCurrentMaxState = Lifecycle.State.RESUMED;    }
    Op(int cmd, @NonNull Fragment fragment, Lifecycle.State state) {        this.mCmd = cmd;        this.mFragment = fragment;        this.mOldMaxState = fragment.mMaxState;        this.mCurrentMaxState = state;    }}

ArrayList<BackStackRecord> mBackStackIndices;ArrayList<Integer> mAvailBackStackIndices;  //可用的回退栈的索引

//BackStackRecord.java//commit@Overridepublic int commit() {    return commitInternal(false);}//commitInternalint commitInternal(boolean allowStateLoss) {        ···        mCommitted = true;        if (mAddToBackStack) {            mIndex = mManager.allocBackStackIndex(this);        } else {            mIndex = -1;        }        mManager.enqueueAction(this, allowStateLoss);        return mIndex;}

public void enqueueAction(OpGenerator action, boolean allowStateLoss) {    if (!allowStateLoss) {        checkStateLoss();    }    synchronized (this) {        if (mDestroyed || mHost == null) {            if (allowStateLoss) {                // This FragmentManager isn't attached, so drop the entire transaction.                return;            }            throw new IllegalStateException("Activity has been destroyed");        }        if (mPendingActions == null) {            mPendingActions = new ArrayList<>();        }        mPendingActions.add(action);        scheduleCommit();    }}

void scheduleCommit() {    synchronized (this) {        boolean postponeReady =                mPostponedTransactions != null && !mPostponedTransactions.isEmpty();        boolean pendingReady = mPendingActions != null && mPendingActions.size() == 1;        //通过handler发送        if (postponeReady || pendingReady) {            mHost.getHandler().removeCallbacks(mExecCommit);            mHost.getHandler().post(mExecCommit);            updateOnBackPressedCallbackEnabled();        }    }}

@Overridepublic void commitNow() {    disallowAddToBackStack();    mManager.execSingleAction(this, false);}
 public void execSingleAction(OpGenerator action, boolean allowStateLoss) {        ···        ensureExecReady(allowStateLoss);        if (action.generateOps(mTmpRecords, mTmpIsPop)) {            mExecutingActions = true;            try {                removeRedundantOperationsAndExecute(mTmpRecords, mTmpIsPop);            } finally {                cleanupExec();            }        }        updateOnBackPressedCallbackEnabled();        doPendingDeferredStart();        burpActive();    }

private void ensureExecReady(boolean allowStateLoss) {    ···    mExecutingActions = true;    try {        executePostponedTransaction(null, null);    } finally {        mExecutingActions = false;    }}

public void completeTransaction() {    final boolean canceled;    canceled = mNumPostponed > 0;    FragmentManagerImpl manager = mRecord.mManager;    final int numAdded = manager.mAdded.size();    for (int i = 0; i < numAdded; i++) {        final Fragment fragment = manager.mAdded.get(i);        fragment.setOnStartEnterTransitionListener(null);        if (canceled && fragment.isPostponed()) {            fragment.startPostponedEnterTransition();        }    }    mRecord.mManager.completeExecute(mRecord, mIsBack, !canceled, true);}

viewPager.setOffscreenPageLimit(int count);

/** * Set a ceiling for the state of an active fragment in this FragmentManager. If fragment is * already above the received state, it will be forced down to the correct state. * * <p>The fragment provided must currently be added to the FragmentManager to have it's * Lifecycle state capped, or previously added as part of this transaction. The * {@link Lifecycle.State} passed in must at least be {@link Lifecycle.State#CREATED}, otherwise * an {@link IllegalArgumentException} will be thrown.</p> * * @param fragment the fragment to have it's state capped. * @param state the ceiling state for the fragment. * @return the same FragmentTransaction instance */@NonNullpublic FragmentTransaction setMaxLifecycle(@NonNull Fragment fragment,        @NonNull Lifecycle.State state) {    addOp(new Op(OP_SET_MAX_LIFECYCLE, fragment, state));    return this;}

public TabFragmentPagerAdapter(FragmentManager fm, List<Fragment> list) {    super(fm); //该方法过时了    this.mlist = list;}

public FragmentPagerAdapter(@NonNull FragmentManager fm,        @Behavior int behavior) {    mFragmentManager = fm;    mBehavior = behavior;}

@Deprecatedpublic static final int BEHAVIOR_SET_USER_VISIBLE_HINT = 0;
public static final int BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT = 1;