概述

平时开发中经常使用Fragment的场景是创建Fragment并添加到FragmentActivity的指定布局容器中。要实现这样的操作，首先需要获取FragmentManager，接着开启事务FragmentTransaction，并添加add、remove、replace、hide、show等等操作，最后commitXXX提交事务执行对应操作。

接下来进入源码追踪这个过程，看看FragmentManager是如何进行调度执行。

源码探究

文中源码基于’androidx.fragment:fragment:1.1.0’

FragmentManager的由来

在FragmentActivity中通过getSupportFragmentManager方法来获取FragmentManager：

[FragmentActivity.java]

public FragmentManager getSupportFragmentManager() {return mFragments.getSupportFragmentManager();
}

该方法中又通过mFragments成员来获取：
[FragmentController.java]

public FragmentManager getSupportFragmentManager() {return mHost.mFragmentManager;
}

其中又通过mHost成员来获取。

在研究FragmentManager之前，先来看看mFragments、mHost是什么。

FragmentController

先来看看FragmentActivity的mFragments成员：

[FragmentActivity.java]

public class FragmentActivity extends ComponentActivity implementsActivityCompat.OnRequestPermissionsResultCallback,ActivityCompat.RequestPermissionsRequestCodeValidator {// ···final FragmentController mFragments = FragmentController.createController(new HostCallbacks());// ···
}

mFragments为FragmentController对象。

接着看createController方法，这里传入HostCallbacks实例：
[FragmentController.java]

public static FragmentController createController(@NonNull FragmentHostCallback<?> callbacks) {return new FragmentController(checkNotNull(callbacks, "callbacks == null"));
}private FragmentController(FragmentHostCallback<?> callbacks) {// 持有HostCallbacks引用mHost = callbacks;
}

HostCallbacks

在创建FragmentController时，实例化了HostCallbacks并赋值给FragmentController的mHost成员。

[FragmentActivity.java]

class HostCallbacks extends FragmentHostCallback<FragmentActivity> implementsViewModelStoreOwner,OnBackPressedDispatcherOwner {public HostCallbacks() {super(FragmentActivity.this /*fragmentActivity*/);}// ···
}

HostCallbacks继承自FragmentHostCallback，为FragmentActivity的内部类，持有FragmentActivity的引用。

[FragmentHostCallback.java]

public abstract class FragmentHostCallback<E> extends FragmentContainer {// ···FragmentHostCallback(@NonNull FragmentActivity activity) {this(activity, activity /*context*/, new Handler(), 0 /*windowAnimations*/);}FragmentHostCallback(@Nullable Activity activity, @NonNull Context context,@NonNull Handler handler, int windowAnimations) {// 持有FragmentActivity上下文引用mActivity = activity;mContext = Preconditions.checkNotNull(context, "context == null");// 构造函数中创建的Handler，默认运行在主线程mHandler = Preconditions.checkNotNull(handler, "handler == null");// 动画相关，默认为0mWindowAnimations = windowAnimations;}// ···
}

可以看出HostCallbacks持有当前FragmentActivity上下文，并创建了一个主线程Handler。

FragmentManagerImpl

FragmentManager为抽象类，而FragmentManagerImpl是其实现类：

[FragmentManagerImpl.java]

final class FragmentManagerImpl extends FragmentManager implements LayoutInflater.Factory2 {// ···
}

在FragmentHostCallback实例化时会创建FragmentManagerImpl：
[FragmentHostCallback.java]

public abstract class FragmentHostCallback<E> extends FragmentContainer {// ···final FragmentManagerImpl mFragmentManager = new FragmentManagerImpl();// ···
}

FragmentHostCallback的mFragmentManager成员持有FragmentManagerImpl。

FragmentManagerImpl的绑定

在FragmentActivity的onCreate方法中：
[FragmentActivity.java]

protected void onCreate(@Nullable Bundle savedInstanceState) {// 调用FragmentController的attachHost方法，参数传nullmFragments.attachHost(null /*parent*/);// ···
}

