navigation之详细聊聊fragment的实现原理(代码片段)

作者：字节小站

1. 前言

Fragment真是一个非常老的家伙，它的第一条提交记录是在2010年，而最近的一条记录则是在2021年6月11号，足足11岁了，但是它却老当益壮，在Jetpack中大放异彩，Navigation组件就是基于Fragment的一个跳转组件，Google的单Activity项目结构就是一个Activity和多个Fragment项目结构。多年以来，一提到Fragment，大家脑海中的第一印象可能还停留在平板应用开发中了，它曾经在手机项目中高频使用Fragment的机会还真没那么多。一方面是因为手机项目一般都是多Activity结构实现的，不会涉及到那么多的Fragment使用，另一方面，Fragment也比Activity复杂，相比之下使用有点麻烦，甚至是痛苦，不好定位问题，所以在技术选型时，能避则避。它太难用了，以至于Square团队的Piwai大神(LeakCanary的作者)在2014年发表了一篇倡导反对使用Fragment的文章。不管怎么样，这么多年过去了，Android团队也一直没有放弃对Fragment的支持，甚至在Jetpack中，Fragment开始扮演越来越重要的角色了，最近关于Navigation的倡导使用越来越多了，加上我参与了一个平板项目，所以对Fragment主流程源码进行了一次全面的研究。收获颇多，相信将来对Navigation研究定是大有裨益。

2. 创建Fragment

根据官方文档，写一个简单的Demo。简单了解Fragment的使用。

2.1 新建一个Fragment类

class ExampleFragment extends Fragment 
    public ExampleFragment() 
        super(R.layout.example_fragment);
    

2.2 把Fragment添加到Activity上

把Fragment添加到Activity上可以通过xml文件和代码编程两种方式实现。本文只介绍第二种实现方式。

<!-- res/layout/example_activity.xml -->
<androidx.fragment.app.FragmentContainerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

public class ExampleActivity extends AppCompatActivity 
    public ExampleActivity() 
        super(R.layout.example_activity);
    
    @Override
    protected void onCreate(Bundle savedInstanceState) 
        super.onCreate(savedInstanceState);
        if (savedInstanceState == null) 
            getSupportFragmentManager().beginTransaction()
                .setReorderingAllowed(true)
                .add(R.id.fragment_container_view, ExampleFragment.class, null)
                .commit();
        
    

我们可以看到，主要是通过FragmentManager来将Fragment添加到fragment_container_view对应的布局中，Demo是蛮简单的，模板代码，网上拷贝一下就能用。但是FragmentManager、Transaction、commit()分别是什么意思，还有待深入探究一番。

3. 深入理解Fragment原理

3.1 Fragment本质是什么

3.1.1 Fragment本质是View

从前面的DEMO我们看到，Fragment会add到FragmentContainerView上面，能被添加到ViewGroup的组件，一定也是View或者ViewGroup。有源码为证：

//androidx.fragment.app.Fragment.java

ViewGroup mContainer;

// The View generated for this fragment.
View mView;

那么既然如此，何必大费周章呢，直接用View来替代Fragment不就好了，addView()、removeView()使用起来更简单直观。

当然了Fragment本质是View但是又不仅限于此， 在真实的项目中，界面往往很复杂，业务逻辑也很复杂，往往需要处理各种UI状态变化，比如：增加一组View，替换一组View，删除一组View，还需要和Activity协作。总之，如果让开发者自己去实现这一套逻辑，恐怕比使用Fragment要麻烦的多吧。尽管Fragment看起来蛮复杂的，但是还是远比我们自己去实现相同功能简单的多。

3.1.2 Fragment本质不仅限于View

Fragment作为一个View可以被添加到Activity的布局中去。但是他更强大，还有以下几个特性：

1. 处理生命周期，比Activity生命周期还要复杂
2. 通过FragmentTransaction操作多个Fragment
3. 通过FragmentManager维护一个回退栈，回退到上一个FragmentTransaction操作的界面

//androidx.fragment.app.Fragment.java

