Android fragment原始碼全解析

Fragment 相信基本上每個android developer都用過，但是知曉其原理 用的好的還是不多，今天就從原始碼的角度上來帶著大家分析一下Fragment的原始碼，對fragment有了更深層次的認識以後相信

寫出來的程式碼也會越來越好看。

首先，我們來看第一個流程，fragment是怎麼載入到介面上的，藉著這個流程分析，能讀完絕大多數fragment的原始碼。

一般我們顯示一個fragment的時候 喜歡如下這種做法：

   blankFragment=new BlankFragment();
        fm=getFragmentManager();
        FragmentTransaction ft=fm.beginTransaction();
        ft.replace(R.id.rootView,blankFragment);
        ft.commit();

 

這段程式碼相信大家都很熟悉了，我們就來一步步跟進去看看 ，2-5 執行結束以後 是怎麼把fragment介面顯示到手機螢幕上的。

//下面的程式碼 來自於activity裡面！！！！！！！！！！！！！！！
    public FragmentManager getFragmentManager() {
        //到這裡能發現是mFragments返回給我們的FragmentManager
        return mFragments.getFragmentManager();
    }

//繼續往下跟 就會發現mFragments是由FragmentController的createController函式 構造出來的一個物件，
//並且這個函式 需要傳進去一個HostCallBack的物件
    final FragmentController mFragments = FragmentController.createController(new HostCallbacks());



//下面的程式碼就來自於FragmentController 這個類！！！！！
   private final FragmentHostCallback<?> mHost;

    //從這個函式就能看出來HostCallbacks 這個類肯定是FragmentHostCallback的子類了
    public static final FragmentController createController(FragmentHostCallback<?> callbacks) {
        return new FragmentController(callbacks);
    }

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

   //所以這個getFragmentManager返回的就是FragmentManager這個物件，並且這個物件是mHost的getFragmentManagerImpl函式返回的。
    //這裡結合建構函式一看就明白了，這個mHost就是我們在activity程式碼裡面，第12行那裡傳進去的HostCallbacks這個物件來幫助初始化的
    public FragmentManager getFragmentManager() {
        return mHost.getFragmentManagerImpl();
    }


 //下面的程式碼在activity裡
//這個地方一目瞭然 果然我們這個HostCallbacks 這個類是繼承自FragmentHostCallback的，並且能看出來，我們這裡把activity的引用也傳進去了。
//所以能馬上得出一個結論就是一個activity對應著一個HostCallbacks物件 這個物件持有本身這個activity的引用。傳進去以後就代表FragmentController
//這個類的成員mHost 也持有了activity的引用
 class HostCallbacks extends FragmentHostCallback<Activity> {
        public HostCallbacks() {
            super(Activity.this /*activity*/);
        }

        @Override
        public void onDump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
            Activity.this.dump(prefix, fd, writer, args);
        }
        .................略過餘下程式碼
 }

 //下面的程式碼來源自 FragmentHostCallback<E> 這個抽象類

  public FragmentHostCallback(Context context, Handler handler, int windowAnimations) {
        this(null /*activity*/, context, handler, windowAnimations);
    }

    FragmentHostCallback(Activity activity) {
        this(activity, activity /*context*/, activity.mHandler, 0 /*windowAnimations*/);
    }

    //到這裡就能看到FragmentHostCallback 持有了acitivty的引用 並且連activity的handler都一併持有！
    FragmentHostCallback(Activity activity, Context context, Handler handler,
            int windowAnimations) {
        mActivity = activity;
        mContext = context;
        mHandler = handler;
        mWindowAnimations = windowAnimations;
    }

上面 初步分析了getFragmentManager這個方法的由來。那繼續看這個方法到底是返回的什麼？

//下面的程式碼來源自抽象類FragmentHostCallback
 FragmentManagerImpl getFragmentManagerImpl() {
        return mFragmentManager;
    }
 //所以就能看出來 我們在activity中呼叫的getFragmentManger這個方法最終返回的是FragmentManagerImpl 這個類的物件了
 final FragmentManagerImpl mFragmentManager = new FragmentManagerImpl();

