android Fragmentation框架源码全面解析一

Fragmentaion框架是一个很优秀的框架，我们有2个项目都使用过，目前无不良反应，BUG呢还是有一些，不过不妨碍它的优秀。

项目地址：https://github.com/YoKeyword/Fragmentation    点击打开链接

关注好几千，群众的眼光是雪亮的。

它有啥作用呢？

Fragment是可以让你的app纵享丝滑的设计，如果你的app想在现在基础上性能大幅度提高，并且占用内存降低，同样的界面Activity占用内存比Fragment要多，响应速度Fragment比Activty在中低端手机上快了很多，甚至能达到好几倍！如果你的app当前或以后有移植平板等平台时，可以让你节省大量时间和精力。

为"单Activity ＋ 多Fragment的架构", "多模块Activity + 多Fragment的架构"而生，帮你简化使用过程，轻松解决各种复杂嵌套等问题，修复了官方Fragment库存在的一些BUG。

这句话是作者原话，意思就是说不用这个框架也可以实现它的效果，由于这个框架都封装好了我们想用的方法，可以让代码更简单，使用的感受呢就是纵享丝滑。

想详细了解，可以看看作者的全面解析博客

http://www.jianshu.com/p/d9143a92ad94    点击打开链接

下面开始进入正文

很久没更新这个框架了，我看了下，最新的和老版本核心代码都一样的，下图结构是老版本的，不过后面的代码解析都用的目前最新的版本

导入源码可以看到总共分为4个部分，最外层有SupportActivity、SupportFraggment 等，里面有3个部分：anim、debug、

helper。

最外层的SupportActivity、SupportFragment是我们需要直接继承的基类，

animi 用于SupportFragment 直接的转场动画，

debug 顾名思义用于帮助查找框架中的bug,

helper 一些辅助类。

下面我们看下ISupport,

interface ISupport {

    /**
     * 加载根Fragment, 即Activity内的第一个Fragment 或 Fragment内的第一个子Fragment
     *
     * @param containerId 容器id
     * @param toFragment  目标Fragment
     */
    void loadRootFragment(int containerId, SupportFragment toFragment);

    /**
     * 以replace方式加载根Fragment
     */
    void replaceLoadRootFragment(int containerId, SupportFragment toFragment, boolean addToBack);

    /**
     * 加载多个根Fragment
     *
     * @param containerId 容器id
     * @param toFragments 目标Fragments
     */
    void loadMultipleRootFragment(int containerId, int showPosition, SupportFragment... toFragments);

一个定义了各种以后会直接使用到的常用方法，

ISupportFragment，继承ISupport的一个接口

interface ISupportFragment extends ISupport {

    /**
     * replace目标Fragment, 主要用于Fragment之间的replace
     *
     * @param toFragment 目标Fragment
     * @param addToBack  是否添加到回退栈
     */
    void replaceFragment(SupportFragment toFragment, boolean addToBack);

    /**
     * @return 位于栈顶的子Fragment
     */
    SupportFragment getTopChildFragment();

    /**
     * @return 当前Fragment的前一个Fragment
     */
    SupportFragment getPreFragment();

在ISupport的基础上又定义了一些方法，因为定义的这些方法是在实现它的SupportFragment 中使用的。

public class SupportFragment extends Fragment implements ISupportFragment {
    // LaunchMode
    public static final int STANDARD = 0;
    public static final int SINGLETOP = 1;
    public static final int SINGLETASK = 2;

而SupportActivity是直接实现ISupport的

public class SupportActivity extends AppCompatActivity implements ISupport, SensorEventListener {
    private FragmentationDelegate mFragmentationDelegate;

    private LifecycleHelper mLifecycleHelper;
    private ArrayList<FragmentLifecycleCallbacks> mFragmentLifecycleCallbacks;

