Fragment事務管理源代碼分析

阿新 • • 發佈：2018-01-28

min start 也有 protect transacti ear 想要 asm tee

轉載請標明出處：http://blog.csdn.net/shensky711/article/details/53132952
本文出自: 【HansChen的博客】

概述

在Fragment使用中，有時候須要對Fragment進行add、remove、show、hide、replace等操作來進行Fragment的顯示隱藏等管理。這些管理是通過FragmentTransaction進行事務管理的。事務管理是對於一系列操作進行管理，一個事務包括一個或多個操作命令，是邏輯管理的工作單元。

一個事務開始於第一次運行操作語句，結束於Commit。通俗地將。就是把多個操作緩存起來，等調用commit的時候，統一批處理。以下會對Fragmeng的事務管理做一個代碼分析

分析入口

    /**
     * 顯示Fragment，假設Fragment已加入過，則直接show。否則構造一個Fragment
     *
     * @param containerViewId 容器控件id
     * @param clz             Fragment類
     */
    protected void showFragment(@IdRes int containerViewId, Class 
<? extends Fragment> clz) {
        FragmentManager fm = getFragmentManager();
        FragmentTransaction ft = fm.beginTransaction();//開始事務管理
        Fragment f;
        if ((f = fm.findFragmentByTag(clz.getName())) == null) {
            try {
                f = clz.newInstance();
                ft.add(containerViewId, f, clz.getName());//加入操作 

            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            ft.show(f);//加入操作
        }
        ft.commit();//提交事務
    }

上面是一個簡單的顯示Fragment的栗子，簡單推斷一下Fragment是否已加入過，加入過就直接show，否則構造一個Fragment，最後提交事務。

代碼分析

FragmentManager

技術分享圖片
上圖是獲取FragmentManager的大體過程

要管理Fragment事務。首先是須要拿到FragmentManager。在Activity中能夠通過getFragmentManager()方法獲取(使用兼容包的話。通過FragmentActivity#getSupportFragmentManager())。在這裏我們就不正確兼容包進行分析了

    final FragmentController mFragments = FragmentController.createController(new HostCallbacks());

    /**
     * Return the FragmentManager for interacting with fragments associated
     * with this activity.
     */
    public FragmentManager getFragmentManager() {
        return mFragments.getFragmentManager();
    }

FragmentManager是一個抽象類。它是通過mFragments.getFragmentManager()來獲取的。mFragments是FragmentController對象，它通過FragmentController.createController(new HostCallbacks())生成，這是一個靜態工廠方法：

    public static final FragmentController createController(FragmentHostCallback<?> callbacks) {
        return new FragmentController(callbacks);
    }

在這裏面直接new了一個FragmentController對象，註意FragmentController的構造方法須要傳入一個FragmentHostCallback

FragmentController構造方法

    private final FragmentHostCallback<?> mHost;
    private FragmentController(FragmentHostCallback<?> callbacks) {
        mHost = callbacks;
    }

構造方法非常easy，傳入了一個FragmentHostCallback實例

FragmentController#getFragmentManager

    public FragmentManager getFragmentManager() {
        return mHost.getFragmentManagerImpl();
    }

這裏又調用了mHost的getFragmentManagerImpl方法。希望童鞋們沒有被繞暈，mHost是一個FragmentHostCallback實例。那我們回過頭來看看它傳進來的地方

FragmentHostCallback

這個FragmentHostCallback是一個抽象類，我們能夠看到，在Activity中是傳入了 Activity#HostCallbacks內部類，這個就是FragmentHostCallback的實現類

FragmentHostCallback#getFragmentManagerImpl

    final FragmentManagerImpl mFragmentManager = new FragmentManagerImpl();
    FragmentManagerImpl getFragmentManagerImpl() {
        return mFragmentManager;
    }

最終找到FragmentManager的真身FragmentManagerImpl了

FragmentManagerImpl#beginTransaction

    @Override
    public FragmentTransaction beginTransaction() {
        return new BackStackRecord(this);
    }

能夠看到，所謂的FragmentTransaction事實上就是一個BackStackRecord。到如今。FragmentManager和FragmentTransaction我們都找到了。下圖就是各個類之間的關系：
技術分享圖片

以下開始真正的事務管理分析，我們先選擇一個事務add來進行分析

FragmentTransaction#add

    public FragmentTransaction add(int containerViewId, Fragment fragment, String tag) {
        doAddOp(containerViewId, fragment, tag, OP_ADD);
        return this;
    }

    private void doAddOp(int containerViewId, Fragment fragment, String tag, int opcmd) {

        //設置fragment的FragmentManagerImpl，mManager事實上就是Activity#HostCallbacks中的成員變量
        fragment.mFragmentManager = mManager;

        //設置fragment的tag
        if (tag != null) {
            if (fragment.mTag != null && !tag.equals(fragment.mTag)) {
                throw new IllegalStateException("...");
            }
            fragment.mTag = tag;
        }

        if (containerViewId != 0) {
            if (containerViewId == View.NO_ID) {
                throw new IllegalArgumentException("...");
            }
            if (fragment.mFragmentId != 0 && fragment.mFragmentId != containerViewId) {
                throw new IllegalStateException("");
            }
            //設置fragment的mContainerId以及mFragmentId
            fragment.mContainerId = fragment.mFragmentId = containerViewId;
        }

        //新增一個操作
        Op op = new Op();
        op.cmd = opcmd;
        op.fragment = fragment;
        //加入操作
        addOp(op);
    }

    //插入到鏈表的最後
    void addOp(Op op) {
        if (mHead == null) {
            mHead = mTail = op;
        } else {
            op.prev = mTail;
            mTail.next = op;
            mTail = op;
        }
        op.enterAnim = mEnterAnim;
        op.exitAnim = mExitAnim;
        op.popEnterAnim = mPopEnterAnim;
        op.popExitAnim = mPopExitAnim;
        mNumOp++;
    }

add的操作步驟為：

設置fragment的FragmentManagerImpl
設置fragment的tag
設置fragment的mContainerId以及mFragmentId
插入一個類型為OP_ADD的操作到鏈表最後

這裏用到了一個類：

    static final class Op {
        Op next;//下一操作節點
        Op prev;//上一操作節點
        int cmd;//操作類型，可選有：OP_NULL|OP_ADD|OP_REPLACE|OP_REMOVE|OP_HIDE|OP_SHOW|OP_DETACH|OP_ATTACH
        Fragment fragment;//操作的Fragment對象
        int enterAnim;//入場動畫
        int exitAnim;//出場動畫
        int popEnterAnim;//彈入動畫
        int popExitAnim;//彈出動畫
        ArrayList<Fragment> removed;
    }

這是一個操作鏈表節點。

全部add、remove、hide等事物最終會形成一個操作鏈

FragmentTransaction#commit

等全部操作都插入後，最後我們須要調用FragmentTransaction的commit方法。操作才會真正地運行。

    public int commit() {
        return commitInternal(false);
    }

    int commitInternal(boolean allowStateLoss) {
        //防止反復commit
        if (mCommitted) {
            throw new IllegalStateException("commit already called");
        }

        //DEBUG代碼統統無論
        if (FragmentManagerImpl.DEBUG) {
            Log.v(TAG, "Commit: " + this);
            LogWriter logw = new LogWriter(Log.VERBOSE, TAG);
            PrintWriter pw = new FastPrintWriter(logw, false, 1024);
            dump("  ", null, pw, null);
            pw.flush();
        }

        mCommitted = true;

        //僅僅有調用了addToBackStack方法之後，這個標記才會為true
        if (mAddToBackStack) {
            mIndex = mManager.allocBackStackIndex(this);
        } else {
            mIndex = -1;
        }
        //插入事物隊列
        mManager.enqueueAction(this, allowStateLoss);
        return mIndex;
    }

FragmentManagerImpl#enqueueAction

    /**
     * Adds an action to the queue of pending actions.
     *
     * @param action the action to add
     * @param allowStateLoss whether to allow loss of state information
     * @throws IllegalStateException if the activity has been destroyed
     */
    public void enqueueAction(Runnable action, boolean allowStateLoss) {
        if (!allowStateLoss) {
            checkStateLoss();
        }
        synchronized (this) {
            if (mDestroyed || mHost == null) {
                throw new IllegalStateException("Activity has been destroyed");
            }
            if (mPendingActions == null) {
                mPendingActions = new ArrayList<Runnable>();
            }
            mPendingActions.add(action);
            if (mPendingActions.size() == 1) {
                mHost.getHandler().removeCallbacks(mExecCommit);
                mHost.getHandler().post(mExecCommit);
            }
        }
    }

這裏把操作加入到mPendingActions列表裏去。並通過mHost.getHandler()獲取Handler發送運行請求。從上面的分析知道。mHost就是Activity的HostCallbacks。構造方法中把Activity的mHandler傳進去了，這裏運行的mHost.getHandler()獲取到的也就是Activity中的mHandler，這樣做是由於須要在主線程中運行

final Handler mHandler = new Handler();

再看看mExecCommit中做了什麽操作：

    Runnable mExecCommit = new Runnable() {
        @Override
        public void run() {
            execPendingActions();
        }
    };

    /**
     * Only call from main thread!
     */
    public boolean execPendingActions() {
        if (mExecutingActions) {
            throw new IllegalStateException("Recursive entry to executePendingTransactions");
        }

        //再次檢測是否主線程
        if (Looper.myLooper() != mHost.getHandler().getLooper()) {
            throw new IllegalStateException("Must be called from main thread of process");
        }

        boolean didSomething = false;

        while (true) {
            int numActions;

            synchronized (this) {

                //參數檢測
                if (mPendingActions == null || mPendingActions.size() == 0) {
                    break;
                }

                numActions = mPendingActions.size();
                if (mTmpActions == null || mTmpActions.length < numActions) {
                    mTmpActions = new Runnable[numActions];
                }

                mPendingActions.toArray(mTmpActions);
                mPendingActions.clear();
                mHost.getHandler().removeCallbacks(mExecCommit);
            }

            mExecutingActions = true;
            //遍歷運行待處理的事務操作
            for (int i=0; i<numActions; i++) {
                mTmpActions[i].run();
                mTmpActions[i] = null;
            }
            mExecutingActions = false;
            didSomething = true;
        }

        doPendingDeferredStart();

        return didSomething;
    }

插入了事物之後，就是在主線程中把須要處理的事務統一處理。處理事務是通過運行mTmpActions[i].run()進行的，這個mTmpActions[i]就是前面我們通過enqueueAction方法插入的BackStackRecord，童鞋們可能沒註意到，它但是一個Runnable，我們來看看它的定義

final class BackStackRecord extends FragmentTransaction implements
        FragmentManager.BackStackEntry, Runnable {
    static final String TAG = FragmentManagerImpl.TAG;

    ... ...
}

兜兜轉轉，我們又回到了BackStackRecord

BackStackRecord#run

    public void run() {

        ......

        if (mManager.mCurState >= Fragment.CREATED) {
            SparseArray<Fragment> firstOutFragments = new SparseArray<Fragment>();
            SparseArray<Fragment> lastInFragments = new SparseArray<Fragment>();
            calculateFragments(firstOutFragments, lastInFragments);
            beginTransition(firstOutFragments, lastInFragments, false);
        }
        //遍歷鏈表。依據cmd事務類型依次處理事務
        Op op = mHead;
        while (op != null) {
            switch (op.cmd) {
                case OP_ADD: {
                    Fragment f = op.fragment;
                    f.mNextAnim = op.enterAnim;
                    mManager.addFragment(f, false);
                }
                break;
                case OP_REPLACE: {
                    Fragment f = op.fragment;
                    int containerId = f.mContainerId;
                    if (mManager.mAdded != null) {
                        for (int i = mManager.mAdded.size() - 1; i >= 0; i--) {
                            Fragment old = mManager.mAdded.get(i);
                            if (old.mContainerId == containerId) {
                                if (old == f) {
                                    op.fragment = f = null;
                                } else {
                                    if (op.removed == null) {
                                        op.removed = new ArrayList<Fragment>();
                                    }
                                    op.removed.add(old);
                                    old.mNextAnim = op.exitAnim;
                                    if (mAddToBackStack) {
                                        old.mBackStackNesting += 1;
                                    }
                                    mManager.removeFragment(old, mTransition, mTransitionStyle);
                                }
                            }
                        }
                    }
                    if (f != null) {
                        f.mNextAnim = op.enterAnim;
                        mManager.addFragment(f, false);
                    }
                }
                break;
                case OP_REMOVE: {
                    Fragment f = op.fragment;
                    f.mNextAnim = op.exitAnim;
                    mManager.removeFragment(f, mTransition, mTransitionStyle);
                }
                break;
                case OP_HIDE: {
                    Fragment f = op.fragment;
                    f.mNextAnim = op.exitAnim;
                    mManager.hideFragment(f, mTransition, mTransitionStyle);
                }
                break;
                case OP_SHOW: {
                    Fragment f = op.fragment;
                    f.mNextAnim = op.enterAnim;
                    mManager.showFragment(f, mTransition, mTransitionStyle);
                }
                break;
                case OP_DETACH: {
                    Fragment f = op.fragment;
                    f.mNextAnim = op.exitAnim;
                    mManager.detachFragment(f, mTransition, mTransitionStyle);
                }
                break;
                case OP_ATTACH: {
                    Fragment f = op.fragment;
                    f.mNextAnim = op.enterAnim;
                    mManager.attachFragment(f, mTransition, mTransitionStyle);
                }
                break;
                default: {
                    throw new IllegalArgumentException("Unknown cmd: " + op.cmd);
                }
            }

            op = op.next;
        }

        mManager.moveToState(mManager.mCurState, mTransition,
                mTransitionStyle, true);

        if (mAddToBackStack) {
            mManager.addBackStackState(this);
        }
    }

到這一步，提交的事務就被真正運行了，我們知道。即使commit了事務之後，也不是同步運行的，是通過Handler發送到主線程運行的。

全部事務的處理都是在run方法裏面運行。但是我們留意到，想要搞清楚add、remove等事務背後真正做了什麽。還須要深入了解FragmentManagerImpl。

本文主要解說Fragment事務的流程，FragmentManagerImpl的分析準備放到下一篇分析文章「Fragment源代碼分析」中，相信通過分析之後，就能夠對Fragment的生命周期也有一個非常好的認識了

Fragment事務管理源代碼分析

min start 也有 protect transacti ear 想要 asm tee 轉載請標明出處：http://blog.csdn.net/shens

Fragment事務管理源代碼分析

概述

分析入口

代碼分析

FragmentManager

FragmentController構造方法

FragmentController#getFragmentManager

FragmentHostCallback

FragmentHostCallback#getFragmentManagerImpl

FragmentManagerImpl#beginTransaction

FragmentTransaction#add

FragmentTransaction#commit

FragmentManagerImpl#enqueueAction

BackStackRecord#run

Fragment事務管理源代碼分析

[Android]Fragment源代碼分析(三) 事務

Linux 內核源代碼分析 chap 2 存儲管理（5）

首選項框架PreferenceFragment部分源代碼分析

Spark SQL 源代碼分析之Physical Plan 到 RDD的詳細實現

【Java】【Flume】Flume-NG啟動過程源代碼分析（一）

JAVA隨筆篇一（Timer源代碼分析和scheduleAtFixedRate的使用）

Zepto源代碼分析之二~三個API

gcc 源代碼分析-前端篇3

Storm入門（十一）Twitter Storm源代碼分析之CoordinatedBolt

OpenStack_Swift源代碼分析——ObjectReplicator源代碼分析(1)

HBase源代碼分析之HRegion上MemStore的flsuh流程（二）

【雷電】源代碼分析（二）-- 進入遊戲攻擊

Spring源代碼分析（1）---LocalSessionFactoryBean(工廠的工廠)

Shiro源代碼分析之兩種Session的方式

Raw-OS源代碼分析之消息系統-Queue_Buffer

哇！板球源代碼分析一

Spark源代碼分析之六：Task調度（二）

【雷電】源代碼分析（一）-- 進入遊戲開始界面

Android 消息處理源代碼分析（2）

Fragment事務管理源代碼分析

概述

分析入口

代碼分析

FragmentManager

FragmentController構造方法

FragmentController#getFragmentManager

FragmentHostCallback

FragmentHostCallback#getFragmentManagerImpl

FragmentManagerImpl#beginTransaction

FragmentTransaction#add

FragmentTransaction#commit

FragmentManagerImpl#enqueueAction

BackStackRecord#run

相關推薦