Fragment的BackStack管理過程

• 1. Fragment基本用法
  為了管理Activity中的fragments，需要調用Activity中的getFragmentManager()方法。因為FragmentManager的API是在Android 3.0，也即API level 11開始引入的，所以對於之前的版本，需要使用support library v4中的FragmentActivity，並且使用getSupportFragmentManager()方法。
  用FragmentManager可以做的工作有：
  得到Activity中存在的fragment：
  　　使用findFragmentById()或findFragmentByTag()方法。
  　　將fragment彈出back stack：
  popBackStack()：
      將back stack中最后一次的fragment轉換彈出。如果沒有可以出棧的東西，返回false。
  　這個函數是異步的：它將彈出棧的請求加入隊列，但是這個動作直到應用回到事件循環才會執行。
  為back stack加上監聽器：
  　　addOnBackStackChangedListener()
  使用Fragment時，可以執行一些動作，比如增加、移除、替換等。所有這些改變構成一個集合，這個集合被叫做一個transaction。
  可以調用FragmentTransaction中的方法來處理這個transaction.
  以這樣得到FragmentTransaction類的實例：　
  
  [java]  view plain copy

  1. FragmentManager fragmentManager = getFragmentManager();  
  2. FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();  
  
  

  每個transaction是一組同時執行的變化的集合。用add(), remove(), replace()方法，把所有需要的變化加進去，然后調用commit()方法，將這些變化應用。在commit()方法之前，你可以調用addToBackStack()，把這個transaction加入back stack中去，這個back stack是由activity管理的，當用戶按返回鍵時，就會回到上一個fragment的狀態。下面的代碼非常典型，用一個新的fragment取代之前的fragment，並且將之前的狀態存儲在back stack中。

  [java]  view plain copy

  1. // Create new fragment and transaction  
  2. Fragment newFragment = new ExampleFragment();  
  3. FragmentTransaction transaction = getFragmentManager().beginTransaction();  
  4.   
  5. // Replace whatever is in the fragment_container view with this fragment,  
  6. // and add the transaction to the back stack  
  7. transaction.replace(R.id.fragment_container, newFragment);  
  8. transaction.addToBackStack(null);  
  9.   
  10. // Commit the transaction  
  11. transaction.commit();  
  通過調用addToBackStack()，commit()的一系列轉換作為一個transaction被存儲在back stack中，用戶按Back鍵可以返回上一個轉換前的狀態。
  調用commit()方法並不能立即執行transaction中包含的改變動作，commit()方法把transaction加入activity的UI線程隊列中。
  

  下面我們對上述代碼中出現的函數進行分析，以此來逐步學習Fragment的管理機制。

  getSupportFragmentManager()：
  

  [java]  view plain copy

  1. public FragmentManager getSupportFragmentManager() {  
  2.     return mFragments;  
  3. }  
  該函數返回類型是FragmentManager，FragmentManager是一個抽象類，其實現類是FragmentManager.FragmentManagerImpl

  beginTransaction()：
  該函數在FragmentManagerIMpl中的源碼如下：

  [java]  view plain copy

  1. public FragmentTransaction beginTransaction() {  
  2.     return new BackStackRecord(this);  
  3. }  
  返回一個BackStackRecord對象，該對象是FragmentTranscation的一個子類。
  BackStackRecord的聲明如下:
  [java]  view plain copy

  1. final class BackStackRecord extends FragmentTransaction implements  
  2.         FragmentManager.BackStackEntry, Runnable {...}  
  該類實現了一個重要的接口：FragmentManager.BackStackEntry, 該接口代表了fragment back stack的一個入口。可以用FragmentManager.getBackStackEntry()來檢索BackStackEntry。    
  接下來執行transaction.replace(), 查看BackStackRecord，調用過程源碼如下：
  [java]  view plain copy

  1. public FragmentTransaction replace(int containerViewId, Fragment fragment) {  
  2.     return replace(containerViewId, fragment, null);  
  3. }  
  4.   
  5. public FragmentTransaction replace(int containerViewId, Fragment fragment, String tag) {  
  6.     if (containerViewId == 0) {  
  7.         throw new IllegalArgumentException("Must use non-zero containerViewId");  
  8.     }  
  9.   
  10.     doAddOp(containerViewId, fragment, tag, OP_REPLACE);  
  11.     return this;  
  12. }  
  我們發現，replace()最終調用的函數為doAddOp(int containerViewId, Fragment fragment, String tag, int opcmd), 將Fragment和對Fragment所進行的操作放到op鏈表中：
  [java]  view plain copy

  1. private void doAddOp(int containerViewId, Fragment fragment, String tag, int opcmd) {  
  2.     fragment.mFragmentManager = mManager;  
  3.   
  4.     if (tag != null) {  
  5.         if (fragment.mTag != null && !tag.equals(fragment.mTag)) {  
  6.             throw new IllegalStateException("Can't change tag of fragment "  
  7.                     + fragment + ": was " + fragment.mTag  
  8.                     + " now " + tag);  
  9.         }  
  10.         fragment.mTag = tag;  
  11.     }  
  12.   
  13.     if (containerViewId != 0) {  
  14.         if (fragment.mFragmentId != 0 && fragment.mFragmentId != containerViewId) {  
  15.             throw new IllegalStateException("Can't change container ID of fragment "  
  16.                     + fragment + ": was " + fragment.mFragmentId  
  17.                     + " now " + containerViewId);  
  18.         }  
  19.         fragment.mContainerId = fragment.mFragmentId = containerViewId;  
  20.     }  
  21.   
  22.     Op op = new Op();  
  23.     op.cmd = opcmd;  
  24.     op.fragment = fragment;  
  25.     addOp(op);  
  26. }  
  該函數首先設置fragment的mFragmentManager屬性，然后再設置其mContainerId和mFragmentId，最后創建Op對象，然設置相應自段，其中cmd自動用來標識事務的類型，分為如下幾類：
      static final int OP_NULL = 0;
      static final int OP_ADD = 1;
      static final int OP_REPLACE = 2;
      static final int OP_REMOVE = 3;
      static final int OP_HIDE = 4;
      static final int OP_SHOW = 5;
      static final int OP_DETACH = 6;
      static final int OP_ATTACH = 7;
  每個字段的意思可直接通過英文名稱獲知。Op()類是BackStackRecord中聲明的結構體，本質上是一個雙向鏈表的Node。addOp()如下：
  [java]  view plain copy

  1. void addOp(Op op) {  
  2.     if (mHead == null) {  
  3.         mHead = mTail = op;  
  4.     } else {  
  5.         op.prev = mTail;  
  6.         mTail.next = op;  
  7.         mTail = op;  
  8.     }  
  9.     op.enterAnim = mEnterAnim;  
  10.     op.exitAnim = mExitAnim;  
  11.     op.popEnterAnim = mPopEnterAnim;  
  12.     op.popExitAnim = mPopExitAnim;  
  13.     mNumOp++;  
  14. }  
  該函數將Op對象添加到鏈表的末尾，並將mNumOp的值增一。

  transaction.addToBackStack(null)設置了mAddToBackStack為true，源碼如下：

  [java]  view plain copy

  1. public FragmentTransaction addToBackStack(String name) {  
  2.     if (!mAllowAddToBackStack) {  
  3.         throw new IllegalStateException(  
  4.                 "This FragmentTransaction is not allowed to be added to the back stack.");  
  5.     }  
  6.     mAddToBackStack = true;  
  7.     mName = name;  
  8.     return this;  
  9. }  
  此函數將mAddToBackStack自段設置為true,並設置mName字段。
  最后調用transaction.commit()來執行transaction。commit()的調用過程代碼如下：
  [java]  view plain copy

  1. public int commit() {  
  2.     return commitInternal(false);  
  3. }  
  4.   
  5. int commitInternal(boolean allowStateLoss) {  
  6.     if (mCommitted) throw new IllegalStateException("commit already called");  
  7.     if (FragmentManagerImpl.DEBUG) {  
  8.         Log.v(TAG, "Commit: " + this);  
  9.         LogWriter logw = new LogWriter(TAG);  
  10.         PrintWriter pw = new PrintWriter(logw);  
  11.         dump("  ", null, pw, null);  
  12.     }  
  13.     mCommitted = true;  
  14.     if (mAddToBackStack) {  
  15.         mIndex = mManager.allocBackStackIndex(this);  
  16.     } else {  
  17.         mIndex = -1;  
  18.     }  
  19.     mManager.enqueueAction(this, allowStateLoss);  
  20.     return mIndex;  
  21. }  
  由於mAddToBackStack為true，所以會用FragmentManager為BackstackRecorder也即FragmentTransaction分配一個index，分配過程如下：
  [java]  view plain copy

  1. public int allocBackStackIndex(BackStackRecord bse) {  
  2.     synchronized (this) {  
  3.         if (mAvailBackStackIndices == null || mAvailBackStackIndices.size() <= 0) {  
  4.             if (mBackStackIndices == null) {  
  5.                 mBackStackIndices = new ArrayList<BackStackRecord>();  
  6.             }  
  7.             int index = mBackStackIndices.size();  
  8.             if (DEBUG) Log.v(TAG, "Setting back stack index " + index + " to " + bse);  
  9.             mBackStackIndices.add(bse);  
  10.             return index;  
  11.   
  12.         } else {  
  13.             int index = mAvailBackStackIndices.remove(mAvailBackStackIndices.size()-1);  
  14.             if (DEBUG) Log.v(TAG, "Adding back stack index " + index + " with " + bse);  
  15.             mBackStackIndices.set(index, bse);  
  16.             return index;  
  17.         }  
  18.     }  
  19. }  
  FragmentManager用mAvailBackStackIndices和mBackStackIndices兩個數組來為BackStackRecord分配Index。mAvailBackStackIndices用來存儲在mBackStackIndices中能夠分配的Index，mBackStackIndices則用來保存BackStackRecord。這利用兩個數組可以減少對mBackStackIndices的動態分配大小的次數，是一個以空間換時間的策略。上面的代碼首先判斷是否有可用的Index分配給BackStackRecord,若無則直接將BackStackRecord插入到mBackStackIndices；若存在的話則從mAvailBackStackIndices的隊尾取出一個index，然后設置mBackStackIndices中該index下的值。
  
  讓我們回到commit()中，該函數最后執行mManager.enqueAction(),源碼如下：
  [html]  view plain copy

  1. public void enqueueAction(Runnable action, boolean allowStateLoss) {  
  2.     if (!allowStateLoss) {  
  3.         checkStateLoss();  
  4.     }  
  5.     synchronized (this) {  
  6.         if (mDestroyed || mActivity == null) {  
  7.             throw new IllegalStateException("Activity has been destroyed");  
  8.         }  
  9.         if (mPendingActions == null) {  
  10.             mPendingActions = new ArrayList<Runnable>();  
  11.         }  
  12.         mPendingActions.add(action);  
  13.         if (mPendingActions.size() == 1) {  
  14.             mActivity.mHandler.removeCallbacks(mExecCommit);  
  15.             mActivity.mHandler.post(mExecCommit);  
  16.         }  
  17.     }  
  18. }  
  [java]  view plain copy

  1. 該函數首先進行狀態監測，查看該Fagment所在的Activity的生命周期是否處於Saving Activity之前，因為Activity保存狀態往往是由用戶離開那個Activity所造成的，在此之后執行commit會丟失一些狀態信息。針對這種情況，可以使用commitAllowingStateLoss().最后將BackStackRecord加入到執行隊列中。當第一次往執行  
  2. 隊列中添加消息時，首先會從消息隊列中所有callback屬性為mExecCommit的消息刪除，然后重新將mExecCommit添加到消息隊列。mExecCommit的定義如下：  
  [java]  view plain copy

  1. Runnable mExecCommit = new Runnable() {  
  2.     @Override  
  3.     public void run() {  
  4.         execPendingActions();  
  5.     }  
  6. };  
  execPendingActions()只能在主線程內被調用，其內部通過一個循環對mPendingActions中的Actions進行執行。值得注意的是，每執行一次循環，mPendingActions中的所有Action都會被添加到一個臨時數組中，然后這個數組被變量一遍以執行數組中的每個Runnable。同時，每個Runnable直接被調用了run，而不是開個線程執行的。當這個Runnable在執行的時候，mPendingActions數組可能會被添加內容。當某一時刻mPendingActions中的內容為空，則while循環退出。此部分代碼如下：
  [java]  view plain copy

  1. public boolean execPendingActions() {  
  2.     if (mExecutingActions) {  
  3.         throw new IllegalStateException("Recursive entry to executePendingTransactions");  
  4.     }  
  5.       
  6.     if (Looper.myLooper() != mActivity.mHandler.getLooper()) {  
  7.         throw new IllegalStateException("Must be called from main thread of process");  
  8.     }  
  9.   
  10.     boolean didSomething = false;  
  11.   
  12.     while (true) {  
  13.         int numActions;  
  14.           
  15.         synchronized (this) {  
  16.             if (mPendingActions == null || mPendingActions.size() == 0) {  
  17.                 break;  
  18.             }  
  19.               
  20.             numActions = mPendingActions.size();  
  21.             if (mTmpActions == null || mTmpActions.length < numActions) {  
  22.                 mTmpActions = new Runnable[numActions];  
  23.             }  
  24.             mPendingActions.toArray(mTmpActions);  
  25.             mPendingActions.clear();  
  26.             mActivity.mHandler.removeCallbacks(mExecCommit);  
  27.         }  
  28.         //一次性執行完數組中所有的Action  
  29.         mExecutingActions = true;  
  30.         for (int i=0; i<numActions; i++) {  
  31.             mTmpActions[i].run();  
  32.             mTmpActions[i] = null;  
  33.         }  
  34.         mExecutingActions = false;  
  35.         didSomething = true;  
  36.     }  
  37.       
  38.     if (mHavePendingDeferredStart) {  
  39.         boolean loadersRunning = false;  
  40.         for (int i=0; i<mActive.size(); i++) {  
  41.             Fragment f = mActive.get(i);  
  42.             if (f != null && f.mLoaderManager != null) {  
  43.                 loadersRunning |= f.mLoaderManager.hasRunningLoaders();  
  44.             }  
  45.         }  
  46.         if (!loadersRunning) {  
  47.             mHavePendingDeferredStart = false;  
  48.             startPendingDeferredFragments();  
  49.         }  
  50.     }  
  51.     return didSomething;  
  52. }  
  由於BackstackRecorder實現了Runnable,我們來看看BackStackRecorder中的run()，如下所示：
  [java]  view plain copy

  1. public void run() {  
  2.     if (FragmentManagerImpl.DEBUG) Log.v(TAG, "Run: " + this);  
  3.   
  4.     if (mAddToBackStack) {  
  5.         if (mIndex < 0) {  
  6.             throw new IllegalStateException("addToBackStack() called after commit()");  
  7.         }  
  8.     }  
  9.   
  10.     bumpBackStackNesting(1);  
  11.   
  12.     Op op = mHead;  
  13.     //遍歷op,根據cmd的類型對Fragment和FragmentManager進行相應的設置  
  14.     while (op != null) {  
  15.         switch (op.cmd) {  
  16.             case OP_ADD: {  
  17.                 Fragment f = op.fragment;  
  18.                 f.mNextAnim = op.enterAnim;  
  19.                 //將Fragment添加到FragmentManager中，其源碼顯示是將Fragment添加到FragmentManager中的mActive數組中，並將Fragment添加到了數組mAdded中。  
  20.                 mManager.addFragment(f, false);  
  21.             } break;  
  22.             case OP_REPLACE: {  
  23.                 Fragment f = op.fragment;  
  24.                 if (mManager.mAdded != null) {  
  25.                     //遍歷已經添加的Fragment，  
  26.                     for (int i=0; i<mManager.mAdded.size(); i++) {  
  27.                         Fragment old = mManager.mAdded.get(i);  
  28.                         if (FragmentManagerImpl.DEBUG) Log.v(TAG,  
  29.                                 "OP_REPLACE: adding=" + f + " old=" + old);  
  30.                         //如果發現兩個mContainerId一樣，則進行特殊處理  
  31.                         if (f == null || old.mContainerId == f.mContainerId) {  
  32.                             if (old == f) {  
  33.                                 //兩個Fragment一樣，則置空，保留old中的Fragment  
  34.                                 op.fragment = f = null;  
  35.                             } else {  
  36.                                 // 將old fragment加入到 op.removed數組中，保留op中的Fragment  
  37.                                 if (op.removed == null) {  
  38.                                     op.removed = new ArrayList<Fragment>();  
  39.                                 }  
  40.                                 op.removed.add(old);  
  41.                                 old.mNextAnim = op.exitAnim;  
  42.                                 if (mAddToBackStack) {  
  43.                                     //設置old Fragment在BackStack中的Number  
  44.                                     old.mBackStackNesting += 1;  
  45.                                     if (FragmentManagerImpl.DEBUG) Log.v(TAG, "Bump nesting of "  
  46.                                             + old + " to " + old.mBackStackNesting);  
  47.                                 }  
  48.                                 //對old Fragment設置相應的狀態屬性，如mAdded、mRemoving， 從FragmentManager中移除oldFrgment的相關屬性  
  49.                                 mManager.removeFragment(old, mTransition, mTransitionStyle);  
  50.                             }  
  51.                         }  
  52.                     }  
  53.                 }  
  54.                 //將Fragment添加到FragmentManager中  
  55.                 if (f != null) {  
  56.                     f.mNextAnim = op.enterAnim;  
  57.                     mManager.addFragment(f, false);  
  58.                 }  
  59.             } break;  
  60.             case OP_REMOVE:   
  61.             ......  
  62.         }  
  63.   
  64.         op = op.next;  
  65.     }  
  66.     //設置Fragment的當前狀態，然后根據當前狀態來回調Fragment的生命周期中的相關函數。此函數控制了Fragment的生命周期和Fragment的繪制，想要徹底理解Fragment的生命周期的同學可以認真研究此函數。  
  67.     mManager.moveToState(mManager.mCurState, mTransition,  
  68.             mTransitionStyle, true);  
  69.       
  70.     //將BackStackRecord加入到BackStack中，並回調onBackStackChanged  
  71.     if (mAddToBackStack) {  
  72.         mManager.addBackStackState(this);  
  73.     }  
  74. }  
  addBackStackState()的源碼如下：
  [java]  view plain copy

  1. void addBackStackState(BackStackRecord state) {  
  2.     if (mBackStack == null) {  
  3.         mBackStack = new ArrayList<BackStackRecord>();  
  4.     }  
  5.     mBackStack.add(state);  
  6.     //回調onBackStackChanged  
  7.     reportBackStackChanged();  
  8. }  
  可以看到傳說中的BackStack就是在這里被創建的, FragmentManager中的BackStack主要是用來存儲FragmentTransaction的。

  
  

  小結：

  FragmentTransaction中的Op鏈用來保存add、remove、replace等action，在FragmentTransaction的run執行時，Op鏈會被變量以調整每個節點的內容。

  FragmentManager使用一個BackStack來管理FragmentTransaction；使用mAdded數組來添加被add的Fragment，Fragment的創建、顯示等行為都受FragmentManager的控制。
  FragmentManager中的moveToState()是一個非常重要的函數，在FragmentTransaction run的時候被調用。下次我們將深入這個函數。
  
  
  
  
  
  
  
  
  
  
  
  
  
  

來自為知筆記(Wiz)