再進去看看 這個物件的begin方法返回的是什麼

 //原始碼來自於抽象類 FragmentManager
    public FragmentTransaction beginTransaction() {
        //可以看出來 返回的是BackStackRecord 這個類的物件
        return new BackStackRecord(this);
    }
//下面的程式碼來自於BackStackState這個類
//可以看到這個類是一個final類 
final class BackStackState implements Parcelable {
}

//注意BackStackRecord這個類 和BackStackState 是在同一個檔案內的 
//可以看一下BackStackRecord 是FragmentTransaction的子類 並且實現了
//BackStackEntry, Runnable這兩個介面
final class BackStackRecord extends FragmentTransaction implements
        FragmentManager.BackStackEntry, Runnable {
    static final String TAG = FragmentManagerImpl.TAG;

    final FragmentManagerImpl mManager;
}

//下面的這個class就是在BackStackRecord這個類的原始碼裡面的，這裡Op
//實際上就是一個雙向連結串列結構
 static final class Op {
        Op next;
        Op prev;
        int cmd;
        Fragment fragment;
        int enterAnim;
        int exitAnim;
        int popEnterAnim;
        int popExitAnim;
        ArrayList<Fragment> removed;
    }
    

你看 所以begintranscation返回的最終就是backstackrecord物件了。

我們繼續看看這個物件的操作

//以下程式碼來源自backstackrecord 原始碼
public FragmentTransaction replace(int containerViewId, Fragment fragment) {
        return replace(containerViewId, fragment, null);
    }

//你看這裡replace操作 你如果沒有傳進去一個有效的id的話 異常就會在這裡出現了
    public FragmentTransaction replace(int containerViewId, Fragment fragment, String tag) {
        if (containerViewId == 0) {
            throw new IllegalArgumentException("Must use non-zero containerViewId");
        }

        //最終都是呼叫的doaAdddop這個方法來完成操作的
        doAddOp(containerViewId, fragment, tag, OP_REPLACE);
        return this;
    }

//這個方法說白了 就是拼裝下這個雙向連結串列
     private void doAddOp(int containerViewId, Fragment fragment, String tag, int opcmd) {
        fragment.mFragmentManager = mManager;

        if (tag != null) {
            if (fragment.mTag != null && !tag.equals(fragment.mTag)) {
                throw new IllegalStateException("Can't change tag of fragment "
                        + fragment + ": was " + fragment.mTag
                        + " now " + tag);
            }
            fragment.mTag = tag;
        }

        if (containerViewId != 0) {
            if (fragment.mFragmentId != 0 && fragment.mFragmentId != containerViewId) {
                throw new IllegalStateException("Can't change container ID of fragment "
                        + fragment + ": was " + fragment.mFragmentId
                        + " now " + containerViewId);
            }
            fragment.mContainerId = fragment.mFragmentId = containerViewId;
        }

        Op op = new Op();
        op.cmd = opcmd;
        op.fragment = fragment;
        addOp(op);
    }

//所以我們看到 replace操作或者是add remove這種操作 就是操作雙向連結串列的 除此之外沒有任何有意義的舉動，最終反應到使用者能感知的層面上全都是要走
 //commit這個函式的
     public int commit() {
        return commitInternal(false);
    }
//建構函式再看一遍

 public BackStackRecord(FragmentManagerImpl manager) {
        mManager = manager;
    }
int commitInternal(boolean allowStateLoss) {
        if (mCommitted) {
            throw new IllegalStateException("commit already called");
        }
        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;
        if (mAddToBackStack) {
            mIndex = mManager.allocBackStackIndex(this);
        } else {
            mIndex = -1;
        } 
        //這個物件就是     final FragmentManagerImpl mManager; 我們在呼叫begin函式的時候傳進去一個this指標 就是用來初始化他的
        mManager.enqueueAction(this, allowStateLoss);
        return mIndex;
    }

 //所以下面就是FragmentManagerImpl 的原始碼了 final class FragmentManagerImpl extends FragmentManager implements LayoutInflater.Factory2

