Android Fragment 和 FragmentManager 的代碼分析

更新時(shí)間：2017年01月19日 10:09:43 作者：Binkery

這篇文章主要介紹了Android Fragment 和 FragmentManager 的代碼分析,非常不錯(cuò)，具有參考借鑒價(jià)值，需要的的朋友參考下吧

這兩天在研究插件化編程，在使用 Fragment 碰到了一些問(wèn)題，于是查看源碼，順便分析了一下 Fragment 和 FragmentManager 以及其他幾個(gè) API 的原代碼，看看他們是怎么工作的。

我們知道 Fragment 有個(gè) onCreateView() 方法，這個(gè)方法在 Fragment 創(chuàng)建 View 的時(shí)候被調(diào)用，并且返回一個(gè) View 對(duì)象。那么 onCreateView 在什么時(shí)候被調(diào)用呢，咱們?cè)?Fragment 這個(gè)類(lèi)里找到了一個(gè)方法，performCreateView() 方法。

Fragment.java
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
  @Nullable Bundle savedInstanceState) {
 return null;
}

performCreateView 這個(gè)方法在什么時(shí)候會(huì)被調(diào)用呢，在 Fragment 里找不到調(diào)用它的代碼。咱們可以猜測(cè)一下，大概會(huì)在 FragmentManager 里。

View performCreateView(LayoutInflater inflater, ViewGroup container,
  Bundle savedInstanceState) {
 if (mChildFragmentManager != null) {
  mChildFragmentManager.noteStateNotSaved();
 }
 return onCreateView(inflater, container, savedInstanceState);
}

在 FragmentManager 里，咱們找到了調(diào)用 Fragment.performCreateView 的代碼，在 moveToState() 方法里，這個(gè)方法有點(diǎn)大，我只粘貼了部分代碼。可以看到，它會(huì)在 Fragment 初始化或者創(chuàng)建的時(shí)候被調(diào)用。并且我們知道，創(chuàng)建的View 被賦值給 Fragment 的 mView 成員變量了。

FragmentManager.java
void moveToState(Fragment f, int newState, int transit, int transitionStyle, boolean keepActive) {
 switch (f.mState) {
 case Fragment.INITIALIZING:
  if (f.mFromLayout) {
   f.mView = f.performCreateView(f.getLayoutInflater(
   f.mSavedFragmentState), null, f.mSavedFragmentState);
 }
 break;
case Fragment.CREATED:
 if (!f.mFromLayout) {
  f.mView = f.performCreateView(f.getLayoutInflater(
   f.mSavedFragmentState), container, f.mSavedFragmentState);
 }
break;
} 
}

接下來(lái)，咱們要看什么時(shí)候會(huì)調(diào)用 moveToState() 這個(gè)方法。找了一下，發(fā)現(xiàn)很 N 多的地方調(diào)用了這個(gè)方法。這樣給咱們逆推找代碼造成了一定的難度。于是咱們換個(gè)思路，正推來(lái)分析。怎么正推了，看咱們?cè)趺词褂?Fragment 和 FragmentManager 來(lái)分析。

一般咱們都是 getFragmentManager() 或者 getSupportFragmentManager() 的方法來(lái)獲取 FragmentManager.以 FragmentActivity 為例，一般情況下，咱們?cè)谶@個(gè)類(lèi)的子類(lèi)里調(diào)用這兩個(gè)方法之一。

咱們?cè)?FragmentActivity 里找到了相應(yīng)的代碼。FragmentManager 是一個(gè)抽象類(lèi)，F(xiàn)ragmentManagerImpl 是 FragmentManager 的子類(lèi)，在 FragmentManager 同一個(gè) java 文件內(nèi)，是一個(gè)內(nèi)部類(lèi)。它是 FragmentManager 的實(shí)現(xiàn)。

FragmentActivity.java
//FragmentManagerImpl is subclass of FragmentManager
final FragmentManagerImpl mFragments = new FragmentManagerImpl();
public FragmentManager getSupportFragmentManager() {
 return mFragments;
}

獲取到 FragmentManager 后，咱們一般就會(huì)調(diào)用 beginTransaction() 方法，返回一個(gè) FragmentTransaction 。咱們看代碼去。

FragmentManager.java
public abstract FragmentTransaction beginTransaction();
FragmentManagerImpl extends FragmentManager
@Override
public FragmentTransaction beginTransaction() {
 return new BackStackRecord(this);
}
/**
* Static library support version of the framework's {@link android.app.FragmentTransaction}.
* Used to write apps that run on platforms prior to Android 3.0. When running
* on Android 3.0 or above, this implementation is still used; it does not try
* to switch to the framework's implementation. See the framework SDK
* documentation for a class overview.
*/
public abstract class FragmentTransaction

