Fragment的栈是Fragment管理颇为出彩的一部分,它跟Activity栈的本质差异除了在数据结构上和逻辑上的不同之外，主要区别还在于：
1.Fragment管理是在进程空间内的
2.Fragment的管理一般情况下是一个Window下进行的。
Fragment的管理在一个进程空间内是比较好理解的,因为我们知道Activity的管理其实相对复杂,它的管理是通过IPC调用,IPC的一端是我们的Client,而作为Server的是Ams服务。Activity的管理是基于Window的,而Fragment的管理普遍是基于同一个window下的View来实现的。在我看来,Fragment管理无疑是Android的福音,因为它更轻量级,相对更快。而且这种Fragment注册也可以不通过注册AndroidManifest.xml的方式来实现,意味着你可以实现一个非常好的插件系统。
或许各位看官还不理解,为何子墨兄为何要在开篇如此浓墨重彩,那是因为子墨希望大家尽量的将代码结构往Fragment管理上靠。当然我还是习惯性的提醒各位,Fragment不是View，不是控件,不要用View的观点去看待它,它就是一个容器,比Activity轻量级的容器。
我们回到本章的课题,Fragment的栈管理,或许你还不能很直观的了解什么是Fragment栈,我们引入一段代码：
FragmentTransaction ft = this.getSupportFragmentManager().beginTransaction();
fragment = new TestFragment1();
ft.add(R.id.fragmentContainer, fragment, "test");
ft.setTransition( FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
<span style="color:#ff0000;"><strong>ft.addToBackStack("test");</strong></span>
ft.commitAllowingStateLoss();
上一章我们浓墨重彩写了Fragment的事务管理,我们知道,我们提交的这个事务将会在下一个UI线程消息中执行,我在里面用红色标注了一段代码addToBackStack的方法。实际上,对于里面的name参数我们可有可无。它只是我们在dump的时候的一个标识符号。我们现在这个方法上打个断点,我们知道,当我们调用这个方法的直接结果就是在我们按Back的时候,它会返回到我们上一个事务中去。我们知道对于Back按钮的处理是在Activity的onBackPressed回调中。
<pre name="code" class="java">android.support.v4.app.FragmentManager:
@Override
public boolean popBackStackImmediate() {
checkStateLoss();
executePendingTransactions();
return popBackStackState(mActivity.mHandler, null, -1, 0);
}
FragmentActivity：/** * Take care of popping the fragment back stack or finishing the activity * as appropriate. */ public void onBackPressed() { if (!mFragments.popBackStackImmediate()) { finish(); } }
FragmentManager在PopStack的时候会调用一遍executePendingTransactions，我们上一章说过,基于事务的Fragment模型会将事务存在在队列中,而这个方法就是将队列中的所有事务执行一遍。Fragment的事务管理是采用备忘录的方式,所以你所有的操作都会记录在它自己的数据结构中,而且每一个数据操作都是可逆的。这是Fragment的两点之一，也就是当你进行add的操作时候,必然有一个remove操作与其对应,这种对应的操作被记录在BackStackRecord的popFromBackStack方法中。我们先来看下这部分逻辑:
android.support.v4.app.BackStackRecord：
public void popFromBackStack(boolean doStateMove) {
...
switch (op.cmd) {
<span style="color:#ff0000;">case OP_ADD</span>: {
Fragment f = op.fragment;
f.mNextAnim = op.popExitAnim;
<span style="color:#cc0000;">mManager.removeFragment</span>(f,
FragmentManagerImpl.reverseTransit(mTransition),
mTransitionStyle);
}
}
我看看到,实际上在popFromBackStack中,BackStackRecord对本身的记录进行了逆操作,这就是为什么在你在回退Fragment栈的时候它能用逆的方式来进行Fragment管理。我们回头再说FragmentManager。为了实现Fragment的回退,首先我们要记录整个Fragment的调用流程,还有回调Fragment对应的BackStackRecord的pop方法。Fragment调用的入口之一在boolean popBackStackState(Handler handler, String
name, int id, int flags)中:
boolean popBackStackState(Handler handler, String name, int id, int flags) {
if (mBackStack == null) {
return false;
}
if (name == null && id < 0 && (flags & POP_BACK_STACK_INCLUSIVE) == 0) {
<span style="color:#3366ff;"> int last = mBackStack.size() - 1;
if (last < 0) {
return false;
}
final BackStackRecord bss = mBackStack.remove(last);
bss.popFromBackStack(true);
reportBackStackChanged();</span>
} else {
<span style="color:#ff0000;">int index = -1;
if (name != null || id >= 0) {
// If a name or ID is specified, look for that place in
// the stack.
index = mBackStack.size() - 1;
while (index >= 0) {
BackStackRecord bss = mBackStack.get(index);
if (name != null && name.equals(bss.getName())) {
break;
}
if (id >= 0 && id == bss.mIndex) {
break;
}
index--;
}
if (index < 0) {
return false;
}
if ((flags & POP_BACK_STACK_INCLUSIVE) != 0) {
index--;
// Consume all following entries that match.
while (index >= 0) {
BackStackRecord bss = mBackStack.get(index);
if ((name != null && name.equals(bss.getName()))
|| (id >= 0 && id == bss.mIndex)) {
index--;
continue;
}
break;
}
}
}
if (index == mBackStack.size() - 1) {
return false;
}
final ArrayList<BackStackRecord> states = new ArrayList<BackStackRecord>();
for (int i = mBackStack.size() - 1; i > index; i--) {
states.add(mBackStack.remove(i));
}
final int LAST = states.size() - 1;
for (int i = 0; i <= LAST; i++) {
states.get(i).popFromBackStack(i == LAST);
}
reportBackStackChanged();</span>
}
return true;
}
我们可以看出,实际上Fragment管理Fragment存储的数据结构是:mBackStack对象。它的类型是强类型的ArrayList。我们不难猜出它是采用线性表的方式来模拟Stack数据结构。蓝色部分代码比较好了解,直接取得最后一个状态,然后通过回调它的pop方法来结束Fragment对自己的管理。有些人可能会带有困惑,Fragment已经在FragmentManager中存在有记录,为何要多创建一个BackStackRecord对象来记录呢？实际上这个问题跟Activity的管理很相似,我能给你的最直观的回答就是侧重点不同,FragmentManager的侧重点是为了管理Fragment的状态,而BackStackRecord的目的是为了记录Fragment的操作。为了方便大家了解红色部分的逻辑我先引入一段代码:
if (v == view1) {
FragmentTransaction ft = this.getSupportFragmentManager().beginTransaction();
fragment = new TestFragment1();
ft.add(R.id.fragmentContainer, fragment, "test");
ft.setTransition( FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
<strong><span style="color:#ff0000;">ft.addToBackStack("test"+index);</span></strong>
ft.commitAllowingStateLoss();
index ++;
} else {
this.getSupportFragmentManager().popBackStack("test2", FragmentManager.POP_BACK_STACK_INCLUSIVE);
}
当你add到BackStack里面10个的Fragment的时候,pop到test2位置的fragment的时候,它会将BackStack中test2之后的记录都clear掉,对,就是Activity的clearTop或者Activity的启动参数设置。当然,Activity的Intent的Flag和启动模式本身就是一种东西,只不过做了包装而已。我们通过现象在回到代码就非常的好理解,它无非就是取得对应的BackStackRecord,然后记录在一个List里面,然后进行批量的消除。
好了,文章写到这里,相信你对Fragment的Stack的管理有了一个基本的认识,但是我们还是没有涉及Fragment如何加入Stack的问题。我们回调BackStackRecord的addToStack方法:
public FragmentTransaction addToBackStack(String name) {
if (!mAllowAddToBackStack) {
throw new IllegalStateException(
"This FragmentTransaction is not allowed to be added to the back stack.");
}
mAddToBackStack = true;
mName = name;
return this;
}
这里,BackStackRecord对mAddToBackStack被设置为true.在Commit的时候会分配一个index号码：
int commitInternal(boolean allowStateLoss) {
if (mCommitted)
throw new IllegalStateException("commit already called");
mCommitted = true;
if (mAddToBackStack) {
mIndex = mManager.<strong><span style="color:#33cc00;">allocBackStackIndex</span></strong>(this);
} else {
mIndex = -1;
}
mManager.enqueueAction(this, allowStateLoss);
return mIndex;
}
实际上,对于Manager分配Index的方式非常简单：
public int allocBackStackIndex(BackStackRecord bse) {
synchronized (this) {
if (<strong>mAvailBackStackIndices</strong> == null
|| mAvailBackStackIndices.size() <= 0) {
if (mBackStackIndices == null) {
mBackStackIndices = new ArrayList<BackStackRecord>();
}
int index = <strong>mBackStackIndices</strong>.size();
mBackStackIndices.add(bse);
return index;
} else {
int index = mAvailBackStackIndices
.remove(mAvailBackStackIndices.size() - 1);
mBackStackIndices.set(index, bse);
return index;
}
}
}
这里主要是两个变量mAvailBackStackIndices和mBackStackIndices。实际上我们可以比较简单的理解这两个变量,当我们pop出Fragment的时候,它会将它的index存放在mAvailBackStackIndices队列中,当我们需要申请一个index的时候如果mAvailBackStackIndices中存在,那么就返回暂存在这个对象中的索引值。
[Android]Fragment源码分析(肆) Fragment栈管理