    private FragmentAnimator mFragmentAnimator;

ISupport及ISupportFragment里面定义的方法就是我们以后需要直接使用的主要方法了，

先来看下SupportActivity，

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mFragmentationDelegate = getFragmentationDelegate();
    mFragmentAnimator = onCreateFragmentAnimator();
}

初始化中创建了FragmentationDelegate对象和转场动画对象，FragmentationDelegate是干嘛的呢？

 

SupportFragment和SupportActivity中核心方法都会用到FragmentaionDelegate，

说白了整个框架的核心业务都在FragmentaionDelegate里面，主要包含了这些事务：

加载根Fragment、加载多个根Fragment、替换根Fragment、子Fragment之间的替换、隐藏显示Fragment、启动目标Fragment、

得到位于栈顶Fragment、获取栈内的Fragment、Fragment出栈、出栈到目标fragment、获取栈顶的子Fragment、

获取当前Fragment的前一个Fragment、子栈内Fragment出栈

现在开始一个一个方法突破吧！

一、加载根Fragment

void loadRootTransaction(FragmentManager fragmentManager, int containerId, ISupportFragment to, boolean addToBackStack, boolean allowAnimation) {
    fragmentManager = checkFragmentManager(fragmentManager, null);
    if (fragmentManager == null) return;

    bindContainerId(containerId, to);
    start(fragmentManager, null, to, to.getClass().getName(), !addToBackStack, null, allowAnimation, TYPE_REPLACE);
}

首先检查了下fragmentManager存不存在，不存在就没后面的，所以一般情况下是存在的，

private void bindContainerId(int containerId, ISupportFragment to) {
    Bundle args = getArguments((Fragment) to);
    args.putInt(FRAGMENTATION_ARG_CONTAINER, containerId);
}

bindContainerId() 把视图容器id存在目标Fragment的Arguments中，

private void start(FragmentManager fragmentManager, final ISupportFragment from, ISupportFragment to, String toFragmentTag,
                   boolean dontAddToBackStack, ArrayList<TransactionRecord.SharedElement> sharedElementList, boolean allowRootFragmentAnim, int type) {
    FragmentTransaction ft = fragmentManager.beginTransaction();
    boolean addMode = (type == TYPE_ADD || type == TYPE_ADD_RESULT || type == TYPE_ADD_WITHOUT_HIDE);
    Fragment fromF = (Fragment) from;
    Fragment toF = (Fragment) to;
    Bundle args = getArguments(toF);
    args.putBoolean(FRAGMENTATION_ARG_REPLACE, !addMode);

    if (sharedElementList == null) {
        if (addMode) { // Replace mode forbidden animation, the replace animations exist overlapping Bug on support-v4.

            TransactionRecord record = to.getSupportDelegate().mTransactionRecord;
            if (record != null && record.targetFragmentEnter != Integer.MIN_VALUE) {
                ft.setCustomAnimations(record.targetFragmentEnter, record.currentFragmentPopExit,
                        record.currentFragmentPopEnter, record.targetFragmentExit);
                args.putInt(FRAGMENTATION_ARG_CUSTOM_END_ANIM, record.targetFragmentEnter);
            } else {
                ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
            }
        } else {
            args.putInt(FRAGMENTATION_ARG_ROOT_STATUS, SupportFragmentDelegate.STATUS_ROOT_ANIM_DISABLE);
        }
    } else {
        args.putBoolean(FRAGMENTATION_ARG_IS_SHARED_ELEMENT, true);
        for (TransactionRecord.SharedElement item : sharedElementList) {
            ft.addSharedElement(item.sharedElement, item.sharedName);
        }
    }
    if (from == null) {
        ft.replace(args.getInt(FRAGMENTATION_ARG_CONTAINER), toF, toFragmentTag);
        if (!addMode) {
            ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
            args.putInt(FRAGMENTATION_ARG_ROOT_STATUS, allowRootFragmentAnim ?
                    SupportFragmentDelegate.STATUS_ROOT_ANIM_ENABLE : SupportFragmentDelegate.STATUS_ROOT_ANIM_DISABLE);
        }
    } else {
        if (addMode) {
            ft.add(from.getSupportDelegate().mContainerId, toF, toFragmentTag);
            if (type != TYPE_ADD_WITHOUT_HIDE) {
                ft.hide(fromF);
            }
        } else {
            ft.replace(from.getSupportDelegate().mContainerId, toF, toFragmentTag);
        }
    }

    if (!dontAddToBackStack && type != TYPE_REPLACE_DONT_BACK) {
        ft.addToBackStack(toFragmentTag);
    }
    supportCommit(fragmentManager, ft);
}

接下来这个start()就稍微复杂些了，主要业务都在里面，也是一个很公用的方法，包含了fragment的添加、替换，

参数也比较多，

FragmentManager fragmentManager：Fragment管理器

ISupportFragment from：当前Fragment

ISupportFragment to： 目标Fragment，即需要开启的Fragment，方式可能是add或replace

String toFragmentTag：目标Fragment的tag，通过这个tag可以从栈中找到它

boolean dontAddToBackStack：是否不允许添加入栈，感觉有点别扭，直接名字叫是否允许入栈多好

ArrayList<TransactionRecord.SharedElement> sharedElementList：过渡元素，过渡动画时用

boolean allowRootFragmentAnim：是否允许根Fragment动画

int type：添加Fragment的类型

这个方法主要分为3块，

第一块，判断有无过渡动画元素，添加相应的动画

第二块，当前fragment是否为空，然后做出add或replace fragment

第三块，是否允许把目标fragment添加入栈

然后提交事务。

二、加载多个根Fragment

void loadMultipleRootTransaction(FragmentManager fragmentManager, int containerId, int showPosition, ISupportFragment... tos) {
    fragmentManager = checkFragmentManager(fragmentManager, null);
    if (fragmentManager == null) return;
    FragmentTransaction ft = fragmentManager.beginTransaction();
    for (int i = 0; i < tos.length; i++) {
        Fragment to = (Fragment) tos[i];

        Bundle args = getArguments(to);
        args.putInt(FRAGMENTATION_ARG_ROOT_STATUS, SupportFragmentDelegate.STATUS_ROOT_ANIM_DISABLE);
        bindContainerId(containerId, tos[i]);

        String toName = to.getClass().getName();
        ft.add(containerId, to, toName);

        if (i != showPosition) {
            ft.hide(to);
        }
    }

    supportCommit(fragmentManager, ft);
}

这个方法比start()逻辑少点，因为这个方法没它公用的地方多，整个方法主要就要一个for循环，然后一个一个的添加，显示指定位置的Fragment，其他添加的都隐藏。

三、启动一个Fragment

public void start(ISupportFragment toFragment) {
    start(toFragment, ISupportFragment.STANDARD);
}

/**
 * @param launchMode Similar to Activity's LaunchMode.
 */
public void start(final ISupportFragment toFragment, @ISupportFragment.LaunchMode int launchMode) {
    mTransactionDelegate.dispatchStartTransaction(mFragment.getFragmentManager(), mSupportF, toFragment, 0, launchMode, TransactionDelegate.TYPE_ADD);
}

void dispatchStartTransaction(FragmentManager fragmentManager, ISupportFragment from, ISupportFragment to, int requestCode, int launchMode, int type) {
    fragmentManager = checkFragmentManager(fragmentManager, from);
    if (fragmentManager == null) return;

    checkNotNull(to, "toFragment == null");

    if (from != null) {
        if (from.getSupportDelegate().mContainerId == 0) {
            Fragment fromF = (Fragment) from;
            if (fromF.getTag() != null && !fromF.getTag().startsWith("android:switcher:")) {
                throw new RuntimeException("Can't find container, please call loadRootFragment() first!");
            }
        }
        bindContainerId(from.getSupportDelegate().mContainerId, to);
        from = SupportHelper.getTopFragment(fragmentManager, from.getSupportDelegate().mContainerId);
    }

    // process SupportTransaction
    String toFragmentTag = to.getClass().getName();
    boolean dontAddToBackStack = false;
    ArrayList<TransactionRecord.SharedElement> sharedElementList = null;
    TransactionRecord transactionRecord = to.getSupportDelegate().mTransactionRecord;
    if (transactionRecord != null) {
        if (transactionRecord.tag != null) {
            toFragmentTag = transactionRecord.tag;
        }
        dontAddToBackStack = transactionRecord.dontAddToBackStack;
        if (transactionRecord.sharedElementList != null) {
            sharedElementList = transactionRecord.sharedElementList;
            // Compat SharedElement
            FragmentationHack.reorderIndices(fragmentManager);
        }
    }

    if (type == TYPE_ADD_RESULT || type == TYPE_ADD_RESULT_WITHOUT_HIDE) {
        saveRequestCode((Fragment) to, requestCode);
    }

    if (handleLaunchMode(fragmentManager, from, to, toFragmentTag, launchMode)) return;

    if (type == TYPE_ADD_WITH_POP) {
        startWithPop(fragmentManager, from, to);
    } else {
        start(fragmentManager, from, to, toFragmentTag, dontAddToBackStack, sharedElementList, false, type);
    }
}

这也是非常核心的一个方法，将会是用得最多的方法，

如果fromFragment为空的则用加载根Fragment的方式开启，不为空就把视图容器id传给目标fragment,

接下来取出目标Fragment中的过渡动画相关的参数，然后如果添加类型为带requestCode，就调用

saveRequestCode((Fragment) to, requestCode)把这个requestCode保存起来，

if (handleLaunchMode(fragmentManager, from, to, toFragmentTag, launchMode)) return;

如果启动模式为SINGLETOP 或 SINGLETASK，就return掉，跟Activity的启动模式一样，

接下来根据条件复用startWithPop()或start()

四、出栈当前Fragment开启新Fragment

/**
 * Launch a fragment while poping self.
 */
public void startWithPop(ISupportFragment toFragment) {
    mDelegate.startWithPop(toFragment);
}

/**
 * Launch a fragment while poping self.
 */
public void startWithPop(ISupportFragment toFragment) {
    mTransactionDelegate.dispatchStartTransaction(mFragment.getFragmentManager(), mSupportF, toFragment, 0, ISupportFragment.STANDARD, TransactionDelegate.TYPE_ADD_WITH_POP);
}

看到了吧，开始调用共有方法dispatchStartTransaction()，上面刚讲到的方法，这里会通过添加类型来区分执行startWithPop()还是start()

if (type == TYPE_ADD_WITH_POP) {
    startWithPop(fragmentManager, from, to);
} else {
    start(fragmentManager, from, to, toFragmentTag, dontAddToBackStack, sharedElementList, false, type);
}

下面好好看下startWithPop()，如果FragmentManager正在执行某事务，那么把executeStartWithPop()加入消息队列，否则

直接调用executeStartWithPop()

private void startWithPop(final FragmentManager fragmentManager, final ISupportFragment from, final ISupportFragment to) {
    if (FragmentationHack.isExecutingActions(fragmentManager)) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                executeStartWithPop(fragmentManager, from, to);
            }
        });
        return;
    }

    executeStartWithPop(fragmentManager, from, to);
}

