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

[Android]Fragment源码分析(肆) Fragment栈管理,,5-wow.com