//這個函式就很關鍵了，這個mHost 前文介紹過 持有了activity的引用，所以這裡你看 就是用activity的handler 去執行了mExecCommit 
//注意是在activity的主執行緒去執行的mExecCommit 這個執行緒
  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);
            }
        }
    }
//這個執行緒執行的execPendingActions 就是這個方法 這個方法也是在FragmentManagerImpl 裡的。並不在activity裡。所以commit操作就是最終讓activity的主執行緒去執行了FragmentManagerImpl
//execPendingActions方法
Runnable mExecCommit = new Runnable() {
        @Override
        public void run() {
            execPendingActions();
        }
    };

  /**
     * 所以這個方法是隻能在主執行緒裡面做的
     */
    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++) {
                //你看這裡run方法 回過頭去 我們應該還能想起來backstackrecord這個類是繼承了runnable這個介面的，所以最終我們還是要看看backstackrecord 的run方法裡面都做了什麼
                mTmpActions[i].run();
                mTmpActions[i] = null;
            }
            mExecutingActions = false;
            didSomething = true;
        }

        if (mHavePendingDeferredStart) {
            boolean loadersRunning = false;
            for (int i=0; i<mActive.size(); i++) {
                Fragment f = mActive.get(i);
                if (f != null && f.mLoaderManager != null) {
                    loadersRunning |= f.mLoaderManager.hasRunningLoaders();
                }
            }
            if (!loadersRunning) {
                mHavePendingDeferredStart = false;
                startPendingDeferredFragments();
            }
        }
        return didSomething;
    }

一直到這裡 我們就知道，commit操作 最終執行的實際上是我們backstackrecord 這個類裡的run方法。

//以下程式碼就是backstackrecord裡面的程式碼了
//這個run方法 其實就是取op這個雙向連結串列然後分析op.cmd的值 然後根據
//這些不同的值 去呼叫FragmentManager裡各種轉換fragment
 public void run() {
        if (FragmentManagerImpl.DEBUG) {
            Log.v(TAG, "Run: " + this);
        }

        if (mAddToBackStack) {
            if (mIndex < 0) {
                throw new IllegalStateException("addToBackStack() called after commit()");
            }
        }

        bumpBackStackNesting(1);

        SparseArray<Fragment> firstOutFragments = new SparseArray<Fragment>();
        SparseArray<Fragment> lastInFragments = new SparseArray<Fragment>();
        calculateFragments(firstOutFragments, lastInFragments);
        beginTransition(firstOutFragments, lastInFragments, false);

        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 = 0; i < mManager.mAdded.size(); i++) {
                            Fragment old = mManager.mAdded.get(i);
                            if (FragmentManagerImpl.DEBUG) {
                                Log.v(TAG,
                                        "OP_REPLACE: adding=" + f + " old=" + old);
                            }
                            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;
                                        if (FragmentManagerImpl.DEBUG) {
                                            Log.v(TAG, "Bump nesting of "
                                                    + old + " to " + old.mBackStackNesting);
                                        }
                                    }
                                    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 這個方法
//同時moveToState 也是fragment狀態分發最重要的方法了

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

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

到這裡應該就差不多了，最終的線索就是 只要搞明白moveToState這個函式就可以了。

//下面的程式碼來自於fragmentmanager
//我們首先來看一下movetostate這個函式總共有一個
void moveToState(Fragment f)
void moveToState(int newState, boolean always)
void moveToState(int newState, int transit, int transitStyle, boolean always)
void moveToState(Fragment f, int newState, int transit, int transitionStyle,
            boolean keepActive)

//可以看到movetoState總共4種。
//在詳細介紹movetostate函式之前，我們先去看看這個函式的引數之一new state是什麼

//下面程式碼來自於fragment
//其實new state 就是代表新的狀態，總共他的值有7種 就全在這裡了 預先都是定義好的
    static final int INVALID_STATE = -1;   // Invalid state used as a null value.
    static final int INITIALIZING = 0;     // Not yet created.
    static final int CREATED = 1;          // Created.
    static final int ACTIVITY_CREATED = 2; // The activity has finished its creation. 這個狀態其實很好理解，
    //就是fragement在oncreate函式結束的時候會呼叫dispatchActivityCreated 就是通知fragment 跟你繫結的宿主activity已經走完onCreate了
    static final int STOPPED = 3;          // Fully created, not started.
    static final int STARTED = 4;          // Created and started, not resumed.
    static final int RESUMED = 5;          // Created started and resumed.