接着看attachHost方法：
[FragmentController.java]

public void attachHost(@Nullable Fragment parent) {// 调用FragmentManagerImpl的attachController方法，并传入HostCallbacks实例，参数parent为null。mHost.mFragmentManager.attachController(mHost, mHost /*container*/, parent);
}

进入FragmentManagerImpl的attachController方法：
[FragmentManagerImpl.java]

public void attachController(@NonNull FragmentHostCallback host,@NonNull FragmentContainer container, @Nullable final Fragment parent) {if (mHost != null) throw new IllegalStateException("Already attached");// 持有HostCallbacks引用mHost = host;mContainer = container;mParent = parent;if (mParent != null) {// Since the callback depends on us being the primary navigation fragment,// update our callback now that we have a parent so that we have the correct// state by defaultupdateOnBackPressedCallbackEnabled();}// Set up the OnBackPressedCallback// 省略BackPressed设置部分// ···// Get the FragmentManagerViewModel// 省略ViewModel设置部分// ···
}

FragmentActivity在onCreate中进行FragmentManagerImpl的绑定操作，在FragmentManagerImpl的attachController方法中接收HostCallbacks实例并保存。

FragmentController、HostCallbacks、FragmentManagerImpl之间关系

FragmentActivity持有FragmentController引用，FragmentController持有HostCallbacks引用，HostCallbacks持有FragmentActivity引用，FragmentActivity和FragmentManagerImpl互相持有引用。

FragmentActivity通过FragmentController获取HostCallbacks，再通过HostCallbacks间接调用FragmentManagerImpl。FragmentManagerImpl通过HostCallbacks来间接获取上下文和执行回调方法。

添加事务操作

开启事务

获取到FragmentManagerImpl实例后，通过它的beginTransaction方法开启一个事务：
[FragmentManagerImpl.java]

public FragmentTransaction beginTransaction() {return new BackStackRecord(this);
}

这里创建BackStackRecord（继承自FragmentTransaction，并实现BackStackEntry、OpGenerator接口），BackStackRecord将持有FragmentManagerImpl。

FragmentTransaction封装一个事务，一个事务包含一组操作（单个或多个操作）。

添加add Fragment的操作

这里以，往FragmentActivity中添加一个Fragment为例。

通常添加Fragment是通过调用FragmentTransaction的add方法，传入布局ID和Fragment实例：
[FragmentTransaction.java]

public FragmentTransaction add(@IdRes int containerViewId, @NonNull Fragment fragment,@Nullable String tag) {// tag可选参数，可通过tag查找fragment，OP_ADD标识add操作类型doAddOp(containerViewId, fragment, tag, OP_ADD);return this;
}

BackStackRecord重写了doAddOp方法：
[BackStackRecord.java]

void doAddOp(int containerViewId, Fragment fragment, @Nullable String tag, int opcmd) {super.doAddOp(containerViewId, fragment, tag, opcmd);// 将持有的FragmentManagerImpl赋值给Fragment的mFragmentManager成员fragment.mFragmentManager = mManager;
}

该方法中通过super还是调用FragmentTransaction的doAddOp，只是在执行完后为Fragment的mFragmentManager成员赋值。

[FragmentTransaction.java]