在看下executeStartWithPop()

private void executeStartWithPop(final FragmentManager fragmentManager, final ISupportFragment from, final ISupportFragment to) {
    fragmentManager.executePendingTransactions();
    final ISupportFragment preFragment = getPreFragment((Fragment) from);
    final int fromContainerId = from.getSupportDelegate().mContainerId;

    mockStartWithPopAnim(from, to, from.getSupportDelegate().mAnimHelper.popExitAnim);
    fragmentManager.popBackStackImmediate();
    mHandler.post(new Runnable() {
        @Override
        public void run() {
            FragmentationHack.reorderIndices(fragmentManager);
            if (preFragment != null && preFragment.getSupportDelegate().mContainerId == fromContainerId) {
                preFragment.getSupportDelegate().start(to);
            } else {
                dispatchStartTransaction(fragmentManager, from, to, 0, ISupportFragment.STANDARD, TYPE_ADD);
            }
        }
    });
}

首先获取到fromFragment即当前Fragment的前一个Fragment和容器id，mockStartWithPopAnim()执行fromFragment的退出动画，并立即从栈中移除，接着后面的业务都加入消息队列，先整理下栈的顺序，如果前一个fragment不为null且它的容器id等于当前Fragment的，就开启目标Fragment，否则目标Fragment被作为根Fragment加入栈中，因为当前Fragment被移除栈了，所以如果还有前一个Fragment就相当于是从前一个开始开启目标Fragment。

