Android-Fragment事务管理原理分析
2020-12-11 本文已影响0人
zzq_nene
一、Fragment事务提交的部分操作
1.相关源码概念
FragmetActivity的getSupportFragmentManager()内部是通过FragmentController.getSupportFragmentManager，而FragmentController的内部是获取的HostCallbacks对象中的FragmentManager对象，这个对象在最新版本的Androidx源码中，虽然是FragmentManagerImpl对象，但是FragmentManagerImpl其实是一个空子类。
通过FragmentManager.beginTransaction()获取FragmentTransaction对象，而FragmentManager.beginTransaction()中的方法实现如下：
public FragmentTransaction beginTransaction() {
return new BackStackRecord(this);
}
FragmentTransaction.add
FragmentTransaction.remove
FragmentTransaction.replace
FragmentTransaction.hide
FragmentTransaction.show
FragmentTransaction.setPrimaryNavigationFragment
FragmentTransaction.addToBackStack
FragmentTransaction.commit
FragmentTransaction的实现类只有一个BackStackRecord
其实这些所有的add、replace等，最终都是将Fragment的状态变成了ADD，然后最终在执行的时候，都是通过调用FragmentManager.moveToState方法，createView，一直开始执行生命周期，而在FragmentManager.moveToState方法中，每个生命周期执行完成之后，都会继续调用moveToState转成下一个步骤的生命周期状态。
使用事务，是为了保证连续的操作是原子性的。
调用hide和show的时候，其实并不会去走生命周期。
2.FragmentActivity#getSupportFragmentManager()
该源码逻辑在在上面已经说了，这里就贴下源码：
// FragmentActivity.java
public FragmentManager getSupportFragmentManager() {
// 这里的mFragments其实就是FragmentController对象
return mFragments.getSupportFragmentManager();
}
// FragmentController.java
public FragmentManager getSupportFragmentManager() {
// 获取HostCallbacks对象中创建的FragmentManager对象
return mHost.mFragmentManager;
}
// FragmentHostCallback.java 这是HostCallbacks的父类，泛型是传入的FragmentActivity
final FragmentManager mFragmentManager = new FragmentManagerImpl();
3.FragmentManager#beginTransaction
// 获取事务类，BackStackRecord其实就是FragmentTransaction的子类实现
public FragmentTransaction beginTransaction() {
return new BackStackRecord(this);
}
// 从BackStackRecord的源码可以看出，BackStackRecord实现了FragmentTransaction抽象类
// 还实现了FragmentManager.OpGenerator接口，所以在这个流程中，保存事务的时候，可能会以FragmentManager.OpGenerator对象
// 也可能会以BackStackRecord保存，这是同一个。
final class BackStackRecord extends FragmentTransaction implements
FragmentManager.BackStackEntry, FragmentManager.OpGenerator {
4.FragmentTransaction#add
（1）直接传入Fragment的Class对象，在内部创建Fragment
public final FragmentTransaction add(@NonNull Class<? extends Fragment> fragmentClass,
@Nullable Bundle args, @Nullable String tag) {
return add(createFragment(fragmentClass, args), tag);
}
public FragmentTransaction add(@NonNull Fragment fragment, @Nullable String tag) {
// 调用add方法，设置Op的mCmd指令为OP_ADD
doAddOp(0, fragment, tag, OP_ADD);
return this;
}
（2）传入布局控件id和Fragment对象
public final FragmentTransaction add(@IdRes int containerViewId,
@NonNull Class<? extends Fragment> fragmentClass, @Nullable Bundle args) {
return add(containerViewId, createFragment(fragmentClass, args));
}
public FragmentTransaction add(@IdRes int containerViewId, @NonNull Fragment fragment) {
doAddOp(containerViewId, fragment, null, OP_ADD);
return this;
}
5.FragmentTransaction#doAddOp
如果传入的是Fragment的Class对象，这doAddOp操作的第一个参数直接传0，如果是传入具体的containerViewId，则使用具体的containerViewId
// 这步的主要操作就是设置tag和containerId
void doAddOp(int containerViewId, Fragment fragment, @Nullable String tag, int opcmd) {
final Class<?> fragmentClass = fragment.getClass();
final int modifiers = fragmentClass.getModifiers();
if (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) {
if (fragment.mTag != null && !tag.equals(fragment.mTag)) {
throw new IllegalStateException("Can't change tag of fragment "
+ fragment + ": was " + fragment.mTag
+ " now " + tag);
}
fragment.mTag = tag;
}
// 判断布局id是否为0，如果不为0，设置给fragment对象的mContainerId值
// 这是用于在fragment对象进行createView的时候使用
if (containerViewId != 0) {
if (containerViewId == View.NO_ID) {
throw new IllegalArgumentException("Can't add fragment "
+ fragment + " with tag " + tag + " to container view with no id");
}
if (fragment.mFragmentId != 0 && fragment.mFragmentId != containerViewId) {
throw new IllegalStateException("Can't change container ID of fragment "
+ fragment + ": was " + fragment.mFragmentId
+ " now " + containerViewId);
}
// 设置宿主ID为布局ID
fragment.mContainerId = fragment.mFragmentId = containerViewId;
}
// 将fragment和opcmd指令封装成一个Op对象，Op对象其是对于Fragment的操作对象，封装fragment的相关操作信息
addOp(new Op(opcmd, fragment));
}
6.FragmentTransaction#addOp
void addOp(Op op) {
// 将每个Fragment相关的操作对象添加到ArrayList集合中，用于提交的时候使用
mOps.add(op);
op.mEnterAnim = mEnterAnim;
op.mExitAnim = mExitAnim;
op.mPopEnterAnim = mPopEnterAnim;
op.mPopExitAnim = mPopExitAnim;
}
7.BackStackRecord#commit
BackStackRecord的提交有四个方法，这里做统一分析：然后最后就分析commit()的后续流程，因为大体相同，主要就是异步和同步提交不同。
// commit() 在主线程中异步执行，其实也是 Handler 抛出任务，等待主线程调度执行。
// commit需要在Activity保存状态之前提交，否则会报错。
// 因为Activity出现异常需要恢复状态，在保存状态之后的commit会丢失
@Override
public int commit() {
return commitInternal(false);
}
// commitAllowingStateLoss() 也是异步执行，但它的不同之处在于，允许在 Activity
// 保存状态之后调用，也就是说它遇到状态丢失不会报错。
@Override
public int commitAllowingStateLoss() {
return commitInternal(true);
}
// 这是同步执行的。立即提交事务。与FragmentManager.executePendingTransactions
// 类似，但是推荐使用commitNow。因为executePendingTransactions会一次性
// 执行所有待执行的事务，可能会有副作用。而且executePendingTransactions方法提交
// 的事务可能不会被添加到FragmentManager的回退栈中，因为这样直接提交可能会影响
// 其他异步执行任务在栈中的顺序
// commitNow的提交也不能在状态保存之后进行
// TODO:这两个方法在调用的时候，是禁止使用回退栈功能的
@Override
public void commitNow() {
disallowAddToBackStack();
mManager.execSingleAction(this, false);
}
@Override
public void commitNowAllowingStateLoss() {
disallowAddToBackStack();
mManager.execSingleAction(this, true);
}
8.BackStackRecord#commitInternal
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;
// 这里的index，其实是记录当前事务可以放置的位置的
// 如果是fragment-1.1.0版本，是采用两个集合的方式，一个集合保存BackStackRecord
// 另一个集合保存因为回退之后，空出来的位置的索引
// 但是在fragment-1.2.1版本中，采用的是AtomicInteger，比较并交换的做法
if (mAddToBackStack) {
// 这里是回退栈可用的情况，则需要计算一个index
// 这里因为Androidx版本的区别，实现也不同。
// 这里的代码是fragment-1.2.1版本的库
mIndex = mManager.allocBackStackIndex();
// 如果是fragment-1.1.0的库，则与这里实现不同，如下所示
// mIndex = mManager.allocBackStackIndex(this);
} else {
mIndex = -1;
}
mManager.enqueueAction(this, allowStateLoss);
return mIndex;
}
9.FragmentManager#allocBackStackIndex()
这是fragment-1.2.1-androidx的源码
这里采用AtomicInteger，是为了保证在异步提交事务处理的时候，保证index的一个原子性
int allocBackStackIndex() {
return mBackStackIndex.getAndIncrement();
}
对比fragment-1.1.0-androidx的源码
在这里，是采用两个ArrayList数组的方式，一个用来保存当前提交的事务，而另一个是用来保存当前事务集合中的可用位置，这样说可能比较抽象，看源码分析。
public int allocBackStackIndex(BackStackRecord bse) {
synchronized (this) {
// 第一次提交的时候，mAvailBackStackIndices是为null或者size==0的
// 所以执行if条件
if (mAvailBackStackIndices == null || mAvailBackStackIndices.size() <= 0) {
// 初始化mBackStackIndices保存事务
if (mBackStackIndices == null) {
mBackStackIndices = new ArrayList<BackStackRecord>();
}
// 找到当前添加的事务的索引位置，在这里，因为是添加到了mBackStackIndices的末尾
// 所以添加的集合的索引位置其实就是添加之前的集合的长度
int index = mBackStackIndices.size();
if (DEBUG) Log.v(TAG, "Setting back stack index " + index + " to " + bse);
mBackStackIndices.add(bse);
return index;
} else {
int index = mAvailBackStackIndices.remove(mAvailBackStackIndices.size()-1);
if (DEBUG) Log.v(TAG, "Adding back stack index " + index + " with " + bse);
mBackStackIndices.set(index, bse);
return index;
}
}
}
// 向之前回退位置的存储集合位置上添加事务
public void setBackStackIndex(int index, BackStackRecord bse) {
synchronized (this) {
if (mBackStackIndices == null) {
mBackStackIndices = new ArrayList<BackStackRecord>();
}
int N = mBackStackIndices.size();
// 如果index小于mBackStackIndices的长度，说明mBackStackIndices中有取出添加到回退栈的事务
// 那么基于复用原则，继续复用之前取出的位置存放当前添加的事务
if (index < N) {
if (DEBUG) Log.v(TAG, "Setting back stack index " + index + " to " + bse);
mBackStackIndices.set(index, bse);
} else {
// 如果存储集合的长度是小于要添加的位置，则向集合的末尾添加事务
while (N < index) {
mBackStackIndices.add(null);
if (mAvailBackStackIndices == null) {
mAvailBackStackIndices = new ArrayList<Integer>();
}
if (DEBUG) Log.v(TAG, "Adding available back stack index " + N);
mAvailBackStackIndices.add(N);
N++;
}
if (DEBUG) Log.v(TAG, "Adding back stack index " + index + " with " + bse);
// 这里是index==N的条件
mBackStackIndices.add(bse);
}
}
}
// 释放存储事务集合中的事务
public void freeBackStackIndex(int index) {
synchronized (this) {
// 在释放mBackStackIndices中的事务的时候，并不是单纯的将集合的index位置释放，然后重新排序集合
// 而是采用一个null来填充，用于下一次的复用
mBackStackIndices.set(index, null);
if (mAvailBackStackIndices == null) {
mAvailBackStackIndices = new ArrayList<Integer>();
}
if (DEBUG) Log.v(TAG, "Freeing back stack index " + index);
// 这里存储的其实就是之前被释放的事务的位置，这样的做法，其实就是方便
// 下一次添加事务的时候，能够精准的找到mBackStackIndices中对应的位置存放事务
mAvailBackStackIndices.add(index);
}
}
10.FragmentManager#enqueueAction
void enqueueAction(@NonNull OpGenerator action, boolean allowStateLoss) {
// 判断是否需要检查状态，即是否允许在保存状态之后提交事务进行丢弃
// 如果allowStateLoss是false，则需要检查当前事务提交的时候是否已经进行onSaveInstanceState操作
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();
}
// mPendingActions中添加的是正在等待处理的事务
synchronized (mPendingActions) {
// 如果HostCallbacks对象为null，判断allowStateLoss是否为true
// 如果为true，则直接return，否则抛出异常，提示activity已经被销毁
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();
}
}
11.FragmentManager#scheduleCommit
// 执行异步任务
void scheduleCommit() {
synchronized (mPendingActions) {
boolean postponeReady =
mPostponedTransactions != null && !mPostponedTransactions.isEmpty();
boolean pendingReady = mPendingActions.size() == 1;
if (postponeReady || pendingReady) {
// 这里就是采用之前添加到HostCallbacks对象中的Handler来执行异步任务操作
// 首先删除上一次执行的提交的任务
mHost.getHandler().removeCallbacks(mExecCommit);
// 然后再执行当前新的提交请求
// mExecCommit其实是一个Runnable对象
mHost.getHandler().post(mExecCommit);
updateOnBackPressedCallbackEnabled();
}
}
}
12.FragmentManager#mExecCommit对象
private Runnable mExecCommit = new Runnable() {
@Override
public void run() {
// 由HostCallbacks中的Handler进行执行该任务
execPendingActions(true);
}
};
13.FragmentManager#execPendingActions
// 只能从主线程调用该方法
boolean execPendingActions(boolean allowStateLoss) {
// 确保执行是处于就绪阶段，即没有正在执行的事务，也HostCallbacks也不为null
// 且是在主线程中，并且初始化mTmpRecords和mTmpIsPop
// 这里就是针对execPendingActions的方法执行的线程检查的操作
ensureExecReady(allowStateLoss);
boolean didSomething = false;
// 这里的操作，其实就是在mPendingActions中取出BackStackRecord
// mPendingActions中存的是OpGenerator，而BackStackRecord实现了该接口
// mTmpRecords存的就是BackStackRecord
// 所以这里的目的就算将待执行的事务添加到mTmpRecords
// 而在mTmpIsPop对应位置会根据是否允许添加到回退栈而设置true还是false
// 这里如果mPendingActions为null，则直接返回false
while (generateOpsForPendingActions(mTmpRecords, mTmpIsPop)) {
mExecutingActions = true;
try {
// 这里是删除冗余操作，并且执行事务
// 所谓的冗余操作：比如一次事务提交，对一个Fragment进行了add
// 又进行了remove，然后又进行了add，这样只有最后一次add有效
// 在这里会修改事务的状态，比如将replace的事务变成ADD的
// 最终就会执行处理事务
// 如果没有回退栈相关，则是调用事务BackStackRecord.executeOps方法
removeRedundantOperationsAndExecute(mTmpRecords, mTmpIsPop);
} finally {
cleanupExec();
}
didSomething = true;
}
updateOnBackPressedCallbackEnabled();
// 执行延迟启动的Fragment，修改其状态
doPendingDeferredStart();
// 这里为了防止列表错误，将mActive的值置为null
// 而不是在Fragment变为非活动状态的时候将其删除。
// 但是在执行事务结束时会清理列表
mFragmentStore.burpActive();
return didSomething;
}
14.FragmentManager#removeRedundantOperationsAndExecute
这里的主要目的就是为了移除事务提交过程中，事务列表中冗余的BackStackRecord对象。
private void removeRedundantOperationsAndExecute(@NonNull ArrayList<BackStackRecord> records,
@NonNull ArrayList<Boolean> isRecordPop) {
if (records.isEmpty()) {
return;
}
if (records.size() != isRecordPop.size()) {
throw new IllegalStateException("Internal error with the back stack records");
}
// 针对与计划处理的事务有交互的任何延迟的事务，进行强制执行
// 不过这些事务是过去延迟处理，但是当前已经准备好的事务
executePostponedTransaction(records, isRecordPop);
final int numRecords = records.size();
int startIndex = 0;
for (int recordNum = 0; recordNum < numRecords; recordNum++) {
final boolean canReorder = records.get(recordNum).mReorderingAllowed;
if (!canReorder) {
// 执行先前的所有事务
if (startIndex != recordNum) {
executeOpsTogether(records, isRecordPop, startIndex, recordNum);
}
// 执行所有不允许重新排序的出栈操作或者事务的添加操作
int reorderingEnd = recordNum + 1;
if (isRecordPop.get(recordNum)) {
while (reorderingEnd < numRecords
&& isRecordPop.get(reorderingEnd)
&& !records.get(reorderingEnd).mReorderingAllowed) {
reorderingEnd++;
}
}
executeOpsTogether(records, isRecordPop, recordNum, reorderingEnd);
startIndex = reorderingEnd;
recordNum = reorderingEnd - 1;
}
}
if (startIndex != numRecords) {
executeOpsTogether(records, isRecordPop, startIndex, numRecords);
}
}
15.FragmentManager#executeOpsTogether
private void executeOpsTogether(@NonNull ArrayList<BackStackRecord> records,
@NonNull ArrayList<Boolean> isRecordPop, int startIndex, int endIndex) {
final boolean allowReordering = records.get(startIndex).mReorderingAllowed;
boolean addToBackStack = false;
// 添加Fragment到集合中，该集合是ADD状态的Fragment集合
if (mTmpAddedFragments == null) {
mTmpAddedFragments = new ArrayList<>();
} else {
mTmpAddedFragments.clear();
}
mTmpAddedFragments.addAll(mFragmentStore.getFragments());
Fragment oldPrimaryNav = getPrimaryNavigationFragment();
for (int recordNum = startIndex; recordNum < endIndex; recordNum++) {
final BackStackRecord record = records.get(recordNum);
final boolean isPop = isRecordPop.get(recordNum);
if (!isPop) {
// 如果是不允许出栈的，修改事务的操作状态
// 比如将replace的操作也变成了ADD操作，这里其实就是想ADD状态集合添加Fragment
oldPrimaryNav = record.expandOps(mTmpAddedFragments, oldPrimaryNav);
} else {
oldPrimaryNav = record.trackAddedFragmentsInPop(mTmpAddedFragments, oldPrimaryNav);
}
addToBackStack = addToBackStack || record.mAddToBackStack;
}
mTmpAddedFragments.clear();
if (!allowReordering) {
FragmentTransition.startTransitions(this, records, isRecordPop, startIndex, endIndex,
false, mFragmentTransitionCallback);
}
// 这里是具体执行对Fragment的add、replace、hide、show等操作的
executeOps(records, isRecordPop, startIndex, endIndex);
int postponeIndex = endIndex;
// 判断是否允许重新排序
if (allowReordering) {
ArraySet<Fragment> addedFragments = new ArraySet<>();
addAddedFragments(addedFragments);
postponeIndex = postponePostponableTransactions(records, isRecordPop,
startIndex, endIndex, addedFragments);
makeRemovedFragmentsInvisible(addedFragments);
}
if (postponeIndex != startIndex && allowReordering) {
// need to run something now
FragmentTransition.startTransitions(this, records, isRecordPop, startIndex,
postponeIndex, true, mFragmentTransitionCallback);
moveToState(mCurState, true);
}
for (int recordNum = startIndex; recordNum < endIndex; recordNum++) {
final BackStackRecord record = records.get(recordNum);
final boolean isPop = isRecordPop.get(recordNum);
if (isPop && record.mIndex >= 0) {
record.mIndex = -1;
}
record.runOnCommitRunnables();
}
if (addToBackStack) {
reportBackStackChanged();
}
}
16.BackStackRecord#expandOps
这里主要是找到旧的Fragment的导航
Fragment expandOps(ArrayList<Fragment> added, Fragment oldPrimaryNav) {
for (int opNum = 0; opNum < mOps.size(); opNum++) {
final Op op = mOps.get(opNum);
switch (op.mCmd) {
case OP_ADD:
case OP_ATTACH:
added.add(op.mFragment);
break;
case OP_REMOVE:
case OP_DETACH: {
added.remove(op.mFragment);
if (op.mFragment == oldPrimaryNav) {
mOps.add(opNum, new Op(OP_UNSET_PRIMARY_NAV, op.mFragment));
opNum++;
oldPrimaryNav = null;
}
}
break;
case OP_REPLACE: {
// REPLACE状态，如果是已经添加的，则需要删除已经添加的，然后再一次添加新的
final Fragment f = op.mFragment;
final int containerId = f.mContainerId;
boolean alreadyAdded = false;
for (int i = added.size() - 1; i >= 0; i--) {
final Fragment old = added.get(i);
if (old.mContainerId == containerId) {
// 判断旧的Fragment和当前要添加的Fragment是否一致
if (old == f) {
alreadyAdded = true;
} else {
// This is duplicated from above since we only make
// a single pass for expanding ops. Unset any outgoing primary nav.
if (old == oldPrimaryNav) {
mOps.add(opNum, new Op(OP_UNSET_PRIMARY_NAV, old));
opNum++;
oldPrimaryNav = null;
}
final Op removeOp = new Op(OP_REMOVE, old);
removeOp.mEnterAnim = op.mEnterAnim;
removeOp.mPopEnterAnim = op.mPopEnterAnim;
removeOp.mExitAnim = op.mExitAnim;
removeOp.mPopExitAnim = op.mPopExitAnim;
mOps.add(opNum, removeOp);
added.remove(old);
opNum++;
}
}
}
// 如果是已经添加，则先删除已经添加的，然后在加入新的
// 再将op.mCmd改成OP_ADD
if (alreadyAdded) {
mOps.remove(opNum);
opNum--;
} else {
op.mCmd = OP_ADD;
added.add(f);
}
}
break;
case OP_SET_PRIMARY_NAV: {
// It's ok if this is null, that means we will restore to no active
// primary navigation fragment on a pop.
mOps.add(opNum, new Op(OP_UNSET_PRIMARY_NAV, oldPrimaryNav));
opNum++;
// Will be set by the OP_SET_PRIMARY_NAV we inserted before when run
oldPrimaryNav = op.mFragment;
}
break;
}
}
return oldPrimaryNav;
}
17.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();
}
}
}
18.BackStackRecord#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.setNextTransition(mTransition);
}
switch (op.mCmd) {
case OP_ADD:
f.setNextAnim(op.mEnterAnim);
mManager.setExitAnimationOrder(f, false);
mManager.addFragment(f);
break;
case OP_REMOVE:
f.setNextAnim(op.mExitAnim);
mManager.removeFragment(f);
break;
case OP_HIDE:
f.setNextAnim(op.mExitAnim);
mManager.hideFragment(f);
break;
case OP_SHOW:
f.setNextAnim(op.mEnterAnim);
mManager.setExitAnimationOrder(f, false);
mManager.showFragment(f);
break;
case OP_DETACH:
f.setNextAnim(op.mExitAnim);
mManager.detachFragment(f);
break;
case OP_ATTACH:
f.setNextAnim(op.mEnterAnim);
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) {
mManager.moveFragmentToExpectedState(f);
}
}
if (!mReorderingAllowed) {
// 事务提交之后，根据当前状态，执行fragment的生命周期
mManager.moveToState(mManager.mCurState, true);
}
}
19.FragmentManager#addFragment/removeFragment/hideFragment/showFragment/detachFragment/attachFragment
void addFragment(@NonNull Fragment fragment) {
if (isLoggingEnabled(Log.VERBOSE)) Log.v(TAG, "add: " + fragment);
makeActive(fragment);
if (!fragment.mDetached) {
// 向mAdded集合中添加fragment，mAdded集合是保存添加的Fragment
// 用于在moveToState的处理添加的Fragment
mFragmentStore.addFragment(fragment);
fragment.mRemoving = false;
if (fragment.mView == null) {
// 添加之后，设置隐藏状态为false
fragment.mHiddenChanged = false;
}
if (isMenuAvailable(fragment)) {
mNeedMenuInvalidate = true;
}
}
}
void removeFragment(@NonNull Fragment fragment) {
if (isLoggingEnabled(Log.VERBOSE)) {
Log.v(TAG, "remove: " + fragment + " nesting=" + fragment.mBackStackNesting);
}
final boolean inactive = !fragment.isInBackStack();
if (!fragment.mDetached || inactive) {
// 从mAdded集合中删除fragment
mFragmentStore.removeFragment(fragment);
if (isMenuAvailable(fragment)) {
mNeedMenuInvalidate = true;
}
fragment.mRemoving = true;
setVisibleRemovingFragment(fragment);
}
}
void hideFragment(@NonNull Fragment fragment) {
if (isLoggingEnabled(Log.VERBOSE)) Log.v(TAG, "hide: " + fragment);
if (!fragment.mHidden) {
// 设置fragment的隐藏状态为true
fragment.mHidden = true;
// Toggle hidden changed so that if a fragment goes through show/hide/show
// it doesn't go through the animation.
fragment.mHiddenChanged = !fragment.mHiddenChanged;
setVisibleRemovingFragment(fragment);
}
}
void showFragment(@NonNull Fragment fragment) {
if (isLoggingEnabled(Log.VERBOSE)) Log.v(TAG, "show: " + fragment);
if (fragment.mHidden) {
// 设置fragment的隐藏状态
fragment.mHidden = false;
// Toggle hidden changed so that if a fragment goes through show/hide/show
// it doesn't go through the animation.
fragment.mHiddenChanged = !fragment.mHiddenChanged;
}
}
void detachFragment(@NonNull Fragment fragment) {
if (isLoggingEnabled(Log.VERBOSE)) Log.v(TAG, "detach: " + fragment);
if (!fragment.mDetached) {
fragment.mDetached = true;
if (fragment.mAdded) {
// We are not already in back stack, so need to remove the fragment.
if (isLoggingEnabled(Log.VERBOSE)) Log.v(TAG, "remove from detach: " + fragment);
mFragmentStore.removeFragment(fragment);
if (isMenuAvailable(fragment)) {
mNeedMenuInvalidate = true;
}
setVisibleRemovingFragment(fragment);
}
}
}
void attachFragment(@NonNull Fragment fragment) {
if (isLoggingEnabled(Log.VERBOSE)) Log.v(TAG, "attach: " + fragment);
if (fragment.mDetached) {
fragment.mDetached = false;
if (!fragment.mAdded) {
mFragmentStore.addFragment(fragment);
if (isLoggingEnabled(Log.VERBOSE)) Log.v(TAG, "add from attach: " + fragment);
if (isMenuAvailable(fragment)) {
mNeedMenuInvalidate = true;
}
}
}
}
20.FragmentManager#moveToState
void moveToState(int newState, boolean always) {
if (mHost == null && newState != Fragment.INITIALIZING) {
throw new IllegalStateException("No activity");
}
if (!always && newState == mCurState) {
return;
}
mCurState = newState;
// Must add them in the proper order. mActive fragments may be out of order
for (Fragment f : mFragmentStore.getFragments()) {
moveFragmentToExpectedState(f);
}
// Now iterate through all active fragments. These will include those that are removed
// and detached.
for (Fragment f : mFragmentStore.getActiveFragments()) {
if (f != null && !f.mIsNewlyAdded) {
moveFragmentToExpectedState(f);
}
}
startPendingDeferredFragments();
if (mNeedMenuInvalidate && mHost != null && mCurState == Fragment.RESUMED) {
mHost.onSupportInvalidateOptionsMenu();
mNeedMenuInvalidate = false;
}
}
21.FragmentManager#moveFragmentToExpectedState
void moveFragmentToExpectedState(@NonNull Fragment f) {
if (!mFragmentStore.containsActiveFragment(f.mWho)) {
if (isLoggingEnabled(Log.DEBUG)) {
Log.d(TAG, "Ignoring moving " + f + " to state " + mCurState
+ "since it is not added to " + this);
}
return;
}
// 在CREATED状态的时候会创建View，保存在Fragment
moveToState(f);
if (f.mView != null) {
// Move the view if it is out of order
Fragment underFragment = mFragmentStore.findFragmentUnder(f);
if (underFragment != null) {
final View underView = underFragment.mView;
// make sure this fragment is in the right order.
final ViewGroup container = f.mContainer;
int underIndex = container.indexOfChild(underView);
int viewIndex = container.indexOfChild(f.mView);
if (viewIndex < underIndex) {
container.removeViewAt(viewIndex);
container.addView(f.mView, underIndex);
}
}
if (f.mIsNewlyAdded && f.mContainer != null) {
// Make it visible and run the animations
if (f.mPostponedAlpha > 0f) {
f.mView.setAlpha(f.mPostponedAlpha);
}
f.mPostponedAlpha = 0f;
f.mIsNewlyAdded = false;
// run animations:
FragmentAnim.AnimationOrAnimator anim = FragmentAnim.loadAnimation(
mHost.getContext(), mContainer, f, true);
if (anim != null) {
if (anim.animation != null) {
f.mView.startAnimation(anim.animation);
} else {
anim.animator.setTarget(f.mView);
anim.animator.start();
}
}
}
}
// 是否隐藏的状态，如果是true，这执行完成隐藏显示Fragment的操作
if (f.mHiddenChanged) {
completeShowHideFragment(f);
}
}