static final int INITIALIZING = -1;          // Not yet attached.
static final int ATTACHED = 0;               // Attached to the host.
static final int CREATED = 1;                // Created.
static final int VIEW_CREATED = 2;           // View Created.
static final int AWAITING_EXIT_EFFECTS = 3;  // Downward state, awaiting exit effects
static final int ACTIVITY_CREATED = 4;       // Fully created, not started.
static final int STARTED = 5;                // Created and started, not resumed.
static final int AWAITING_ENTER_EFFECTS = 6; // Upward state, awaiting enter effects
static final int RESUMED = 7;                // Created started and resumed.

从代码我们可以看出，有8种状态。分为两类，View相关的以及和Activity状态相关的。后文会详细介绍，此处点到为止。

3.2 FragmentTransaction

3.2.1 FragmentTransaction概述

软件工程中有一门叫数据库的课程，数据库中有一个叫"事务"的概念，它表示多个操作是原子性的，要么一起成功，要么一起失败，典型的例子就是转账，张三给李四转账100元这么一个事务，存在两个操作，从张三的账户中扣除100元，给李四的账户增加100元。因为有了事务，不会存在只有某一个操作成功，而另一个操作失败的情况，否则后果不堪设想。
在Android中SharedPreference也有commit方法。

SharedPreferences sharedPreferences= getSharedPreferences("data",Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString("name", “Tom”);
editor.putInt("age", 28);
editor.putBoolean("marrid",false);           
editor.commit();

上述功能，一次提交做了三件事情，putString，putInt，putBoolean。
而FragmentTransaction和SharedPreference类似。它可以同时操作多个Fragment。
假设有布局文件如下：

<LinearLayout android:orientation="vertical">
    
    <ViewGroup1>
        <Fragment1 />
    </ViewGroup1>
    
    <ViewGroup2>
        <Fragment2 />
    </ViewGroup2>
    
    <ViewGroup3>
        <Fragment3 />
    </ViewGroup3>
    
</LinearLayout>

假设我们想在ViewGroup1上增加Fragment1，ViewGroup2上用Fragment2替换掉，把ViewGroup3上的Fragment移除掉。
伪代码如下:

getSupportFragmentManager().beginTransaction()
    .setReorderingAllowed(true)
    .add(ViewGroup1, Fragment1.class, null)
    .replace(ViewGroup2,Fragment2.class,null)
    .remove(Fragment3)
    .commit();

问：这三个操作我为什么要放到一个事务中呢？我连续执行这三个操作不行吗？
答：有些场景下可以，有些场景下不可以。涉及到回退栈的时候，是否放到事务中，按返回键会有很大的区别。我们把上述三个操作分别命名为OP1、OP2、OP3。如果调用了FragmentTransaction.addToBackStack()，三个操作放到事务中时， 按返回键时会执行与OP1、OP2、OP3相反的操作，即ViewGroup1、ViewGroup2、ViewGroup3同时恢复到处理事务之前的状态。如果三个操作不放到事务中时， 则会依次恢复 ViewGroup3、ViewGroup2、ViewGroup1的状态

3.2.2 FragmentTransaction源码分析
3.2.2.1 支持的操作OP_CMD

//FragmentTransaction.java
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;

挑几个一眼就能看懂的。

1. OP_ADD表示增加Fragment
2. OP_REPLACE表示替换某个ViewGroup上的Fragment
3. OP_REMOVE删除Fragment
4. OP_HIDE隐藏Fragment，等同于View.setVisibility(View.GONE)
5. OP_SHOW显示Fragment，等同于View.setVisibility(View.VISIBLE)
6. OP_DETACH detach Fragment
7. OP_ATTACH attach Fragment

对应的方法分别是：

//FragmentTransaction.java

public FragmentTransaction add(@NonNull Fragment fragment, @Nullable String tag)  
    doAddOp(0, fragment, tag, OP_ADD);
    return this;


public FragmentTransaction replace(@IdRes int containerViewId, @NonNull Fragment fragment) 
    return replace(containerViewId, fragment, null);


public FragmentTransaction remove(@NonNull Fragment fragment) 
    addOp(new Op(OP_REMOVE, fragment));

    return this;

3.2.2.2 OP类

public abstract class FragmentTransaction 
    ArrayList<Op> mOps = new ArrayList<>();
    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;
          
      

从源码中我们可以看到，FragmentTransaction中有ArrayList mOps。它表示一个事务中需要处理几个操作。而OP类最重要的两个字段就是mCmd和mFragment。表示对某个Fragment执行指定的操作。

3.2.2.3 FragmentTransaction.commit()方法

//FragmentTransaction.java
public abstract class FragmentTransaction 
    public abstract int commit();

我们看到commit()方法是个抽象方法。它由BackStackRecord类实现。

final class BackStackRecord extends FragmentTransaction implements
      FragmentManager.BackStackEntry, FragmentManager.OpGenerator 
  @Override
  public int commit() 
      return commitInternal(false);
  

3.3 BackStackRecord

3.3.1 BackStackRecord概述

BackStackRecord是FragmentTransaction的子类，表示它支持同时操作多个Fragment。同时，顾名思义，它会被放到BackStack(回退栈)中。回退栈定义在FragmentManager中，是一个ArrayList集合。

//FragmentManager.java
ArrayList<BackStackRecord> mBackStack;

一言以蔽之，BackStackRecord支持事务操作，同时又会被放入到回退栈中

3.3.2 BackStackRecord commit流程

int commitInternal(boolean allowStateLoss) 
    if (mCommitted) throw new IllegalStateException("commit already called");
    if (FragmentManager.isLoggingEnabled(Log.VERBOSE)) 
        Log.v(TAG, "Commit: " + this);
        LogWriter logw = new LogWriter(TAG);
        PrintWriter pw = new PrintWriter(logw);
        dump("  ", pw);
        pw.close();
    
    mCommitted = true;
    if (mAddToBackStack) 
        mIndex = mManager.allocBackStackIndex();
     else 
        mIndex = -1;
    
    mManager.enqueueAction(this, allowStateLoss);
    return mIndex;

该方法最主要的就是调用了FragmentManager.enqueueAction方法

3.4 FragmentManager

3.4.1 FragmentManager概述

从前文，我们知道，对多个Fragment的操作会被记录到FragmentTransaction中，最终调用FragmentManager.enqueueAction方法，真正执行Fragment操作。

3.4.2 操作调用流程

1. FragmentManager.enqueueAction()

void enqueueAction(@NonNull OpGenerator action, boolean allowStateLoss) 
    if (!allowStateLoss) 
        if (mHost == null) 
            if (mDestroyed) 
                throw new IllegalStateException("FragmentManager has been destroyed");
             else 
                throw new IllegalStateException("FragmentManager has not been attached to a "
                        + "host.");
            
        
        checkStateLoss();
    
    synchronized (mPendingActions) 
        if (mHost == null) 
            if (allowStateLoss) 
                // This FragmentManager isn't attached, so drop the entire transaction.
                return;
            
            throw new IllegalStateException("Activity has been destroyed");
        
        mPendingActions.add(action);
        scheduleCommit();
    

该方法最终调用到scheduleCommit()方法

2. FragmentManager.scheduleCommit()

void scheduleCommit() 
    synchronized (mPendingActions) 
        boolean postponeReady =
                mPostponedTransactions != null && !mPostponedTransactions.isEmpty();
        boolean pendingReady = mPendingActions.size() == 1;
        if (postponeReady || pendingReady) 
            mHost.getHandler().removeCallbacks(mExecCommit);
            mHost.getHandler().post(mExecCommit);
            updateOnBackPressedCallbackEnabled();
        
    

该方法最终通过Handler执行mExecCommit

3. FragmentManager.mExecCommit

private Runnable mExecCommit = new Runnable() 
    @Override
    public void run() 
        execPendingActions(true);
    
;

该方法最终调用execPendingActions

4. FragmentManager.execPendingActions()

boolean execPendingActions(boolean allowStateLoss) 
    ensureExecReady(allowStateLoss);

    boolean didSomething = false;
    while (generateOpsForPendingActions(mTmpRecords, mTmpIsPop)) 
        mExecutingActions = true;
        try 
            removeRedundantOperationsAndExecute(mTmpRecords, mTmpIsPop);
         finally 
            cleanupExec();
        
        didSomething = true;
    

    updateOnBackPressedCallbackEnabled();
    doPendingDeferredStart();
    mFragmentStore.burpActive();

    return didSomething;

重点关注removeRedundantOperationsAndExecute(mTmpRecords, mTmpIsPop)

5. FragmentManager.removeRedundantOperationsAndExecute()

private void removeRedundantOperationsAndExecute(@NonNull ArrayList<BackStackRecord> records,
            @NonNull ArrayList<Boolean> isRecordPop) 
    

方法比较长省略代码，最终调用executeOpsTogether

6. FragmentManager.executeOpsTogether

private void executeOpsTogether(@NonNull ArrayList<BackStackRecord> records,
          @NonNull ArrayList<Boolean> isRecordPop, int startIndex, int endIndex) 

方法比较长省略代码，最终调用executeOps方法

7. FragmentManager.executeOps()

private static void executeOps(@NonNull ArrayList<BackStackRecord> records,
            @NonNull ArrayList<Boolean> isRecordPop, int startIndex, int endIndex) 
    for (int i = startIndex; i < endIndex; i++) 
        final BackStackRecord record = records.get(i);
        final boolean isPop = isRecordPop.get(i);
        if (isPop) 
            record.bumpBackStackNesting(-1);
            // Only execute the add operations at the end of
            // all transactions.
            boolean moveToState = i == (endIndex - 1);
            record.executePopOps(moveToState);
         else 
            record.bumpBackStackNesting(1);
            record.executeOps();
        
    

该方法分为两种情况，入栈和出栈，对应commit()和FragmentManager.popBackStack()操作。

8. FragmentManager.executeOps()

void executeOps() 
        final int numOps = mOps.size();
        for (int opNum = 0; opNum < numOps; opNum++) 
            final Op op = mOps.get(opNum);
            final Fragment f = op.mFragment;
            if (f != null) 
                f.setPopDirection(false);
                f.setNextTransition(mTransition);
                f.setSharedElementNames(mSharedElementSourceNames, mSharedElementTargetNames);
            
            switch (op.mCmd) 
                case OP_ADD:
                    f.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
                    mManager.setExitAnimationOrder(f, false);
                    mManager.addFragment(f);
                    break;
                case OP_REMOVE:
                    f.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
                    mManager.removeFragment(f);
                    break;
                case OP_HIDE:
                    f.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
                    mManager.hideFragment(f);
                    break;
                case OP_SHOW:
                    f.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
                    mManager.setExitAnimationOrder(f, false);
                    mManager.showFragment(f);
                    break;
                case OP_DETACH:
                    f.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
                    mManager.detachFragment(f);
                    break;
                case OP_ATTACH:
                    f.setAnimations(op.mEnterAnim, op.mExitAnim, op.mPopEnterAnim, op.mPopExitAnim);
                    mManager.setExitAnimationOrder(f, false);
                    mManager.attachFragment(f);
                    break;
                case OP_SET_PRIMARY_NAV:
                    mManager.setPrimaryNavigationFragment(f);
                    break;
                case OP_UNSET_PRIMARY_NAV:
                    mManager.setPrimaryNavigationFragment(null);
                    break;
                case OP_SET_MAX_LIFECYCLE:
                    mManager.setMaxLifecycle(f, op.mCurrentMaxState);
                    break;
                default:
                    throw new IllegalArgumentException("Unknown cmd: " + op.mCmd);
            
            if (!mReorderingAllowed && op.mCmd != OP_ADD && f != null) 
                if (!FragmentManager.USE_STATE_MANAGER) 
                    mManager.moveFragmentToExpectedState(f);
                
            
        
        if (!mReorderingAllowed && !FragmentManager.USE_STATE_MANAGER) 
            // Added fragments are added at the end to comply with prior behavior.
            mManager.moveToState(mManager.mCurState, true);
        
    

该方法做了两件事，其一：根据OP.mCmd，操作FragmentManager对应的方法，该步骤并不会真正执行操作，也只是做记录操作，其二：调用mManager.moveToState(mManager.mCurState, true)
最终会调用到mManager.moveToState(Fragment f, int newState)方法，它是Fragment框架中真正核心方法

3.5 FragmentManager的核心方法void moveToState(Fragment f, int newState)

作为核心方法，并没有放在3.4章节中，只是为了突出它的核心地位。

void moveToState(@NonNull Fragment f, int newState) 
    FragmentStateManager fragmentStateManager = mFragmentStore.getFragmentStateManager(f.mWho);
    if (fragmentStateManager == null) 
        // Ideally, we only call moveToState() on active Fragments. However,
        // in restoreSaveState() we can call moveToState() on retained Fragments
        // just to clean them up without them ever being added to mActive.
        // For these cases, a brand new FragmentStateManager is enough.
        fragmentStateManager = new FragmentStateManager(mLifecycleCallbacksDispatcher,
                mFragmentStore, f);
        // Only allow this FragmentStateManager to go up to CREATED at the most
        fragmentStateManager.setFragmentManagerState(Fragment.CREATED);
    
    // When inflating an Activity view with a resource instead of using setContentView(), and
    // that resource adds a fragment using the <fragment> tag (i.e. from layout and in layout),
    // the fragment will move to the VIEW_CREATED state before the fragment manager
    // moves to CREATED. So when moving the fragment manager moves to CREATED and the
    // inflated fragment is already in VIEW_CREATED we need to move new state up from CREATED
    // to VIEW_CREATED. This avoids accidentally moving the fragment back down to CREATED
    // which would immediately destroy the Fragment's view. We rely on computeExpectedState()
    // to pull the state back down if needed.
    if (f.mFromLayout && f.mInLayout && f.mState == Fragment.VIEW_CREATED) 
        newState = Math.max(newState, Fragment.VIEW_CREATED);
    
    newState = Math.min(newState, fragmentStateManager.computeExpectedState());
    if (f.mState <= newState) 
        // If we are moving to the same state, we do not need to give up on the animation.
        if (f.mState < newState && !mExitAnimationCancellationSignals.isEmpty()) 
            // The fragment is currently being animated...  but!  Now we
            // want to move our state back up.  Give up on waiting for the
            // animation and proceed from where we are.
            cancelExitAnimation(f);
        
        switch (f.mState) 
            case Fragment.INITIALIZING:
                if (newState > Fragment.INITIALIZING) 
                    fragmentStateManager.attach();
                
                // fall through
            case Fragment.ATTACHED:
                if (newState > Fragment.ATTACHED) 
                    fragmentStateManager.create();
                
                // fall through
            case Fragment.CREATED:
                // We want to unconditionally run this anytime we do a moveToState that
                // moves the Fragment above INITIALIZING, including cases such as when
                // we move from CREATED => CREATED as part of the case fall through above.
                if (newState > Fragment.INITIALIZING) 
                    fragmentStateManager.ensureInflatedView();
                

                if (newState > Fragment.CREATED) 
                    fragmentStateManager.createView();
                
                // fall through
            case Fragment.VIEW_CREATED:
                if (newState > Fragment.VIEW_CREATED) 
                    fragmentStateManager.activityCreated();
                
                // fall through
            case Fragment.ACTIVITY_CREATED:
                if (newState > Fragment.ACTIVITY_CREATED) 
                    fragmentStateManager.start();
                
                // fall through
            case Fragment.STARTED:
                if (newState > Fragment.STARTED) 
                    fragmentStateManager.resume();
                
        
     else if (f.mState > newState) 
        switch (f.mState) 
            case Fragment.RESUMED:
                if (newState < Fragment.RESUMED) 
                    fragmentStateManager.pause();
                
                // fall through
            case Fragment.STARTED:
                if (newState < Fragment.STARTED) 
                    fragmentStateManager.stop();
                
                // fall through
            case Fragment.ACTIVITY_CREATED:
                if (newState < Fragment.ACTIVITY_CREATED) 
                    if (isLoggingEnabled(Log.DEBUG)) 
                        Log.d(TAG, "movefrom ACTIVITY_CREATED: " + f);
                    
                    if (f.mView != null) 
                        // Need to save the current view state if not
                        // done already.
                        if (mHost.onShouldSaveFragmentState(f) && f.mSavedViewState == null) 
                            fragmentStateManager.saveViewState();
                        
                    
                
                // fall through
            case Fragment.VIEW_CREATED:
                if (newState < Fragment.VIEW_CREATED) 
                    FragmentAnim.AnimationOrAnimator anim = null;
                    if (f.mView != null && f.mContainer != null) 
                        // Stop any current animations:
                        f.mContainer.endViewTransition(f.mView);
                        f.mView.clearAnimation();
                        // If parent is being removed, no need to handle child animations.
                        if (!f.isRemovingParent()) 
                            if (mCurState > Fragment.INITIALIZING && !mDestroyed
                                    && f.mView.getVisibility() == View.VISIBLE
                                    && f.mPostponedAlpha >= 0) 
                                anim = FragmentAnim.loadAnimation(mHost.getContext(),
                                        f, false, f.getPopDirection());
                            
                            f.mPostponedAlpha = 0;
                            // Robolectric tests do not post the animation like a real device
                            // so we should keep up with the container and view in case the
                            // fragment view is destroyed before we can remove it.
                            ViewGroup container = f.mContainer;
                            View view = f.mView;
                            if (anim != null) 
                                FragmentAnim.animateRemoveFragment(f, anim,
                                        mFragmentTransitionCallback);
                            
                            container.removeView(view);
                            if (FragmentManager.isLoggingEnabled(Log.VERBOSE)) 
                                Log.v(FragmentManager.TAG, "Removing view " + view + " for "
                                        + "fragment " + f + " from container " + container);
                            
                            // If the local container is different from the fragment
                            // container, that means onAnimationEnd was called, onDestroyView
                            // was dispatched and the fragment was already moved to state, so
                            // we should early return here instead of attempting to move to
                            // state again.
                            if (container != f.mContainer) 
                                return;
                            
                        
                    
                    // If a fragment has an exit animation (or transition), do not destroy
                    // its view immediately and set the state after animating
                    if (mExitAnimationCancellationSignals.get(f) == null) 
                        fragmentStateManager.destroyFragmentView();
                    
                
                // fall through
            case Fragment.CREATED:
                if (newState < Fragment.CREATED) 
                    if (mExitAnimationCancellationSignals.get(f) != null) 
                        // We are waiting for the fragment's view to finish animating away.
                        newState = Fragment.CREATED;
                     else 
                        fragmentStateManager.destroy();
                    
                
                // fall through
            case Fragment.ATTACHED:
                if (newState < Fragment.ATTACHED) 
                    fragmentStateManager.detach();
                
        
    

    if (f.mState != newState) 
        if (isLoggingEnabled(Log.DEBUG)) 
            Log.d(TAG, "moveToState: Fragment state for " + f + " not updated inline; "
                    + "expected state " + newState + " found " + f.mState);
        
        f.mState = newState;
    

该方法是整个Fragment框架中的核心方法，它会根据目标state和Fragment当前的state一步一步的升级或降级Fragment的State。最终回调到Fragment的相关生命周期方法。 至此整个commit方法的调用链条就分析完毕了。

由于篇幅有限，mManager.moveToState(Fragment f, int newState)我将新写一篇文章，专门图解一番。其实LifeCycle组件的State变化也是类似的，一步一步升级或降级。

最后

小编分享一些 Android 开发相关的学习文档、面试题、Android 核心笔记等等文档，希望能帮助到大家学习提升，如有需要参考的可以直接去我 CodeChina地址：https://codechina.csdn.net/u012165769/Android-T3 访问查阅。