五、出栈到目标Fragment

/**
 * Pop the last fragment transition from the manager's fragment
 * back stack.
 *
 * 出栈到目标fragment
 *
 * @param targetFragmentClass   目标fragment
 * @param includeTargetFragment 是否包含该fragment
 */
public void popTo(Class<?> targetFragmentClass, boolean includeTargetFragment) {
    mDelegate.popTo(targetFragmentClass, includeTargetFragment);
}

/**
 * Pop the last fragment transition from the manager's fragment back stack.
 *
 * @param targetFragmentTag     Tag
 * @param includeTargetFragment Whether it includes targetFragment
 */
void popTo(final String targetFragmentTag, final boolean includeTargetFragment, final Runnable afterPopTransactionRunnable, FragmentManager fragmentManager, final int popAnim) {
    fragmentManager = checkFragmentManager(fragmentManager, null);
    if (fragmentManager == null) return;

    if (FragmentationHack.isExecutingActions(fragmentManager)) {
        final FragmentManager finalFragmentManager = fragmentManager;
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                executePopTo(targetFragmentTag, includeTargetFragment, afterPopTransactionRunnable, finalFragmentManager, popAnim);
            }
        });
        return;
    }
    executePopTo(targetFragmentTag, includeTargetFragment, afterPopTransactionRunnable, fragmentManager, popAnim);
}