void doAddOp(int containerViewId, Fragment fragment, @Nullable String tag, int opcmd) {final Class<?> fragmentClass = fragment.getClass();final int modifiers = fragmentClass.getModifiers();// 检查fragment是否是匿名类，或者非public访问性，或者定义在另一个类中但没有声明staticif (fragmentClass.isAnonymousClass() || !Modifier.isPublic(modifiers)|| (fragmentClass.isMemberClass() && !Modifier.isStatic(modifiers))) {throw new IllegalStateException("Fragment " + fragmentClass.getCanonicalName()+ " must be a public static class to be  properly recreated from"+ " instance state.");}if (tag != null) {// 检查是否fragment已有tag但和当前传入的tag不同if (fragment.mTag != null && !tag.equals(fragment.mTag)) {throw new IllegalStateException("Can't change tag of fragment "+ fragment + ": was " + fragment.mTag+ " now " + tag);}// fragment保存tagfragment.mTag = tag;}// containerViewId即为FragmentActivity中用于添加这个fragment的布局容器IDif (containerViewId != 0) {if (containerViewId == View.NO_ID) {throw new IllegalArgumentException("Can't add fragment "+ fragment + " with tag " + tag + " to container view with no id");}// 检查是否fragment已经设置容器ID但与当前传入的ID不同if (fragment.mFragmentId != 0 && fragment.mFragmentId != containerViewId) {throw new IllegalStateException("Can't change container ID of fragment "+ fragment + ": was " + fragment.mFragmentId+ " now " + containerViewId);}// fragment保存容器ID，mFragmentId默认为容器IDfragment.mContainerId = fragment.mFragmentId = containerViewId;}// 添加操作addOp(new Op(opcmd, fragment));
}

该方法中做了以下几步：

1. 该方法中首先校验我们自定义的Fragment：

• 不能是匿名类
• 访问性必须是public
• 若是成员类，必须是静态类

2. 接着检查tag（若有传入）是否和fragment已有保存的不同，最后保存在fragment中
3. 接着检查布局ID（若有传入），该布局为FragmentActivity中用于承载fragment的ViewGroup，必须有设置ID，fragment中若已有设置必须相同，最后fragment保存容器ID，mFragmentId默认也为容器ID
4. 封装Op保存操作类型和fragment，并添加至操作集合

Op

Op表示一个操作，看它的构造函数：

[FragmentTransaction.java]

Op(int cmd, Fragment fragment) {// 保存操作类型this.mCmd = cmd;// 保存待操作的fragmentthis.mFragment = fragment;// 生命周期状态置为RESUMED，对应Activity执行onResume之后的状态this.mOldMaxState = Lifecycle.State.RESUMED;this.mCurrentMaxState = Lifecycle.State.RESUMED;
}

addOp

[FragmentTransaction.java]

void addOp(Op op) {// 保存Op对象mOps.add(op);// 动画相关，默认都为0op.mEnterAnim = mEnterAnim;op.mExitAnim = mExitAnim;op.mPopEnterAnim = mPopEnterAnim;op.mPopExitAnim = mPopExitAnim;
}

FragmentTransaction的mOps成员用于保存Op对象，mOps为ArrayList。

提交事务

FragmentTransaction有四个提交事务的方法：commit、commitAllowingStateLoss、commitNow、commitNowAllowingStateLoss。这四个方法都为抽象类，具体实现在BackStackRecord中。

这里以commitAllowingStateLoss为例：
[BackStackRecord.java]

public int commitAllowingStateLoss() {return commitInternal(true);
}int commitInternal(boolean allowStateLoss) {if (mCommitted) throw new IllegalStateException("commit already called");// 省略DEBUG部分 ···mCommitted = true;// mAddToBackStack默认为false，若调用addToBackStack方法的话为trueif (mAddToBackStack) {mIndex = mManager.allocBackStackIndex(this);} else {mIndex = -1;}// 此时传入的allowStateLoss为true// 通过FragmentManagerImpl入队mManager.enqueueAction(this, allowStateLoss);return mIndex;
}

接着看FragmentManagerImpl的enqueueAction方法，此时传入BackStackRecord自身和true：
[FragmentManagerImpl.java]

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表示待执行操作集合，action即为BackStackRecord（实现了OpGenerator接口）mPendingActions.add(action);scheduleCommit();}
}

接着看scheduleCommit方法：
[FragmentManagerImpl.java]