我們發(fā)現(xiàn) FragmentManager 是一個(gè)抽象方法，實(shí)現(xiàn)在 FragmentManagerImpl。FragmentManagerImpl.beginTransaction() 返回的是一個(gè)BackStackRecord，而 FragmentTransaction 是一個(gè)抽象類(lèi)。那么 BackStackRecord 是個(gè)什么鬼。

我們找到了 BackStackRecord 這個(gè)類(lèi)。我們注意到，它繼承于 FragmentTransaction，并且實(shí)現(xiàn)了 Runable 接口。它的方法有很多，咱們就分析一個(gè)咱們比較常用的，比如 add() 方法。

BackStackRecord.java
final class BackStackRecord extends FragmentTransaction implements FragmentManager.BackStackEntry, Runnable 
final FragmentManagerImpl mManager;
public BackStackRecord(FragmentManagerImpl manager) {
 mManager = manager;
}

add() 方法其實(shí)沒(méi)干啥，咱們一路追下去看。

public FragmentTransaction add(Fragment fragment, String tag) {
 doAddOp(0, fragment, tag, OP_ADD);
 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);
}
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++;
}

一直追到 addOp() 就斷了，好像啥事也沒(méi)干。不過(guò)它大概是在一個(gè) add 操作添加到一個(gè)鏈表上了。那咱們?cè)趺崔k呢？一般咱們add 完后會(huì) commit 一下，咱們看看 commit 都干了啥。

public int commit() {
 return commitInternal(false);
}
int commitInternal(boolean allowStateLoss) {
 if (mCommitted) throw new IllegalStateException("commit already called");
 mCommitted = true;
 if (mAddToBackStack) {
  mIndex = mManager.allocBackStackIndex(this);
 } else {
  mIndex = -1;
 }
 mManager.enqueueAction(this, allowStateLoss);
 return mIndex;
}

commit 好像也沒(méi)干啥特殊的事情，不過(guò)可以看到這么一行代碼 mManager.enqueueAction(this, allowStateLoss); 看 enqueueAction 這個(gè)方法名，應(yīng)該會(huì)做點(diǎn)事情的。

同樣，咱們?cè)?FragmentManagerImpl 里找到了這個(gè)方法。

public void enqueueAction(Runnable action, boolean allowStateLoss) {
  if (!allowStateLoss) {
    checkStateLoss();
  }
  synchronized (this) {
    if (mDestroyed || mActivity == null) {
      throw new IllegalStateException("Activity has been destroyed");
    }
    if (mPendingActions == null) {
      mPendingActions = new ArrayList<Runnable>();
    }
    mPendingActions.add(action);
    if (mPendingActions.size() == 1) {
      mActivity.mHandler.removeCallbacks(mExecCommit);
      mActivity.mHandler.post(mExecCommit);
    }
  }
}

這個(gè)方法把咱們的 BackStackRecord -- 其實(shí)是 FragmentTransaction，也是 Runnable -- 添加到一個(gè) mPendingActions 的 ArrayList 里了。然后調(diào)用 mActivity.mHandler.post(mExecCommit); mExecCommit 又是什么鬼？

Runnable mExecCommit = new Runnable() {
  @Override
  public void run() {
    execPendingActions();
  }
};
mActivity.mHandler.post(mExecCommit); 說(shuō)明它在主線(xiàn)程里執(zhí)行了 mExecCommit 的 run 方法。別問(wèn)我咋知道的。
execPendingActions() 方法稍微比較大，我把注釋寫(xiě)在代碼里。
public boolean execPendingActions() {
  if (mExecutingActions) {
    throw new IllegalStateException("Recursive entry to executePendingTransactions");
  }
  //如果不是在主線(xiàn)程，拋出一個(gè)異常。
  if (Looper.myLooper() != mActivity.mHandler.getLooper()) {
    throw new IllegalStateException("Must be called from main thread of process");
  }
  boolean didSomething = false;
  // 這里有一個(gè) while true 循環(huán)。
  while (true) {
    int numActions;
    // 這里在一個(gè)同步語(yǔ)句塊里，把上次 mPendingActions 里的元素轉(zhuǎn)移到 mTmpActions 數(shù)組里。并且執(zhí)行 run方法。執(zhí)行誰(shuí)的 run 方法呢？！就是 BackStackRecord ， 也就是 FragmentTransaction 。我在最后面貼了 BackStackRecord 的 run 方法。
    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();
      mActivity.mHandler.removeCallbacks(mExecCommit);
    }
    mExecutingActions = true;
    for (int i=0; i<numActions; i++) {
      mTmpActions[i].run();
      mTmpActions[i] = null;
    }
    mExecutingActions = false;
    didSomething = true;
  }
  // 這里有好幾行代碼，不知道干啥的，反正就是做了一些判斷，最后可能會(huì)調(diào)用 startPendingDeferredFragments() 方法。
  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;
}

startPendingDeferredFragments 方法又是一坨不知道啥意思的代碼。最后可能調(diào)用了 performPendingDeferredStart()