//下面我們可以模擬一個流程 幫助大家理解這個狀態到底是幹嘛的 有什麼用。
//比如 我們先看看 fragmentactivity的原始碼，
//首先我們假設 我們想看看activity 發生onResumne事件的時候 對fragment有什麼影響
protected void onResume() {
        super.onResume();
        mHandler.sendEmptyMessage(MSG_RESUME_PENDING);
        mResumed = true;
        mFragments.execPendingActions();
    }
//繼續追蹤程式碼 發現最後是呼叫的onResumeFragments 這個方法
  final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_REALLY_STOPPED:
                    if (mStopped) {
                        doReallyStop(false);
                    }
                    break;
                case MSG_RESUME_PENDING:
                    onResumeFragments();
                    mFragments.execPendingActions();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }

    };
//原來當activity走onresume流程的時候 最終都是走到這裡

protected void onResumeFragments() {
        mFragments.dispatchResume();
    }
//前面已經分析過mFragements就是FragmentController的物件
//所以下面的程式碼 來自於FragmentController
 public void dispatchResume() {
     //前面的原始碼也分析過了mHost.mFragmentManager 就是 final FragmentManagerImpl mFragmentManager = new FragmentManagerImpl();
        mHost.mFragmentManager.dispatchResume();
    }

//下面的程式碼來自fragmentmanager
//一直追蹤到這裡就能明白 activity的宣告週期 與fragment宣告週期關聯的時候 就是通過moveToState 這個函式來完成的
public void dispatchResume() {
        mStateSaved = false;
        moveToState(Fragment.RESUMED, false);
    }

//movetostate這個函式前面已經說過總共有4種 不一樣的宣告 但是最終起效果的只有這一個
//這個函式非常的長 我就簡單挑幾個注意的點進行註釋  程式碼我就不全部複製貼上進來了。太長了
//有興趣的同學可以自己跟進去看看 其實邏輯挺簡單的
void moveToState(Fragment f, int newState, int transit, int transitionStyle,
            boolean keepActive) {
      ......
        if (f.mState < newState) {
            // For fragments that are created from a layout, when restoring from
            // state we don't want to allow them to be created until they are
            // being reloaded from the layout.
            if (f.mFromLayout && !f.mInLayout) {
                return;
            }  
            if (f.mAnimatingAway != null) {
                // The fragment is currently being animated...  but!  Now we
                // want to move our state back up.  Give up on waiting for the
                // animation, move to whatever the final state should be once
                // the animation is done, and then we can proceed from there.
                f.mAnimatingAway = null;
                moveToState(f, f.mStateAfterAnimating, 0, 0, true);
            }
            switch (f.mState) {
                case Fragment.INITIALIZING:
                 .........................................
                        }
                    }
                    f.mHost = mHost;
                    f.mParentFragment = mParent;
                    f.mFragmentManager = mParent != null
                            ? mParent.mChildFragmentManager : mHost.getFragmentManagerImpl();
                    f.mCalled = false;
                    //這個地方相信很多人一看就明白了，這行程式碼就說明了在onAttach的時候 就能使用和fragment關聯的activity了，這也是為什麼
                    //fragment與activity通訊時，我們喜歡定義介面來完成，並且在onAttach的時候繫結介面 的原因
                    f.onAttach(mHost.getContext());
                    if (!f.mCalled) {
                        throw new SuperNotCalledException("Fragment " + f
                                + " did not call through to super.onAttach()");
                    }
                    if (f.mParentFragment == null) {
                        mHost.onAttachFragment(f);
                    }

                    if (!f.mRetaining) {
                        f.performCreate(f.mSavedFragmentState);
                    }
                    f.mRetaining = false;
                    if (f.mFromLayout) {
                        // For fragments that are part of the content view
                        // layout, we need to instantiate the view immediately
                        // and the inflater will take care of adding it.
                        f.mView = f.performCreateView(f.getLayoutInflater(
                                f.mSavedFragmentState), null, f.mSavedFragmentState);
                        if (f.mView != null) {
                            f.mInnerView = f.mView;
                            if (Build.VERSION.SDK_INT >= 11) {
                                ViewCompat.setSaveFromParentEnabled(f.mView, false);
                            } else {
                                f.mView = NoSaveStateFrameLayout.wrap(f.mView);
                            }
                            if (f.mHidden) f.mView.setVisibility(View.GONE);
                            f.onViewCreated(f.mView, f.mSavedFragmentState);
                        } else {
                            f.mInnerView = null;
                        }
                    }
                case Fragment.CREATED:
                ......................
    }