void scheduleCommit() {synchronized (this) {// 标记是否存在延迟事务，默认不存在boolean postponeReady =mPostponedTransactions != null && !mPostponedTransactions.isEmpty();// 标记是否仅存在一个待执行事务，第一次通过enqueueAction提交事务时符合条件boolean pendingReady = mPendingActions != null && mPendingActions.size() == 1;if (postponeReady || pendingReady) {// 符合条件，通过Handler调度任务执行mHost.getHandler().removeCallbacks(mExecCommit);mHost.getHandler().post(mExecCommit);updateOnBackPressedCallbackEnabled();}}
}

当存在延迟事务或第一次提交事务时，会通过Handler来post一个Runnable执行操作，这里的Handler即HostCallbacks实例化时创建的主线程Handler。

可见通过commit、commitAllowingStateLoss方法提交的事务不会立即执行，而是等待主线程LOOPER下一次取出消息时执行。

处理事务操作

前文中使用Handler post的mExecCommit是一个Runnable：
[FragmentManagerImpl.java]

Runnable mExecCommit = new Runnable() {@Overridepublic void run() {execPendingActions();}
};

触发时将调用execPendingActions方法处理事务操作：
[FragmentManagerImpl.java]

public boolean execPendingActions() {// 检查状态和初始化mTmpRecords、mTmpIsPop集合和处理延迟事务ensureExecReady(true);boolean didSomething = false;// 生成命令并保存在mTmpRecords、mTmpIsPop集合中while (generateOpsForPendingActions(mTmpRecords, mTmpIsPop)) {// 标记当前处于执行事务中mExecutingActions = true;try {// 移除或合并多余的操作并执行removeRedundantOperationsAndExecute(mTmpRecords, mTmpIsPop);} finally {cleanupExec();}didSomething = true;}updateOnBackPressedCallbackEnabled();// 执行推迟启动的FragmentdoPendingDeferredStart();// 清理mActive集合burpActive();return didSomething;
}

该方法中会在一个while循环中检索待执行事务并执行，当generateOpsForPendingActions返回false表示没有待执行的事务，则结束while循环。

两个集合的说明：

• mTmpRecords：保存待执行的BackStackRecord。
• mTmpIsPop：标记与mTmpRecords对应索引的BackStackRecord是添加类型还是移除类型的，默认为false，通过popBackStack回退时，会标记对应索引位置为true。

generateOpsForPendingActions

[FragmentManagerImpl.java]

private boolean generateOpsForPendingActions(ArrayList<BackStackRecord> records,ArrayList<Boolean> isPop) {// 标记是否有执行事务boolean didSomething = false;synchronized (this) {// 若不存在待执行事务则返回falseif (mPendingActions == null || mPendingActions.size() == 0) {return false;}final int numActions = mPendingActions.size();// 遍历mPendingActions，此时仅有一个OP_ADD类型的BackStackRecordfor (int i = 0; i < numActions; i++) {// 依次调用generateOps方法didSomething |= mPendingActions.get(i).generateOps(records, isPop);}// 清空mPendingActionsmPendingActions.clear();// 移除mExecCommit，避免冗余执行mHost.getHandler().removeCallbacks(mExecCommit);}return didSomething;
}

generateOps

这里以添加Fragment为例，此时mPendingActions中存在一个OP_ADD类型的BackStackRecord，查看它的generateOps方法：
[BackStackRecord.java]

public boolean generateOps(ArrayList<BackStackRecord> records, ArrayList<Boolean> isRecordPop) {if (FragmentManagerImpl.DEBUG) {Log.v(TAG, "Run: " + this);}// records集合添加BackStackRecord自身records.add(this);// isRecordPop添加falseisRecordPop.add(false);// mAddToBackStack默认为false，因此不加入回退栈if (mAddToBackStack) {mManager.addBackStackState(this);}return true;
}

removeRedundantOperationsAndExecute

[FragmentManagerImpl.java]

private void removeRedundantOperationsAndExecute(ArrayList<BackStackRecord> records,ArrayList<Boolean> isRecordPop) {if (records == null || records.isEmpty()) {return;}if (isRecordPop == null || records.size() != isRecordPop.size()) {throw new IllegalStateException("Internal error with the back stack records");}// Force start of any postponed transactions that interact with scheduled transactions:executePostponedTransaction(records, isRecordPop);final int numRecords = records.size();int startIndex = 0;for (int recordNum = 0; recordNum < numRecords; recordNum++) {// 标记是否支持操作排序优化，默认为falsefinal boolean canReorder = records.get(recordNum).mReorderingAllowed;if (!canReorder) {// execute all previous transactionsif (startIndex != recordNum) {executeOpsTogether(records, isRecordPop, startIndex, recordNum);}// execute all pop operations that don't allow reordering together or// one add operationint reorderingEnd = recordNum + 1;// 非pop事务都返回falseif (isRecordPop.get(recordNum)) {while (reorderingEnd < numRecords&& isRecordPop.get(reorderingEnd)&& !records.get(reorderingEnd).mReorderingAllowed) {reorderingEnd++;}}// 执行指定索引区间中的BackStackRecordexecuteOpsTogether(records, isRecordPop, recordNum, reorderingEnd);startIndex = reorderingEnd;recordNum = reorderingEnd - 1;}}if (startIndex != numRecords) {// 开启操作排序优化情况下可能会满足该if条件executeOpsTogether(records, isRecordPop, startIndex, numRecords);}
}

操作排序优化

当有多个待执行事务时，FragmentManager会删除部分冗余事务操作。例如：

• 假设有两个事务对同一布局容器一起执行，一个事务添加了一个 Fragment A，下一个事务将其替换为 Fragment B。则优化后会将第一个操作取消，仅添加 Fragment B。
• 假设有三个事务，一个事务添加了 Fragment A，第二个事务添加了 Fragment B，然后第三个删除了 Fragment A。那么优化后将不会执行 Fragment A的添加和删除，仅添加 Fragment B。

排序优化操作会导致出现超出开发者预期的行为，因此默认不进行此操作。

executeOpsTogether

进入executeOpsTogether方法：
[FragmentManagerImpl.java]

private void executeOpsTogether(ArrayList<BackStackRecord> records,ArrayList<Boolean> isRecordPop, int startIndex, int endIndex) {// ···executeOps(records, isRecordPop, startIndex, endIndex);// ···
}

进入executeOps方法：
[FragmentManagerImpl.java]

private static void executeOps(ArrayList<BackStackRecord> records,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);// OP_ADD类型执行executeOpsrecord.executeOps();}}
}