发现其实调用的是executePopTo()

private void executePopTo(final String targetFragmentTag, boolean includeTargetFragment, final Runnable afterPopTransactionRunnable, FragmentManager fragmentManager, int popAnim) {
    fragmentManager.executePendingTransactions();
    Fragment targetFragment = fragmentManager.findFragmentByTag(targetFragmentTag);

    if (targetFragment == null) {
        Log.e(TAG, "Pop failure! Can't find FragmentTag:" + targetFragmentTag + " in the FragmentManager's Stack.");
        return;
    }

    int flag = 0;
    if (includeTargetFragment) {
        flag = FragmentManager.POP_BACK_STACK_INCLUSIVE;
        targetFragment = (Fragment) getPreFragment(targetFragment);
    }

    ISupportFragment fromFragment = getTopFragment(fragmentManager);
    Animation popAnimation;

    if (afterPopTransactionRunnable == null && popAnim == TransactionDelegate.DEFAULT_POPTO_ANIM) {
        popAnimation = fromFragment.getSupportDelegate().mAnimHelper.exitAnim;
    } else {
        if (popAnim == TransactionDelegate.DEFAULT_POPTO_ANIM) {
            popAnimation = new Animation() {
            };
            popAnimation.setDuration(fromFragment.getSupportDelegate().mAnimHelper.exitAnim.getDuration());
        } else if (popAnim == 0) {
            popAnimation = new Animation() {
            };
        } else {
            popAnimation = AnimationUtils.loadAnimation(mActivity, popAnim);
        }
    }

    final int finalFlag = flag;
    final FragmentManager finalFragmentManager = fragmentManager;

    mockPopAnim(fromFragment, (ISupportFragment) targetFragment, popAnimation, afterPopTransactionRunnable != null, new Callback() {
        @Override
        public void call() {
            popToFix(targetFragmentTag, finalFlag, finalFragmentManager);
            if (afterPopTransactionRunnable != null) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        mPopToTempFragmentManager = finalFragmentManager;
                        afterPopTransactionRunnable.run();
                        mPopToTempFragmentManager = null;
                    }
                });
            }
        }
    });
}

这个方法较长，includeTargetFragment是否包含目标fragment，这里的作用是如果包含，到时就把栈内目标fragment及以上的fragment都移除，

如果不包含，就把栈内目标fragment以上的fragment都移除；

当移除栈的事务完成后是否还有业务需要处理，就通过afterPopTransactionRunnable来判断；

最后，mockPopAnim()，用于处理出栈后的相关动画，即先出栈再播放动画，如果还有afterPopTransactionRunnable业务，随便把这个业务处理了再播放动画。

以上应该就是最核心的代码了，这个框架还有一个很重要就是对于转场动画的操作，不自定义动画也不会影响使用，这个下篇再分析吧