一直分析到這裡，相信大家就對fragment的原始碼基礎知識有一個不錯的理解了，在這裡 就簡單總結一下 上面的分析：

1.FragmentActivity 是具有支援fragment功能的最底層的activity。其他什麼AppCompatActivity都是他的子類！

2.FragmentActivity主要負責就是生命週期的轉發，比如onCreate onResume onDestroy等等，這就是為什麼activity和fragment狀態能統一的原因了！

當然了，分發的原因就是因為fragmentactivity原始碼裡面持有一個fragmentController的例項！

3.其實將白了，fragmentController就是因為他自己有一個fragmenthostcallback，然後這個hostback還持有了fragmentmanger 所以這個controller 能分發activity的事件！

4.fragementhostcallback持有了activity的很多資源，context handler 是最主要的2個。fragmentmanger就是因為拿到了activty的這2個資源，所以才能和activty互相通訊的！

5.fragmentmangerimple就是fragmentmanger的具體實現類。movetostate方法就是在這個裡面實現的 

6.FragmentTransition 也是個抽象類，他主要就是提供對外的介面函式的 add replace move 這種。BackStackRecord 就是它的具體實現類。還額外實現了runnable介面。

所以BackStackRecord 裡面會有個run方法 這個run方法就是根據不同的操作(所謂操作就是OP.CMD的那個值) 來分發不同的事件，從而呼叫fragmentmanger的各種轉換fragment生命週期的方法！

 

最後在說一下 fragment的 快取和恢復機制吧。

//儲存fragment狀態的 主要是靠FragmentState 這個類來完成的
final class FragmentState implements Parcelable 
//可以看一下這個類的建構函式
 public FragmentState(Fragment frag) {
        mClassName = frag.getClass().getName();
        mIndex = frag.mIndex;
        mFromLayout = frag.mFromLayout;
        mFragmentId = frag.mFragmentId;
        mContainerId = frag.mContainerId;
        mTag = frag.mTag;
        mRetainInstance = frag.mRetainInstance;
        mDetached = frag.mDetached;
        mArguments = frag.mArguments;
    }

//再看一下這個類： 這裡儲存了3個陣列 並且這3個陣列元素都實現了Parcelable 介面
//這意味著他們都可以被序列化
final class FragmentManagerState implements Parcelable {
    FragmentState[] mActive;
    int[] mAdded;
    BackStackState[] mBackStack;
    
    public FragmentManagerState() {
    }
    
    public FragmentManagerState(Parcel in) {
        mActive = in.createTypedArray(FragmentState.CREATOR);
        mAdded = in.createIntArray();
        mBackStack = in.createTypedArray(BackStackState.CREATOR);
    }
    
    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel dest, int flags) {
        dest.writeTypedArray(mActive, flags);
        dest.writeIntArray(mAdded);
        dest.writeTypedArray(mBackStack, flags);
    }
    
    public static final Parcelable.Creator<FragmentManagerState> CREATOR
            = new Parcelable.Creator<FragmentManagerState>() {
        public FragmentManagerState createFromParcel(Parcel in) {
            return new FragmentManagerState(in);
        }
        
        public FragmentManagerState[] newArray(int size) {
            return new FragmentManagerState[size];
        }
    };
}

