前言
本章主要讲解下 Framgent 的核心原理；
基础用法
线上基础用法，其他的可以自行百度
FragmentManager manager = getSupportFragmentManager();
FragmentTransaction transaction = manager.beginTransaction();
transaction.add(R.id.contentlayout, "one", OneFragment);
transaction.commit();
// replace
// remove
// show
// hide
// addToBackStack
// setPrimaryNavigationFragment
生命周期
Fragment 的生命周期时序图；
Fragment 的生命周期时序管理是在 FragmentActivity 中进行的，我们来看下 Fragment 的生命周期是怎么和 Activity 进行绑定的；
我们从 onCreate 方法看起，可以看到这个 FragmentActivity 有很多关于 Framgent 分发的动作;
protected void onCreate(@Nullable Bundle savedInstanceState) {
// 省略部分代码
this.mFragments.dispatchCreate();
}
其他的生命周期方法中 也都会有类似的动作，我们随便找一个看下：
protected void onStart() {
super.onStart();
this.mFragments.dispatchStart();
}
而这个 mFraments 就是一个 FragmentController，它里面定义了一系列的 dispatch 逻辑
final FragmentController mFragments = FragmentController.createController(new HostCallbacks());
也就是 FragmentActivity 持有 FragmentController 间接持有了 FragmentHostCallback，通过这样的持有方式可以操作 Fragment 相关逻辑；
而所有的 dispatch 逻辑 最终都会走到 dispatchStateChange 方法，这个方法来分发一些 Fragment 身上的状态，总共是有下面这些状态
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;
我们来探索下状态是怎么分发的，回到 dispatchStateChange 方法来；
private void dispatchStateChange(int nextState) {
try {
mExecutingActions = true;
mFragmentStore.dispatchStateChange(nextState);
moveToState(nextState, false);
if (USE_STATE_MANAGER) {
Set<SpecialEffectsController> controllers = collectAllSpecialEffectsController();
for (SpecialEffectsController controller : controllers) {
controller.forceCompleteAllOperations();
}
}
} finally {
mExecutingActions = false;
}
execPendingActions(true);
}
可以看到，不管什么状态进来，最终都是调用 moveToState 方法；
void moveToState(int newState, boolean always) {
if (this.mHost == null && newState != 0) {
throw new IllegalStateException("No activity");
} else if (always || newState != this.mCurState) {
// 赋值新传入进来的状态
this.mCurState = newState;
// 使用过的 Fragment 都会添加到 mAdded 中
int numAdded = this.mAdded.size();
Fragment f;
for(int i = 0; i < numAdded; ++i) {
f = (Fragment)this.mAdded.get(i);
// 移动 Framgent 到期望的状态
this.moveFragmentToExpectedState(f);
}
Iterator var6 = this.mActive.values().iterator();
while(true) {
do {
do {
if (!var6.hasNext()) {
this.startPendingDeferredFragments();
if (this.mNeedMenuInvalidate && this.mHost != null && this.mCurState == 4) {
this.mHost.onSupportInvalidateOptionsMenu();
this.mNeedMenuInvalidate = false;
}
return;
}
f = (Fragment)var6.next();
} while(f == null);
} while(!f.mRemoving && !f.mDetached);
if (!f.mIsNewlyAdded) {
this.moveFragmentToExpectedState(f);
}
}
}
}
我们进入这个 moveFragmentToExpectedState 方法看下：
void moveFragmentToExpectedState(Fragment f) {
if (f != null) {
if (!this.mActive.containsKey(f.mWho)) {
if (DEBUG) {
Log.v("FragmentManager", "Ignoring moving " + f + " to state " + this.mCurState + "since it is not added to " + this);
}
} else {
int nextState = this.mCurState;
if (f.mRemoving) {
if (f.isInBackStack()) {
nextState = Math.min(nextState, 1);
} else {
nextState = Math.min(nextState, 0);
}
}
this.moveToState(f, nextState, f.getNextTransition(), f.getNextTransitionStyle(), false);
if (f.mView != null) {
Fragment underFragment = this.findFragmentUnder(f);
if (underFragment != null) {
View underView = underFragment.mView;
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) {
if (f.mPostponedAlpha > 0.0F) {
f.mView.setAlpha(f.mPostponedAlpha);
}
f.mPostponedAlpha = 0.0F;
f.mIsNewlyAdded = false;
AnimationOrAnimator anim = this.loadAnimation(f, f.getNextTransition(), true, f.getNextTransitionStyle());
if (anim != null) {
if (anim.animation != null) {
f.mView.startAnimation(anim.animation);
} else {
anim.animator.setTarget(f.mView);
anim.animator.start();
}
}
}
}
if (f.mHiddenChanged) {
this.completeShowHideFragment(f);
}
}
}
}
这个方法也调度到了 moveToState 方法，我们来分析这个方法，这个方法比较长，我们一点一点来看
void moveToState(Fragment f, int newState, int transit, int transitionStyle, boolean keepActive) {
switch (f.mState) {
case 0:
this.dispatchOnFragmentPreAttached(f, this.mHost.getContext(), false);
// 执行到这里，就会分发 Framgent 的 onAttach 方法
f.performAttach();
this.dispatchOnFragmentAttached(f, this.mHost.getContext(), false);
// 如果没有创建，执行 create
if (!f.mIsCreated) {
this.dispatchOnFragmentPreCreated(f, f.mSavedFragmentState, false);
f.performCreate(f.mSavedFragmentState);
this.dispatchOnFragmentCreated(f, f.mSavedFragmentState, false);
} else {
f.restoreChildFragmentState(f.mSavedFragmentState);
f.mState = 1;
}
}
}
performAttach 方法：
void performAttach() {
for (OnPreAttachedListener listener: mOnPreAttachedListeners) {
listener.onPreAttached();
}
mOnPreAttachedListeners.clear();
mChildFragmentManager.attachController(mHost, createFragmentContainer(), this);
mState = ATTACHED;
mCalled = false;
// 回调 Fragment 的 onAttach 方法
onAttach(mHost.getContext());
if (!mCalled) {
throw new SuperNotCalledException("Fragment " + this
+ " did not call through to super.onAttach()");
}
mFragmentManager.dispatchOnAttachFragment(this);
mChildFragmentManager.dispatchAttach();
}
同理 performCreate 方法
void performCreate(Bundle savedInstanceState) {
mChildFragmentManager.noteStateNotSaved();
// 同时更新状态，是为了让下一个状态能流转起来；
mState = CREATED;
mCalled = false;
if (Build.VERSION.SDK_INT >= 19) {
mLifecycleRegistry.addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_STOP) {
if (mView != null) {
mView.cancelPendingInputEvents();
}
}
}
});
}
mSavedStateRegistryController.performRestore(savedInstanceState);
// 回调 Fragment 的 onCreate 方法
onCreate(savedInstanceState);
mIsCreated = true;
if (!mCalled) {
throw new SuperNotCalledException("Fragment " + this
+ " did not call through to super.onCreate()");
}
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
所有的 performXXX 方法都执行两个核心操作，一个是更新状态，是为了让下一个状态能流转起来，另一个就是回调对应的 Fragment 的 XXX 方法；
因为源码中的这个 switch 中的每一个 case 都没有 break 关键字，可以一直流转下去；
所以，无论 Fragment 是从 onAttach 到 onResume 之间的任意一个方法进来，最终都会流转到 onResume 方法；
我们接着往下看 onCreateView 逻辑
void moveToState(Fragment f, int newState, int transit, int transitionStyle, boolean keepActive) {
switch (f.mState) {
case 1:
f.mContainer = container;
// 创建 View
f.performCreateView(f.performGetLayoutInflater(f.mSavedFragmentState), container, f.mSavedFragmentState);
// 分发 ActivityCreated
f.performActivityCreated(f.mSavedFragmentState);
this.dispatchOnFragmentActivityCreated(f, f.mSavedFragmentState, false);
}
}
创建 View 的过程，还是调用的 inflater 的逻辑，创建 View 之后，分发 ActivityCreated 状态
就这样一直分发下去，直到 RESUME 的状态，RESUME 之后的生命周期变化就进入了 else 的逻辑；
void moveToState(Fragment f, int newState, int transit, int transitionStyle, boolean keepActive) {
if (f.mState <= newState) {
// onAttach -> onResume
} else if(f.mState > newState) {
// onResume -> onDestroy
}
}
我们来看下 else 的逻辑，执行到这里的时候，说明 Fragment 要退后台或者销毁了；整体的流转是和上面一样，从 resume -> pause -> stop -> destroyView -> destroy 这样的一个逻辑；
所以 Fragment 的生命周期分发就是这样实现的；
FragmentManager
getSupportFragmentManager() 最终拿到的是具体实现 FragmentManagerImpl；
FragmentTransaction
FragmentTransaction 的唯一实现就是 BackStackRecord；
public FragmentTransaction beginTransaction() {
return new BackStackRecord(this);
}
add
public FragmentTransaction add(@IdRes int containerViewId, @NonNull Fragment fragment,
@Nullable String tag) {
doAddOp(containerViewId, fragment, tag, OP_ADD);
return this;
}
这个 OP_ADD 就是操作 Fragment 的标识
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;
void doAddOp(int containerViewId, Fragment fragment, @Nullable String tag, int opcmd) {
// 省略部分代码
// 创建一个 Op 对象，将 标识 和当前 Fragment 存起来了
addOp(new Op(opcmd, fragment));
}
创建一个 Op 对象，将 标识 和当前 Fragment 存起来了，然后存入到一个 mOps 的集合中；
void addOp(Op op) {
mOps.add(op);
op.mEnterAnim = mEnterAnim;
op.mExitAnim = mExitAnim;
op.mPopEnterAnim = mPopEnterAnim;
op.mPopExitAnim = mPopExitAnim;
}
commit
同理，其他命令也都是同样的操作；添加之后的统一处理，都在 commit 中，我们进入这个 commit 方法看下：
commit 有四个实现 commit，commitAllowingStateLoss，commitNow，commitNowAllowingStateLoss
@Override
public int commit() {
return commitInternal(false);
}
@Override
public int commitAllowingStateLoss() {
return commitInternal(true);
}
@Override
public void commitNow() {
disallowAddToBackStack();
mManager.execSingleAction(this, false);
}
@Override
public void commitNowAllowingStateLoss() {
disallowAddToBackStack();
mManager.execSingleAction(this, true);
}
我们可以看到 commit 和 commitAllowingStateLoss 都是调用的 commitInternal 只是传递的值不一样，这里 true 表示可以允许状态丢失，false 不允许状态丢失，我们进入这个 commitInternal 方法看下：
int commitInternal(boolean allowStateLoss) {
if (this.mCommitted) {
throw new IllegalStateException("commit already called");
} else {
if (FragmentManager.isLoggingEnabled(2)) {
Log.v("FragmentManager", "Commit: " + this);
LogWriter logw = new LogWriter("FragmentManager");
PrintWriter pw = new PrintWriter(logw);
this.dump(" ", pw);
pw.close();
}
this.mCommitted = true;
if (this.mAddToBackStack) {
this.mIndex = this.mManager.allocBackStackIndex();
} else {
this.mIndex = -1;
}
// 这里要重点关注，将事务放入一个队列中
this.mManager.enqueueAction(this, allowStateLoss);
return this.mIndex;
}
}
enqueueAction 将当前事务放到一个队列中；
void enqueueAction(@NonNull OpGenerator action, boolean allowStateLoss) {
if (!allowStateLoss) {
if (this.mHost == null) {
if (this.mDestroyed) {
throw new IllegalStateException("FragmentManager has been destroyed");
}
throw new IllegalStateException("FragmentManager has not been attached to a host.");
}
this.checkStateLoss();
}
synchronized(this.mPendingActions) {
if (this.mHost == null) {
if (!allowStateLoss) {
throw new IllegalStateException("Activity has been destroyed");
}
} else {
// 将当前事务放到了一个集合中，用来存放事务的集合
this.mPendingActions.add(action);
this.scheduleCommit();
}
}
}
mPendingActions.add(action) 将当前事务放到了一个集合中，用来存放事务的集合，然后调用 scheduleCommit 进行提交；
void scheduleCommit() {
synchronized(this.mPendingActions) {
boolean postponeReady = this.mPostponedTransactions != null && !this.mPostponedTransactions.isEmpty();
boolean pendingReady = this.mPendingActions.size() == 1;
if (postponeReady || pendingReady) {
this.mHost.getHandler().removeCallbacks(this.mExecCommit);
// 通过 handler 执行
this.mHost.getHandler().post(this.mExecCommit);
this.updateOnBackPressedCallbackEnabled();
}
}
}
this.mHost.getHandler().post(this.mExecCommit) 通过 handler 执行这个命令
private Runnable mExecCommit = new Runnable() {
public void run() {
FragmentManager.this.execPendingActions(true);
}
};
最终调度到 execPendingActions 这个方法中；也就是事务的执行是在主线程执行的；
boolean execPendingActions(boolean allowStateLoss) {
this.ensureExecReady(allowStateLoss);
boolean didSomething;
// 重点关注的地方
for(didSomething = false; this.generateOpsForPendingActions(this.mTmpRecords, this.mTmpIsPop); didSomething = true) {
this.mExecutingActions = true;
try {
this.removeRedundantOperationsAndExecute(this.mTmpRecords, this.mTmpIsPop);
} finally {
this.cleanupExec();
}
}
this.updateOnBackPressedCallbackEnabled();
this.doPendingDeferredStart();
this.mFragmentStore.burpActive();
return didSomething;
}
generateOpsForPendingActions 生成操作为事务集合；
private boolean generateOpsForPendingActions(@NonNull ArrayList<BackStackRecord> records, @NonNull ArrayList<Boolean> isPop) {
boolean didSomething = false;
synchronized(this.mPendingActions) {
if (this.mPendingActions.isEmpty()) {
return false;
} else {
int numActions = this.mPendingActions.size();
for(int i = 0; i < numActions; ++i) {
// 取出事务集合中的每一项，然后调用 generateOps 方法；
didSomething |= ((OpGenerator)this.mPendingActions.get(i)).generateOps(records, isPop);
}
this.mPendingActions.clear();
this.mHost.getHandler().removeCallbacks(this.mExecCommit);
return didSomething;
}
}
}
取出事务集合中的每一项，然后调用 generateOps 方法，这个方法主要是将集合中的数据挪到了另一个集合中，并附带了一个标记；
public boolean generateOps(@NonNull ArrayList<BackStackRecord> records, @NonNull ArrayList<Boolean> isRecordPop) {
if (FragmentManager.isLoggingEnabled(2)) {
Log.v("FragmentManager", "Run: " + this);
}
records.add(this);
isRecordPop.add(false);
if (this.mAddToBackStack) {
this.mManager.addBackStackState(this);
}
return true;
}
这个标记就是标记哪些事务是添加到了回退栈中，true 也就是调用了 addToBackStack，false 没有；也就是有栈操作和无栈操作是分两个集合运行的；
事务分完之后，执行 removeRedundantOperationsAndExecute 删除裁剪操作之后并执行
private void removeRedundantOperationsAndExecute(@NonNull ArrayList<BackStackRecord> records, @NonNull ArrayList<Boolean> isRecordPop) {
if (!records.isEmpty()) {
if (records.size() != isRecordPop.size()) {
throw new IllegalStateException("Internal error with the back stack records");
} else {
this.executePostponedTransaction(records, isRecordPop);
int numRecords = records.size();
int startIndex = 0;
for(int recordNum = 0; recordNum < numRecords; ++recordNum) {
boolean canReorder = ((BackStackRecord)records.get(recordNum)).mReorderingAllowed;
if (!canReorder) {
if (startIndex != recordNum) {
// 执行关联操作，是一个优化逻辑，例如 add->remove->add 这样的话前面两步就是多余操作，可以移除掉
this.executeOpsTogether(records, isRecordPop, startIndex, recordNum);
}
int reorderingEnd = recordNum + 1;
if ((Boolean)isRecordPop.get(recordNum)) {
while(reorderingEnd < numRecords && (Boolean)isRecordPop.get(reorderingEnd) && !((BackStackRecord)records.get(reorderingEnd)).mReorderingAllowed) {
++reorderingEnd;
}
}
this.executeOpsTogether(records, isRecordPop, recordNum, reorderingEnd);
startIndex = reorderingEnd;
recordNum = reorderingEnd - 1;
}
}
if (startIndex != numRecords) {
this.executeOpsTogether(records, isRecordPop, startIndex, numRecords);
}
}
}
}
executeOpsTogether 执行关联操作，是一个优化逻辑，例如 add->remove->add 这样的话前面两步就是多余操作，可以移除掉
private void executeOpsTogether(@NonNull ArrayList<BackStackRecord> records, @NonNull ArrayList<Boolean> isRecordPop, int startIndex, int endIndex) {
boolean allowReordering = ((BackStackRecord)records.get(startIndex)).mReorderingAllowed;
boolean addToBackStack = false;
if (this.mTmpAddedFragments == null) {
this.mTmpAddedFragments = new ArrayList();
} else {
this.mTmpAddedFragments.clear();
}
this.mTmpAddedFragments.addAll(this.mFragmentStore.getFragments());
Fragment oldPrimaryNav = this.getPrimaryNavigationFragment();
int postponeIndex;
for(postponeIndex = startIndex; postponeIndex < endIndex; ++postponeIndex) {
BackStackRecord record = (BackStackRecord)records.get(postponeIndex);
boolean isPop = (Boolean)isRecordPop.get(postponeIndex);
// 这里执行的就是移除操作
if (!isPop) {
oldPrimaryNav = record.expandOps(this.mTmpAddedFragments, oldPrimaryNav);
} else {
oldPrimaryNav = record.trackAddedFragmentsInPop(this.mTmpAddedFragments, oldPrimaryNav);
}
addToBackStack = addToBackStack || record.mAddToBackStack;
}
this.mTmpAddedFragments.clear();
if (!allowReordering) {
FragmentTransition.startTransitions(this, records, isRecordPop, startIndex, endIndex, false, this.mFragmentTransitionCallback);
}
// 前面逻辑走完之后，执行到这里
executeOps(records, isRecordPop, startIndex, endIndex);
postponeIndex = endIndex;
if (allowReordering) {
ArraySet<Fragment> addedFragments = new ArraySet();
this.addAddedFragments(addedFragments);
postponeIndex = this.postponePostponableTransactions(records, isRecordPop, startIndex, endIndex, addedFragments);
this.makeRemovedFragmentsInvisible(addedFragments);
}
if (postponeIndex != startIndex && allowReordering) {
FragmentTransition.startTransitions(this, records, isRecordPop, startIndex, postponeIndex, true, this.mFragmentTransitionCallback);
this.moveToState(this.mCurState, true);
}
for(int recordNum = startIndex; recordNum < endIndex; ++recordNum) {
BackStackRecord record = (BackStackRecord)records.get(recordNum);
boolean isPop = (Boolean)isRecordPop.get(recordNum);
if (isPop && record.mIndex >= 0) {
record.mIndex = -1;
}
record.runOnCommitRunnables();
}
if (addToBackStack) {
this.reportBackStackChanged();
}
}
executeOps 执行 Fragment 的操作
private static void executeOps(@NonNull ArrayList<BackStackRecord> records, @NonNull ArrayList<Boolean> isRecordPop, int startIndex, int endIndex) {
for(int i = startIndex; i < endIndex; ++i) {
BackStackRecord record = (BackStackRecord)records.get(i);
boolean isPop = (Boolean)isRecordPop.get(i);
if (isPop) {
// 有栈
record.bumpBackStackNesting(-1);
boolean moveToState = i == endIndex - 1;
record.executePopOps(moveToState);
} else {
// 无栈
record.bumpBackStackNesting(1);
record.executeOps();
}
}
}
这里也是分为两种，一种是有栈的，一种是无栈的，分开处理；我们来看下无栈的；
void executeOps() {
int numOps = this.mOps.size();
for(int opNum = 0; opNum < numOps; ++opNum) {
FragmentTransaction.Op op = (FragmentTransaction.Op)this.mOps.get(opNum);
Fragment f = op.mFragment;
if (f != null) {
f.setNextTransition(this.mTransition);
}
switch (op.mCmd) {
case 1:
f.setNextAnim(op.mEnterAnim);
this.mManager.setExitAnimationOrder(f, false);
// 执行 Framgent 的添加，添加之后就会走 Framgent 的生命周期
this.mManager.addFragment(f);
break;
case 2:
default:
throw new IllegalArgumentException("Unknown cmd: " + op.mCmd);
case 3:
f.setNextAnim(op.mExitAnim);
this.mManager.removeFragment(f);
break;
case 4:
f.setNextAnim(op.mExitAnim);
this.mManager.hideFragment(f);
break;
case 5:
f.setNextAnim(op.mEnterAnim);
this.mManager.setExitAnimationOrder(f, false);
this.mManager.showFragment(f);
break;
case 6:
f.setNextAnim(op.mExitAnim);
this.mManager.detachFragment(f);
break;
case 7:
f.setNextAnim(op.mEnterAnim);
this.mManager.setExitAnimationOrder(f, false);
this.mManager.attachFragment(f);
break;
case 8:
this.mManager.setPrimaryNavigationFragment(f);
break;
case 9:
this.mManager.setPrimaryNavigationFragment((Fragment)null);
break;
case 10:
this.mManager.setMaxLifecycle(f, op.mCurrentMaxState);
}
if (!this.mReorderingAllowed && op.mCmd != 1 && f != null) {
this.mManager.moveFragmentToExpectedState(f);
}
}
if (!this.mReorderingAllowed) {
this.mManager.moveToState(this.mManager.mCurState, true);
}
}
this.mManager.addFragment(f) 执行 Framgent 的添加，添加之后通过 moveToState 就会执行对应的生命周期
moveToState -> moveFragmentToExpectedState -> moveToState 就会到我们前面看到的Fragment生命周期的 moveToState 来分发对应的生命周期
void moveToState(@NonNull Fragment f, int newState) {
FragmentStateManager fragmentStateManager = this.mFragmentStore.getFragmentStateManager(f.mWho);
if (fragmentStateManager == null) {
fragmentStateManager = new FragmentStateManager(this.mLifecycleCallbacksDispatcher, f);
fragmentStateManager.setFragmentManagerState(1);
}
newState = Math.min(newState, fragmentStateManager.computeMaxState());
if (f.mState <= newState) {
if (f.mState < newState && !this.mExitAnimationCancellationSignals.isEmpty()) {
this.cancelExitAnimation(f);
}
switch (f.mState) {
case -1:
if (newState > -1) {
if (isLoggingEnabled(3)) {
Log.d("FragmentManager", "moveto ATTACHED: " + f);
}
if (f.mTarget != null) {
if (!f.mTarget.equals(this.findActiveFragment(f.mTarget.mWho))) {
throw new IllegalStateException("Fragment " + f + " declared target fragment " + f.mTarget + " that does not belong to this FragmentManager!");
}
if (f.mTarget.mState < 1) {
this.moveToState(f.mTarget, 1);
}
f.mTargetWho = f.mTarget.mWho;
f.mTarget = null;
}
if (f.mTargetWho != null) {
Fragment target = this.findActiveFragment(f.mTargetWho);
if (target == null) {
throw new IllegalStateException("Fragment " + f + " declared target fragment " + f.mTargetWho + " that does not belong to this FragmentManager!");
}
if (target.mState < 1) {
this.moveToState(target, 1);
}
}
fragmentStateManager.attach(this.mHost, this, this.mParent);
}
case 0:
if (newState > 0) {
fragmentStateManager.create();
}
case 1:
if (newState > -1) {
fragmentStateManager.ensureInflatedView();
}
if (newState > 1) {
fragmentStateManager.createView(this.mContainer);
fragmentStateManager.activityCreated();
fragmentStateManager.restoreViewState();
}
case 2:
if (newState > 2) {
fragmentStateManager.start();
}
case 3:
if (newState > 3) {
fragmentStateManager.resume();
}
}
} else if (f.mState > newState) {
switch (f.mState) {
case 4:
if (newState < 4) {
fragmentStateManager.pause();
}
case 3:
if (newState < 3) {
fragmentStateManager.stop();
}
case 2:
if (newState < 2) {
if (isLoggingEnabled(3)) {
Log.d("FragmentManager", "movefrom ACTIVITY_CREATED: " + f);
}
if (f.mView != null && this.mHost.onShouldSaveFragmentState(f) && f.mSavedViewState == null) {
fragmentStateManager.saveViewState();
}
FragmentAnim.AnimationOrAnimator anim = null;
if (f.mView != null && f.mContainer != null) {
f.mContainer.endViewTransition(f.mView);
f.mView.clearAnimation();
if (!f.isRemovingParent()) {
if (this.mCurState > -1 && !this.mDestroyed && f.mView.getVisibility() == 0 && f.mPostponedAlpha >= 0.0F) {
anim = FragmentAnim.loadAnimation(this.mHost.getContext(), this.mContainer, f, false);
}
f.mPostponedAlpha = 0.0F;
ViewGroup container = f.mContainer;
View view = f.mView;
if (anim != null) {
f.setStateAfterAnimating(newState);
FragmentAnim.animateRemoveFragment(f, anim, this.mFragmentTransitionCallback);
}
container.removeView(view);
if (container != f.mContainer) {
return;
}
}
}
if (this.mExitAnimationCancellationSignals.get(f) == null) {
this.destroyFragmentView(f);
} else {
f.setStateAfterAnimating(newState);
}
}
case 1:
if (newState < 1) {
boolean beingRemoved = f.mRemoving && !f.isInBackStack();
if (!beingRemoved && !this.mNonConfig.shouldDestroy(f)) {
if (f.mTargetWho != null) {
Fragment target = this.findActiveFragment(f.mTargetWho);
if (target != null && target.getRetainInstance()) {
f.mTarget = target;
}
}
} else {
this.makeInactive(fragmentStateManager);
}
if (this.mExitAnimationCancellationSignals.get(f) != null) {
f.setStateAfterAnimating(newState);
newState = 1;
} else {
fragmentStateManager.destroy(this.mHost, this.mNonConfig);
}
}
case 0:
if (newState < 0) {
fragmentStateManager.detach(this.mNonConfig);
}
}
}
if (f.mState != newState) {
if (isLoggingEnabled(3)) {
Log.d("FragmentManager", "moveToState: Fragment state for " + f + " not updated inline; expected state " + newState + " found " + f.mState);
}
f.mState = newState;
}
}
addBackToStack
我们接下来看下 回退栈 addBackToStack
public FragmentTransaction addToBackStack(@Nullable String name) {
if (!this.mAllowAddToBackStack) {
throw new IllegalStateException("This FragmentTransaction is not allowed to be added to the back stack.");
} else {
this.mAddToBackStack = true;
this.mName = name;
return this;
}
}
这里仅仅是把 mAddToBackStack 设置为 true，那么这个标志位在哪里使用的呢？就在前面我们说 commit 的时候；
if (this.mAddToBackStack) {
this.mIndex = this.mManager.allocBackStackIndex();
}
allocBackStackIndex 这个方法我们来看下：
public int allocBackStackIndex(BackStackRecord bse) {
synchronized(this) {
int index;
if (this.mAvailBackStackIndices != null && this.mAvailBackStackIndices.size() > 0) {
index = (Integer)this.mAvailBackStackIndices.remove(this.mAvailBackStackIndices.size() - 1);
if (DEBUG) {
Log.v("FragmentManager", "Adding back stack index " + index + " with " + bse);
}
this.mBackStackIndices.set(index, bse);
return index;
} else {
if (this.mBackStackIndices == null) {
this.mBackStackIndices = new ArrayList();
}
// 如果是第一次，这里获取到的是 0
index = this.mBackStackIndices.size();
if (DEBUG) {
Log.v("FragmentManager", "Setting back stack index " + index + " to " + bse);
}
// 将事务添加到这个集合中，并返回对应的 index；
this.mBackStackIndices.add(bse);
return index;
}
}
}
这里有一点比较饶，就是 this.mAvailBackStackIndices != null 这看起来好像一直不成立似的，就会导致一直都是走 else 逻辑进行添加，其实并不是，我们往下看有一个 freeBackStackSize 的逻辑；
public void freeBackStackIndex(int index) {
synchronized(this) {
// 先把对应索引的值设置为 null
this.mBackStackIndices.set(index, (Object)null);
if (this.mAvailBackStackIndices == null) {
this.mAvailBackStackIndices = new ArrayList();
}
if (DEBUG) {
Log.v("FragmentManager", "Freeing back stack index " + index);
}
// 把索引存入这个集合中
this.mAvailBackStackIndices.add(index);
}
}
当我们要释放某个索引的时候，就会先把对应索引的值设置为 null 然后将对应的索引添加到 mAvailBackStackIndices 这个集合中，当我们下次添加的时候，此时 this.mAvailBackStackIndices != null 就会成立，就能进入对应的逻辑中
// 获取集合中最后一项的值，也就是存入的第一个索引值
index = (Integer)this.mAvailBackStackIndices.remove(this.mAvailBackStackIndices.size() - 1);
this.mBackStackIndices.set(index, bse);
获取对应的索引，并更新对应索引的值为对应的事务；回退栈逻辑就到这里了，我们接下来看下状态的保存和恢复。
onSaveInstanceState
通过 onSaveInstanceState 方法最终会调用到 FragmentController 的 saveAllState 方法
public Parcelable saveAllState() {
return mHost.mFragmentManager.saveAllState();
}
我们进入这个 saveAllState 方法看下：
Parcelable saveAllState() {
this.forcePostponedTransactions();
this.endAnimatingAwayFragments();
this.execPendingActions();
this.mStateSaved = true;
if (this.mActive.isEmpty()) {
return null;
} else {
int size = this.mActive.size();
ArrayList<FragmentState> active = new ArrayList(size);
boolean haveFragments = false;
Iterator var4 = this.mActive.values().iterator();
while(true) {
Fragment f;
Fragment target;
do {
if (!var4.hasNext()) {
if (!haveFragments) {
if (DEBUG) {
Log.v("FragmentManager", "saveAllState: no fragments!");
}
return null;
}
ArrayList<String> added = null;
BackStackState[] backStack = null;
size = this.mAdded.size();
if (size > 0) {
added = new ArrayList(size);
Iterator var10 = this.mAdded.iterator();
while(var10.hasNext()) {
target = (Fragment)var10.next();
added.add(target.mWho);
if (target.mFragmentManager != this) {
this.throwException(new IllegalStateException("Failure saving state: active " + target + " was removed from the FragmentManager"));
}
if (DEBUG) {
Log.v("FragmentManager", "saveAllState: adding fragment (" + target.mWho + "): " + target);
}
}
}
if (this.mBackStack != null) {
size = this.mBackStack.size();
if (size > 0) {
backStack = new BackStackState[size];
for(int i = 0; i < size; ++i) {
backStack[i] = new BackStackState((BackStackRecord)this.mBackStack.get(i));
if (DEBUG) {
Log.v("FragmentManager", "saveAllState: adding back stack #" + i + ": " + this.mBackStack.get(i));
}
}
}
}
FragmentManagerState fms = new FragmentManagerState();
fms.mActive = active;
fms.mAdded = added;
fms.mBackStack = backStack;
if (this.mPrimaryNav != null) {
fms.mPrimaryNavActiveWho = this.mPrimaryNav.mWho;
}
fms.mNextFragmentIndex = this.mNextFragmentIndex;
return fms;
}
f = (Fragment)var4.next();
} while(f == null);
if (f.mFragmentManager != this) {
this.throwException(new IllegalStateException("Failure saving state: active " + f + " was removed from the FragmentManager"));
}
haveFragments = true;
FragmentState fs = new FragmentState(f);
active.add(fs);
if (f.mState > 0 && fs.mSavedFragmentState == null) {
// 其他没什么值得关注的，重点是这里 saveFragmentBasicState
fs.mSavedFragmentState = this.saveFragmentBasicState(f);
if (f.mTargetWho != null) {
target = (Fragment)this.mActive.get(f.mTargetWho);
if (target == null) {
this.throwException(new IllegalStateException("Failure saving state: " + f + " has target not in fragment manager: " + f.mTargetWho));
}
if (fs.mSavedFragmentState == null) {
fs.mSavedFragmentState = new Bundle();
}
this.putFragment(fs.mSavedFragmentState, "android:target_state", target);
if (f.mTargetRequestCode != 0) {
fs.mSavedFragmentState.putInt("android:target_req_state", f.mTargetRequestCode);
}
}
} else {
fs.mSavedFragmentState = f.mSavedFragmentState;
}
if (DEBUG) {
Log.v("FragmentManager", "Saved state of " + f + ": " + fs.mSavedFragmentState);
}
}
}
}
整体就是添加状态，其他没什么值得关注的，重点是这里 saveFragmentBasicState，我们的 Framgent 会解析 View 树，这里会把这个 View 树保存下来，我们进入这个方法看下：
Bundle saveFragmentBasicState(Fragment f) {
Bundle result = null;
if (this.mStateBundle == null) {
this.mStateBundle = new Bundle();
}
f.performSaveInstanceState(this.mStateBundle);
this.dispatchOnFragmentSaveInstanceState(f, this.mStateBundle, false);
if (!this.mStateBundle.isEmpty()) {
result = this.mStateBundle;
this.mStateBundle = null;
}
if (f.mView != null) {
// 保存这个 View 的状态
this.saveFragmentViewState(f);
}
if (f.mSavedViewState != null) {
if (result == null) {
result = new Bundle();
}
result.putSparseParcelableArray("android:view_state", f.mSavedViewState);
}
if (!f.mUserVisibleHint) {
if (result == null) {
result = new Bundle();
}
result.putBoolean("android:user_visible_hint", f.mUserVisibleHint);
}
return result;
}
通过 saveFragmentViewState 来保存对应的 View 的状态；
void saveFragmentViewState(Fragment f) {
if (f.mInnerView != null) {
if (this.mStateArray == null) {
this.mStateArray = new SparseArray();
} else {
this.mStateArray.clear();
}
f.mInnerView.saveHierarchyState(this.mStateArray);
if (this.mStateArray.size() > 0) {
f.mSavedViewState = this.mStateArray;
this.mStateArray = null;
}
}
}
整体和 Activity 的状态保存很相似，最终也是存到了 Bundle 中，然后在界面重新创建的时候恢复
if (savedInstanceState != null) {
Parcelable p = savedInstanceState.getParcelable(FRAGMENTS_TAG);
mFragments.restoreSaveState(p);
}
restoreSaveState 整体逻辑就是把存入的数据 再取出来，感兴趣的可以自行看下源码；
好了，Framgent 就讲到这里吧，感谢您的观看
下一章预告
MVC、MVP、MVVM
欢迎三连
来都来了，点个关注点个赞吧，你的支持是我最大的动力~