executeOps

看BackStackRecord的executeOps方法中的OP_ADD case：
[BackStackRecord.java]

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.setNextTransition(mTransition, mTransitionStyle);}switch (op.mCmd) {case OP_ADD:f.setNextAnim(op.mEnterAnim);// 添加FragmentmManager.addFragment(f, false);break;// 省略其他case ···default:throw new IllegalArgumentException("Unknown cmd: " + op.mCmd);}if (!mReorderingAllowed && op.mCmd != OP_ADD && f != null) {mManager.moveFragmentToExpectedState(f);}}// mReorderingAllowed默认为falseif (!mReorderingAllowed) {// Added fragments are added at the end to comply with prior behavior.// 更新状态，这里传入FragmentManagerImpl的当前状态和truemManager.moveToState(mManager.mCurState, true);}
}

该方法中处理OP_ADD时，首先通过addFragment方法添加fragment至集合中保存，最后通过moveToState更新状态并设置fragment。

addFragment

[FragmentManagerImpl.java]

public void addFragment(Fragment fragment, boolean moveToStateNow) {if (DEBUG) Log.v(TAG, "add: " + fragment);// 将fragment添加至mActive集合保存，若设置setRetainInstance还将添加入FragmentManagerViewModel中保存makeActive(fragment);// 此时为OP_ADD操作，mDetached为falseif (!fragment.mDetached) {if (mAdded.contains(fragment)) {throw new IllegalStateException("Fragment already added: " + fragment);}synchronized (mAdded) {// fragment加入mAdded集合mAdded.add(fragment);}// mAdded用于标记该fragment是否已经加入mAdded集合fragment.mAdded = true;// mRemoving标记该fragment是否从Activity移除fragment.mRemoving = false;// 此时mView还未生成，为nullif (fragment.mView == null) {fragment.mHiddenChanged = false;}if (isMenuAvailable(fragment)) {mNeedMenuInvalidate = true;}// 此时传入的moveToStateNow为falseif (moveToStateNow) {moveToState(fragment);}}
}

将fragment添加入mActive和mAdded集合中。

moveToState

回到BackStackRecord.executeOps方法中，在方法的最后执行moveToState方法：

[FragmentManagerImpl.java]

void moveToState(int newState, boolean always) {if (mHost == null && newState != Fragment.INITIALIZING) {throw new IllegalStateException("No activity");}if (!always && newState == mCurState) {return;}// 更新状态，此时传入的newState和mCurState相等mCurState = newState;// Must add them in the proper order. mActive fragments may be out of orderfinal int numAdded = mAdded.size();// 遍历mAdded，依次取出Fragment处理for (int i = 0; i < numAdded; i++) {Fragment f = mAdded.get(i);moveFragmentToExpectedState(f);}// 省略···
}

该方法中依次取出Fragment，调用moveFragmentToExpectedState将Fragment根据最终期望的状态进行初始化设置。

mCurState成员记录FragmentManagerImpl的当前状态，状态值有：

• INITIALIZING（0）：初始状态，默认状态
• CREATED（1）：初创状态，对应onCreate、onDestroyView阶段
• ACTIVITY_CREATED（2）：created以上、started未满状态，对应onStart、onStop阶段
• STARTED（3）：started以上、resumed未满阶段，对应onResume、onPause阶段
• RESUMED（4）：resumed以上状态，对应onResume完成阶段

看moveFragmentToExpectedState方法：
[FragmentManagerImpl.java]

void moveFragmentToExpectedState(Fragment f) {if (f == null) {return;}if (!mActive.containsKey(f.mWho)) {if (DEBUG) {Log.v(TAG, "Ignoring moving " + f + " to state " + mCurState+ "since it is not added to " + this);}return;}int nextState = mCurState;if (f.mRemoving) {if (f.isInBackStack()) {nextState = Math.min(nextState, Fragment.CREATED);} else {nextState = Math.min(nextState, Fragment.INITIALIZING);}}// 调度fragment到目标状态对应阶段，并执行对应阶段的初始化设置moveToState(f, nextState, f.getNextTransition(), f.getNextTransitionStyle(), false);if (f.mView != null) {// ···}if (f.mHiddenChanged) {completeShowHideFragment(f);}
}

该方法中调用另一个moveToState重载方法：
[FragmentManagerImpl.java]

void moveToState(Fragment f, int newState, int transit, int transitionStyle,boolean keepActive) {// 省略状态检查校验部分// ···// 判断fragment的生命周期状态是否小等于FragmentManager的状态，刚创建添加的fragment状态默认为INITIALIZINGif (f.mState <= newState) {// ···switch (f.mState) {case Fragment.INITIALIZING:// 开始进入attach阶段if (newState > Fragment.INITIALIZING) {if (DEBUG) Log.v(TAG, "moveto CREATED: " + f);// 省略mSavedFragmentState部分 ···f.mHost = mHost;f.mParentFragment = mParent;f.mFragmentManager = mParent != null? mParent.mChildFragmentManager : mHost.mFragmentManager;// If we have a target fragment, push it along to at least CREATED// so that this one can rely on it as an initialized dependency.// 省略mTarget部分 ···// 省略mTargetWho部分 ···dispatchOnFragmentPreAttached(f, mHost.getContext(), false);f.performAttach();if (f.mParentFragment == null) {mHost.onAttachFragment(f);} else {f.mParentFragment.onAttachFragment(f);}dispatchOnFragmentAttached(f, mHost.getContext(), false);if (!f.mIsCreated) {dispatchOnFragmentPreCreated(f, f.mSavedFragmentState, false);f.performCreate(f.mSavedFragmentState);dispatchOnFragmentCreated(f, f.mSavedFragmentState, false);} else {f.restoreChildFragmentState(f.mSavedFragmentState);f.mState = Fragment.CREATED;}}// fall through// 注意此处无break，会继续往下匹配case执行case Fragment.CREATED:// 开始进入CreateView阶段// 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) {ensureInflatedFragmentView(f);}if (newState > Fragment.CREATED) {if (DEBUG) Log.v(TAG, "moveto ACTIVITY_CREATED: " + f);if (!f.mFromLayout) {ViewGroup container = null;if (f.mContainerId != 0) {if (f.mContainerId == View.NO_ID) {throwException(new IllegalArgumentException("Cannot create fragment "+ f+ " for a container view with no id"));}// 获取布局容器，通过FragmentActivity.this.findViewById(f.mContainerId)获取container = (ViewGroup) mContainer.onFindViewById(f.mContainerId);if (container == null && !f.mRestored) {String resName;try {resName = f.getResources().getResourceName(f.mContainerId);} catch (Resources.NotFoundException e) {resName = "unknown";}throwException(new IllegalArgumentException("No view found for id 0x"+ Integer.toHexString(f.mContainerId) + " ("+ resName+ ") for fragment " + f));}}f.mContainer = container;// performGetLayoutInflater中通过FragmentActivity上下文获取LayoutInflater// performCreateView中会触发fragment的onCreateView方法，// 返回我们自定义的视图，并赋值给mView成员f.performCreateView(f.performGetLayoutInflater(f.mSavedFragmentState), container, f.mSavedFragmentState);if (f.mView != null) {f.mInnerView = f.mView;f.mView.setSaveFromParentEnabled(false);if (container != null) {// 将fragment的view加入布局容器中container.addView(f.mView);}if (f.mHidden) {f.mView.setVisibility(View.GONE);}f.onViewCreated(f.mView, f.mSavedFragmentState);dispatchOnFragmentViewCreated(f, f.mView, f.mSavedFragmentState,false);// Only animate the view if it is visible. This is done after// dispatchOnFragmentViewCreated in case visibility is changedf.mIsNewlyAdded = (f.mView.getVisibility() == View.VISIBLE)&& f.mContainer != null;} else {f.mInnerView = null;}}f.performActivityCreated(f.mSavedFragmentState);dispatchOnFragmentActivityCreated(f, f.mSavedFragmentState, false);if (f.mView != null) {f.restoreViewState(f.mSavedFragmentState);}f.mSavedFragmentState = null;}// fall throughcase Fragment.ACTIVITY_CREATED:if (newState > Fragment.ACTIVITY_CREATED) {if (DEBUG) Log.v(TAG, "moveto STARTED: " + f);f.performStart();dispatchOnFragmentStarted(f, false);}// fall throughcase Fragment.STARTED:if (newState > Fragment.STARTED) {if (DEBUG) Log.v(TAG, "moveto RESUMED: " + f);f.performResume();dispatchOnFragmentResumed(f, false);f.mSavedFragmentState = null;f.mSavedViewState = null;}}} else if (f.mState > newState) {// 省略生命周期逆生长部分，即onPause、onStop、onDestroyView、onDestroy、onDetach// ···}if (f.mState != newState) {Log.w(TAG, "moveToState: Fragment state for " + f + " not updated inline; "+ "expected state " + newState + " found " + f.mState);// 更新fragment的状态f.mState = newState;}
}

moveToState方法中在CREATED状态阶段，完成了Fragment视图的创建（若有自定义视图），接着添加至给定的布局容器中。

moveToState方法还会根据Fragment和FragmentManager当前的生命周期状态，调度Fragment的状态更新，在其中还会触发Fragment各阶段的生命周期回调方法。

总结

前文大致跟踪了一个Fragment从新建到添加入FragmentActivity的过程。
首先FragmentManager将“添加Fragment”的行为封装成一个Op操作，再将Op加入一个事务BackStackRecord，然后将事务加入待执行队列保存，之后通过Handler调度至主线程执行。
接着FragmentManager从遍历待执行队列中的事务，依次执行。执行过程中根据操作类型以及Fragment状态和FragmentManager状态，执行Fragment对应阶段的处理和生命周期回调。