//上面那個類的3個屬性 實際上對應儲存著是fragemntmanager裡的 三個成員
ArrayList<Fragment> mActive;//他還儲存了mBackStack所有相關的fragment 所以mAdder是mActive的子集
ArrayList<Fragment> mAdded;
ArrayList<BackStackRecord> mBackStack;//這個就是儲存呼叫了addToBackStack方法的FragementTransaction，你看就是這個東西記錄了
//你commit的操作 所以當你呼叫了addToBackStack 以後再按返回鍵 就可以回到上一個fragment了

然後我們看一下 當我們的activity onstop以後 會給fragment帶來什麼？

 //下面程式碼來自於fragmentactivity
 @Override
    protected void onStop() {
        super.onStop();

        mStopped = true;
        mHandler.sendEmptyMessage(MSG_REALLY_STOPPED);

        mFragments.dispatchStop();
    }

//來自於fragmentcontroller
 public void dispatchStop() {
        mHost.mFragmentManager.dispatchStop();
    }

//來自於fragemntmanager
 public void dispatchStop() {
        // See saveAllState() for the explanation of this.  We do this for
        // all platform versions, to keep our behavior more consistent between
        // them.
        mStateSaved = true;
        //你看這裡就是轉換了一下狀態
        moveToState(Fragment.STOPPED, false);
    }

//所以對應的你也能猜到了 當activity onresume的時候 這裡也無非就是把fragement的狀態 從stopped 變成resumed了。 fragement是例項並沒有銷燬 還在
 public void dispatchResume() {
        mStateSaved = false;
        moveToState(Fragment.RESUMED, false);
    }

我們再考慮一下另外一個場景：

比如說 我們旋轉了螢幕。並且

setRetainInstance 為true的時候

看看fragment是怎麼處理的（為false的情況 就是fragment和activity一樣了 activity怎麼做fragment就怎麼做 沒什麼好講的必要。。）

 

 //下面程式碼來自於fragmentmanager
//如果Fragment設定了fragment.setRetainInstance(true) 最終ams 會一步步呼叫到這個函式的
//所以你看 這裡就是返回了mActive 陣列的拷貝呀！
 ArrayList<Fragment> retainNonConfig() {
        ArrayList<Fragment> fragments = null;
        if (mActive != null) {
            for (int i=0; i<mActive.size(); i++) {
                Fragment f = mActive.get(i);
                if (f != null && f.mRetainInstance) {
                    if (fragments == null) {
                        fragments = new ArrayList<Fragment>();
                    }
                    fragments.add(f);
                    f.mRetaining = true;
                    f.mTargetIndex = f.mTarget != null ? f.mTarget.mIndex : -1;
                    if (DEBUG) Log.v(TAG, "retainNonConfig: keeping retained " + f);
                }
            }
        }
        return fragments;
    }

//上面說了儲存fragment例項 下面肯定要說如何儲存fragemnt的例項的
//下面程式碼來自於activity

    NonConfigurationInstances retainNonConfigurationInstances() {
        Object activity = onRetainNonConfigurationInstance();
        HashMap<String, Object> children = onRetainNonConfigurationChildInstances();
        List<Fragment> fragments = mFragments.retainNonConfig();
        ArrayMap<String, LoaderManager> loaders = mFragments.retainLoaderNonConfig();
        if (activity == null && children == null && fragments == null && loaders == null
                && mVoiceInteractor == null) {
            return null;
        }
        //這裡nci你看就知道了 看下類的原始碼你看他儲存的東西 並沒有做什麼序列化反序列化的操作，
        //所以他可以儲存任何東西！當然了，這個nci 是最終儲存在activitythread物件裡的，
        //activitytheread物件裡有個鍵值對叫mActivies。他有個資料結構叫activityclientrecord
        //有興趣的人可以去看下activitytheread的原始碼 這裡不深入展開了。
        NonConfigurationInstances nci = new NonConfigurationInstances();
        //注意 nci.activity這個地方 可不是activity，他是activity原始碼中onRetainNonConfigurationInstance方法返回的物件咯，看63行就知道了
        nci.activity = activity;
        nci.children = children;
        nci.fragments = fragments;
        nci.loaders = loaders;
        if (mVoiceInteractor != null) {
            mVoiceInteractor.retainInstance();
            nci.voiceInteractor = mVoiceInteractor;
        }
        return nci;
    }.

//所以看到這裡就應該明白，如果你的setRetainInstance設定了true的話，當activity重新recreate的時候，雖然activity生成了一個全新的，fragmentmanger也是一個全新的，
 //但是你的fragment實際上還是舊的，生命週期會有一些不同的，不會有oncreate和ondestroy了。他會走85行那裡的restoreAllState方法了
     static final class NonConfigurationInstances {
        Object activity;
        HashMap<String, Object> children;
        List<Fragment> fragments;
        ArrayMap<String, LoaderManager> loaders;
        VoiceInteractor voiceInteractor;
    }


//下面這個方法在fragemntactitivy原始碼裡
     public final Object onRetainNonConfigurationInstance() {
        if (mStopped) {
            doReallyStop(true);
        }

        Object custom = onRetainCustomNonConfigurationInstance();

        List<Fragment> fragments = mFragments.retainNonConfig();
        SimpleArrayMap<String, LoaderManager> loaders = mFragments.retainLoaderNonConfig();

        if (fragments == null && loaders == null && custom == null) {
            return null;
        }

        NonConfigurationInstances nci = new NonConfigurationInstances();
        nci.custom = custom;
        nci.fragments = fragments;
        nci.loaders = loaders;
        return nci;
    }

 //以下程式碼來自於fragmentmanger restoreAllState這個方法就是恢復儲存的fragment例項的
     void restoreAllState(Parcelable state, List<Fragment> nonConfig) {
        // If there is no saved state at all, then there can not be
        // any nonConfig fragments either, so that is that.
        if (state == null) return;
        FragmentManagerState fms = (FragmentManagerState)state;
        if (fms.mActive == null) return;
        
        // First re-attach any non-config instances we are retaining back
        // to their saved state, so we don't try to instantiate them again.
        if (nonConfig != null) {
            for (int i=0; i<nonConfig.size(); i++) {
                Fragment f = nonConfig.get(i);
                if (DEBUG) Log.v(TAG, "restoreAllState: re-attaching retained " + f);
                FragmentState fs = fms.mActive[f.mIndex];
                fs.mInstance = f;
                f.mSavedViewState = null;
                f.mBackStackNesting = 0;
                f.mInLayout = false;
                f.mAdded = false;
                f.mTarget = null;
                if (fs.mSavedFragmentState != null) {
                    fs.mSavedFragmentState.setClassLoader(mHost.getContext().getClassLoader());
                    f.mSavedViewState = fs.mSavedFragmentState.getSparseParcelableArray(
                            FragmentManagerImpl.VIEW_STATE_TAG);
                    f.mSavedFragmentState = fs.mSavedFragmentState;
                }
            }
        }
        
     .................................
    }

最後再考慮一種場景，假設我們的宿主activity 在後臺掛起的時候，因為記憶體不足 被系統殺掉了。fragment會發生什麼？

其實也很簡單啊，原始碼就不貼了，大家自己看，我說下簡單的流程：

1.首先要明確 activity的onSaveInstanceState的方法，是在onPause以後 onStop以前呼叫的。

2.activty放到後臺的時候會呼叫onstop方法，但是onSaveInstanceState是在這之前被呼叫的

3.所以實際上FragmentManager儲存的那3個陣列mActive、mAdded、mBackStack都被提前儲存到FragmentManagerState裡面了

4.等到activity重新回到前臺 走oncreate的時候，會獲得savedInstanceState這個例項，通過他去建立新的FragmentManager例項和新的fragment物件。

5.此時不管fragment是否setRetainInstance(true)，Fragment例項都會重新被建立，原因如下：

retainNonConfig是在Activity在onDestroy被儲存的，有人會說，你上面被系統回收了不是也要最終走ondestroy嗎，但是要注意的是：

只有被relaunch的activity在destroy時才會在ActivityThread程式碼中被呼叫retainNonConfig去通知Activity返回需要儲存例項，其他的destroy不會。

所謂relaunch是指 比如我們手動呼叫了activity的recreate方法，或者更改了系統語言 螢幕方向等造成的activity重新建立。而系統資源不足回收造成的activity重新建立

是不屬於relaunch這一行為的