void startPendingDeferredFragments() {
  if (mActive == null) return;
  for (int i=0; i<mActive.size(); i++) {
    Fragment f = mActive.get(i);
    if (f != null) {
      performPendingDeferredStart(f);
    }
  }
}

在這個(gè)方法里，咱們看到了很熟悉的 moveToState() 方法。接著就是上面的分析，F(xiàn)ragment 的 onCreateView 會(huì)被調(diào)用。

public void performPendingDeferredStart(Fragment f) {
  if (f.mDeferStart) {
    if (mExecutingActions) {
      // Wait until we're done executing our pending transactions
      mHavePendingDeferredStart = true;
      return;
    }
    f.mDeferStart = false;
    moveToState(f, mCurState, 0, 0, false);
  }
}

咱們?cè)诨貋?lái)看 BackStackRecord 的 run 方法。這坨代碼有點(diǎn)大，我還是寫(xiě)注釋在代碼里。

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);
  TransitionState state = null;
  SparseArray<Fragment> firstOutFragments = null;
  SparseArray<Fragment> lastInFragments = null;
  if (SUPPORTS_TRANSITIONS) {
    firstOutFragments = new SparseArray<Fragment>();
    lastInFragments = new SparseArray<Fragment>();
    calculateFragments(firstOutFragments, lastInFragments);
    state = beginTransition(firstOutFragments, lastInFragments, false);
  }
  int transitionStyle = state != null ? 0 : mTransitionStyle;
  int transition = state != null ? 0 : mTransition;
  // 注意這里要開(kāi)始 while 循環(huán)了，要遍歷剛才咱們說(shuō)的鏈表了。
  Op op = mHead;
  while (op != null) {
    int enterAnim = state != null ? 0 : op.enterAnim;
    int exitAnim = state != null ? 0 : op.exitAnim;
    switch (op.cmd) {
      // OP_ADD 很簡(jiǎn)單，mManager.addFragment(f, false); 其他的幾個(gè)也類(lèi)似，調(diào)用 mManager 相應(yīng)的方法。
      case OP_ADD: {
        Fragment f = op.fragment;
        f.mNextAnim = enterAnim;
        mManager.addFragment(f, false);
      } break;
      case OP_REPLACE: {
        Fragment f = op.fragment;
        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 (f == null || old.mContainerId == f.mContainerId) {
              if (old == f) {
                op.fragment = f = null;
              } else {
                if (op.removed == null) {
                  op.removed = new ArrayList<Fragment>();
                }
                op.removed.add(old);
                old.mNextAnim = exitAnim;
                if (mAddToBackStack) {
                  old.mBackStackNesting += 1;
                  if (FragmentManagerImpl.DEBUG) Log.v(TAG, "Bump nesting of "
                      + old + " to " + old.mBackStackNesting);
                }
                mManager.removeFragment(old, transition, transitionStyle);
              }
            }
          }
        }
        if (f != null) {
          f.mNextAnim = enterAnim;
          mManager.addFragment(f, false);
        }
      } break;
      case OP_REMOVE: {
        Fragment f = op.fragment;
        f.mNextAnim = exitAnim;
        mManager.removeFragment(f, transition, transitionStyle);
      } break;
      case OP_HIDE: {
        Fragment f = op.fragment;
        f.mNextAnim = exitAnim;
        mManager.hideFragment(f, transition, transitionStyle);
      } break;
      case OP_SHOW: {
        Fragment f = op.fragment;
        f.mNextAnim = enterAnim;
        mManager.showFragment(f, transition, transitionStyle);
      } break;
      case OP_DETACH: {
        Fragment f = op.fragment;
        f.mNextAnim = exitAnim;
        mManager.detachFragment(f, transition, transitionStyle);
      } break;
      case OP_ATTACH: {
        Fragment f = op.fragment;
        f.mNextAnim = enterAnim;
        mManager.attachFragment(f, transition, transitionStyle);
      } break;
      default: {
        throw new IllegalArgumentException("Unknown cmd: " + op.cmd);
      }
    }
    op = op.next;
  }
  // 最后還調(diào)用了moveToState() 這個(gè)方法。跟剛才的區(qū)別，看最后一個(gè)參數(shù)，一個(gè)true，一個(gè)false。
  // 而且注意，這行代碼在 while 循環(huán)之后。
  mManager.moveToState(mManager.mCurState, transition, transitionStyle, true);
  if (mAddToBackStack) {
    mManager.addBackStackState(this);
  }
}

以上所述是小編給大家介紹的Android Fragment 和 FragmentManager 的代碼分析，希望對(duì)大家有所幫助，如果大家有任何疑問(wèn)請(qǐng)給我留言，小編會(huì)及時(shí)回復(fù)大家的。在此也非常感謝大家對(duì)腳本之家網(wǎng)站的支持！

您可能感興趣的文章: