[Android]Fragment源码分析(肆) Fragment栈管理

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中存在,那么就返回暂存在这个对象中的索引值。