前言
不知道你們都沒有自己特別的學習的方法，我是有吧所有的整理成筆記的習慣
比如今天講解的關於Fragment的我會做成筆記
由於文章有些地方代碼過於太長了繁瑣，所以部分省略掉了，敲了一下午眼睛和手脖子都酸了，至於省略的部分，對這些筆記，面試內容感興趣的可以看筆記研究，歡迎留言
把最近的知識也整理彙總了一份，打算和之前的知識做個彙總的PDF，有興趣的可以借鑑學習一下
知識彙總的PDF相關內容後續GitHub更新,想衝擊金三銀四的小夥伴可以找找看看，歡迎star
（順手留下GitHub鏈接，需要獲取相關面試等內容的可以自己去找）
https://github.com/xiangjiana/Android-MS
更多完整項目下載。未完待續。源碼。圖文知識後續上傳github。
可以點擊關於我聯繫我獲取
一丶Fragment 的使用
實現很簡單，創建一個的佈局，然後在 Activity 裏點擊時替換 Fragment
mFragmentManager = getSupportFragmentManager();
mFragmentManager.beginTransaction()
.replace(R.id.fl_content, fragment)
.commitAllowingStateLoss();
代碼很簡單，核心就三步：
- 創建
Fragment- 獲取
FragmentManager- 調用事務，添加、替換
我們一步步來了解這背後的故事。
Fragment 大家應該比較熟悉，放到最後。
先來看看 FragmentManager 。
####二丶 FragmentManager
public abstract class FragmentManager {...}
FragmentManager 是一個抽象類，定義了一些和 Fragment 相關的操作和內部類/接口。
2.1.定義的操作
FragmentManager 中定義的方法如下：
//開啓一系列對 Fragments 的操作
public abstract FragmentTransaction beginTransaction();
//FragmentTransaction.commit() 是異步執行的，如果你想立即執行，可以調用這個方法
public abstract boolean executePendingTransactions();
//根據 ID 找到從 XML 解析出來的或者事務中添加的 Fragment
//首先會找添加到 FragmentManager 中的，找不到就去回退棧裏找
public abstract Fragment findFragmentById(@IdRes int id);
//跟上面的類似，不同的是使用 tag 進行查找
public abstract Fragment findFragmentByTag(String tag);
//彈出回退棧中棧頂的 Fragment，異步執行的
public abstract void popBackStack();
//立即彈出回退棧中棧頂的，直接執行哦
public abstract boolean popBackStackImmediate();
......
可以看到，定義的方法有很多是異步執行的，後面看看它究竟是如何實現的異步。
2.2.內部類/接口：
BackStackEntry：Fragment後退棧中的一個元素onBackStackChangedListener：後退棧變動監聽器FragmentLifecycleCallbacks:FragmentManager中的Fragment生命週期監聽
//後退棧中的一個元素
public interface BackStackEntry {
//棧中該元素的唯一標識
public int getId(); //獲取 FragmentTransaction#addToBackStack(String) 設置的名稱 public String getName();
@StringRes
public int getBreadCrumbTitleRes();
@StringRes
public int getBreadCrumbShortTitleRes();
public CharSequence getBreadCrumbTitle();
public CharSequence getBreadCrumbShortTitle();
}
可以看到 BackStackEntry 的接口比較簡單，關鍵信息就是 ID 和 Name。
//在 Fragment 回退棧中有變化時回調
public interface OnBackStackChangedListener {
public void onBackStackChanged();
}
//FragmentManager 中的 Fragment 生命週期監聽
public abstract static class FragmentLifecycleCallbacks {
public void onFragmentPreAttached(FragmentManager fm, Fragment f, Context context) {}
public void onFragmentAttached(FragmentManager fm, Fragment f, Context context) {}
public void onFragmentCreated(FragmentManager fm, Fragment f, Bundle savedInstanceState) {}
public void onFragmentActivityCreated(FragmentManager fm, Fragment f, Bundle savedInstanceState) {}
public void onFragmentViewCreated(FragmentManager fm, Fragment f, View v, Bundle savedInstanceState) {}
public void onFragmentStarted(FragmentManager fm, Fragment f) {}
public void onFragmentResumed(FragmentManager fm, Fragment f) {}
public void onFragmentPaused(FragmentManager fm, Fragment f) {}
public void onFragmentStopped(FragmentManager fm, Fragment f) {}
public void onFragmentSaveInstanceState(FragmentManager fm, Fragment f, Bundle outState) {}
public void onFragmentViewDestroyed(FragmentManager fm, Fragment f) {}
public void onFragmentDestroyed(FragmentManager fm, Fragment f) {}
public void onFragmentDetached(FragmentManager fm, Fragment f) {}
}
}
熟悉 Fragment 生命週期的同學一定覺得很面熟，這個接口就是爲我們提供一個 FragmentManager 所 有 Fragment 生命週期變化的回調。
小結：
可以看到， FragmentManager 是一個抽象類，它定義了對一個 Activity/Fragment 中 添加進來的Fragment 列表、Fragment 回退棧的操作、管理。
2.3.實現類 FragmentManagerImpl
FragmentManager 定義的任務是由 FragmentManagerImpl 實現的。
主要成員：
final class FragmentManagerImpl extends FragmentManager implements
LayoutInflaterFactory {
ArrayList<OpGenerator> mPendingActions;
Runnable[] mTmpActions;
boolean mExecutingActions;
ArrayList<Fragment> mActive;
ArrayList<Fragment> mAdded;
ArrayList<Integer> mAvailIndices;
ArrayList<BackStackRecord> mBackStack;
ArrayList<Fragment> mCreatedMenus;
// Must be accessed while locked.
ArrayList<BackStackRecord> mBackStackIndices;
ArrayList<Integer> mAvailBackStackIndices;
ArrayList<OnBackStackChangedListener> mBackStackChangeListeners;
private CopyOnWriteArrayList<Pair<FragmentLifecycleCallbacks, Boolean>> mLifecycleCallbacks;
//...
}
可以看到， FragmentManagerImpl 中定義了 添加的、活躍的。以及回退棧的列表，這和FragmentManager 的要求一致
接着還有當前的狀態，當前 Fragment 的起始 mParent，以及 FragmentManager 的 mHost 和mContainer。
FragmentContainer 就是一個接口，定義了關於佈局的兩個方法：
public abstract class FragmentContainer {
@Nullable
public abstract View onFindViewById(@IdRes int id);
public abstract boolean onHasView();
}
而 FragmentHostCallback 就複雜一點了，它提供了 Fragment 需要的信息，也定義了 Fragment 宿主應該做的操作：
public abstract class FragmentHostCallback<E> extends FragmentContainer {
private final Activity mActivity;
final Context mContext;
private final Handler mHandler;
final int mWindowAnimations;
final FragmentManagerImpl mFragmentManager = new FragmentManagerImpl();
//...
}
我們知道，一般來說 Fragment 的宿主就兩種：
ActivityFragment
比如 FragmentActivity 的內部類 HostCallbacks 就實現了這個抽象類：
class HostCallbacks extends FragmentHostCallback<FragmentActivity> {
public HostCallbacks() {
super(FragmentActivity.this /*fragmentActivity*/);
}
//...
@Override
public LayoutInflater onGetLayoutInflater() {
return
FragmentActivity.this.getLayoutInflater().cloneInContext(FragmentActivity.t his);
}
@Override
public FragmentActivity onGetHost() {
return FragmentActivity.this;
}
......
}
我們再看看他對 FragmentManager 定義的關鍵方法是如何實現的。
@Override
public FragmentTransaction beginTransaction() {
return new BackStackRecord(this);
}
beginTransaction() 返回一個新的 BackStackRecord ，我們後面介紹。前面提到了， popBackStack() 是一個異步操作，它是如何實現異步的呢？
@Override
public void popBackStack() {
enqueueAction(new PopBackStackState(null, -1, 0), false);
}
public void enqueueAction(OpGenerator 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<>();
}
mPendingActions.add(action);
scheduleCommit();
}
}
private void scheduleCommit() {
synchronized (this) {
boolean postponeReady = mPostponedTransactions != null && !mPostponedTransactions.isEmpty();
boolean pendingReady = mPendingActions != null && mPendingActions.size() == 1;
if (postponeReady || pendingReady) {
mHost.getHandler().removeCallbacks(mExecCommit);
mHost.getHandler().post(mExecCommit);
}
}
}
可以看到，調用到最後，是調用宿主中的 Handler來發送任務的，so easy 嘛。其他的異步執行也是類似，就不贅述了。
後退棧相關方法：
ArrayList<BackStackRecord> mBackStack;
@Override
public int getBackStackEntryCount() {
return mBackStack != null ? mBackStack.size() : 0;
}
@Override
public BackStackEntry getBackStackEntryAt(int index) {
return mBackStack.get(index);
}
可以看到，開始事務和後退棧，返回/操作的都是 BackStackRecord ，我們來了解了解它是何方神聖。
三丶事務
BackStackRecord 繼承了 FragmentTransaction ：
final class BackStackRecord extends FragmentTransaction implements
FragmentManager.BackStackEntry, FragmentManagerImpl.OpGenerator {...}
先來看看 FragmentTransaction 。
3.1.FragmentTransaction
FragmentTransaction 定義了一系列對 Fragment 的操作方法：
//它會調用 add(int, Fragment, String)，其中第一個參數傳的是 0
public abstract FragmentTransaction add(Fragment fragment, String tag);
//它會調用 add(int, Fragment, String)，其中第三個參數是 null
public abstract FragmentTransaction add(@IdRes int containerViewId, Fragment fragment);
//添加一個 Fragment 給 Activity 的最終實現
//第一個參數表示 Fragment 要放置的佈局 id
//第二個參數表示要添加的 Fragment，【注意】一個 Fragment 只能添加一次
//第三個參數選填，可以給 Fragment 設置一個 tag，後續可以使用這個 tag 查詢它
public abstract FragmentTransaction add(@IdRes int containerViewId, Fragment fragment, @Nullable String tag);
//調用 replace(int, Fragment, String)，第三個參數傳的是 null
public abstract FragmentTransaction replace(@IdRes int containerViewId, Fragment fragment);
//替換宿主中一個已經存在的 fragment
//這一個方法等價於先調用 remove(), 再調用 add() public abstract FragmentTransaction replace(@IdRes int containerViewId, Fragment fragment, @Nullable String tag);
//移除一個已經存在的 fragment
//如果之前添加到宿主上，那它的佈局也會被移除
public abstract FragmentTransaction remove(Fragment fragment);
//隱藏一個已存的 fragment
//其實就是將添加到宿主上的佈局隱藏
public abstract FragmentTransaction hide(Fragment fragment);
//顯示前面隱藏的 fragment，這隻適用於之前添加到宿主上的 fragment
public abstract FragmentTransaction show(Fragment fragment);
//將指定的 fragment 將佈局上解除
//當調用這個方法時，fragment 的佈局已經銷燬了
public abstract FragmentTransaction detach(Fragment fragment);
//當前面解除一個 fragment 的佈局綁定後，調用這個方法可以重新綁定
//這將導致該 fragment 的佈局重建，然後添加、展示到界面上
public abstract FragmentTransaction attach(Fragment fragment);
對 fragment 的操作基本就這幾步，我們知道，要完成對 fragment 的操作，最後還需要提交一下：
mFragmentManager.beginTransaction()
.replace(R.id.fl_child, getChildFragment())
// .commit()
.commitAllowingStateLoss();
2.2.事務的四種提交方式
事務最終的提交方法有四種：
commit()commitAllowingStateLoss()commitNow()commitNowAllowingStateLoss()
它們之間的特點及區別如下：
public abstract int commit();
commit() 在主線程中異步執行，其實也是 Handler 拋出任務，等待主線程調度執行。
注意：
commit() 需要在宿主 Activity 保存狀態之前調用，否則會報錯。
這是因爲如果 Activity 出現異常需要恢復狀態，在保存狀態之後的 commit() 將會丟失，這和調用的初衷不符，所以會報錯。
public abstract int commitAllowingStateLoss();
commitAllowingStateLoss() 也是異步執行，但它的不同之處在於，允許在 Activity 保存狀態之後調用，也就是說它遇到狀態丟失不會報錯。
因此我們一般在界面狀態出錯是可以接受的情況下使用它。
public abstract void commitNow();
commitNow() 是同步執行的，立即提交任務。
前面提到 FragmentManager.executePendingTransactions() 也可以實現立即提交事務。但我們一般建議使用 commitNow() , 因爲另外那位是一下子執行所有待執行的任務，可能會把當前所有的事務都一下子執行了，這有可能有副作用。
此外，這個方法提交的事務可能不會被添加到
FragmentManger的後退棧，因爲你這樣直接提交，有可能影響其他異步執行任務在棧中的順序。
和 commit() 一樣， commitNow() 也必須在 Activity 保存狀態前調用，否則會拋異常。
public abstract void commitNowAllowingStateLoss();
同步執行的 commitAllowingStateLoss() 。
OK，瞭解了 FragmentTransaction 定義的操作，去看看我們真正關心的、 beginTransaction()中返回的 BackStackRecord :
@Override
public FragmentTransaction beginTransaction() {
return new BackStackRecord(this);
}
3.3事務真正實現/回退棧 BackStackRecord
BackStackRecord 既是對 Fragment 進行操作的事務的真正實現，也是 FragmentManager 中的回退棧的實現：
final class BackStackRecord extends
FragmentTransaction implements FragmentManager.BackStackEntry, FragmentManagerImpl.OpGenerator {...}
它的關鍵成員：
final FragmentManagerImpl mManager;
//Op 可選的狀態值
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;
ArrayList<Op> mOps = new ArrayList<>();
static final class Op {
int cmd; //狀態
Fragment fragment;
int enterAnim;
int exitAnim;
int popEnterAnim;
int popExitAnim;
}
int mIndex = -1;
//棧中最後一個元素的索引
}
可以看到 Op 就是添加了狀態和動畫信息的 Fragment， mOps就是棧中所有的 Fragment。事務定義的方法它是如何實現的呢
先看添加一個 Fragment 到佈局 add() 的實現：
@Override
public FragmentTransaction add(int containerViewId, Fragment fragment) {
doAddOp(containerViewId, fragment, null, OP_ADD);
return this;
......
}
可以看到添加一個 Fragment 到佈局很簡單，概況一下就是：
修改 fragmentManager 和 ID，構造成 Op，設置狀態信息，然後添加到列表裏。
添加完了看看替換 replace 的實現：
@Override
public FragmentTransaction replace(int containerViewId, Fragment fragment) {
return replace(containerViewId, fragment, null);
}
@Override
public FragmentTransaction replace(int containerViewId, Fragment fragment, String tag) {
if (containerViewId == 0) {
throw new IllegalArgumentException("Must use non-zero containerViewId");
}
doAddOp(containerViewId, fragment, tag, OP_REPLACE);
return this;
}
太可怕了，也是調用上面剛提到的 doAddOp() ，不同之處在於第四個參數爲 OP_REPLACE ，看來之前小看了這個狀態值！
再看其他方法的實現就很簡單了，無非就是構造一個 Op，設置對應的狀態值。
@Override
public FragmentTransaction remove(Fragment fragment) {
Op op = new Op();
op.cmd = OP_REMOVE;
op.fragment = fragment;
addOp(op);
return this;
}
@Override
public FragmentTransaction hide(Fragment fragment) {
Op op = new Op();
op.cmd = OP_HIDE;
op.fragment = fragment;
addOp(op);
return this;
}
@Override
public FragmentTransaction show(Fragment fragment) {
Op op = new Op();
op.cmd = OP_SHOW;
op.fragment = fragment;
addOp(op);
return this;
}
那這些狀態值的不同是什麼時候起作用的呢？
別忘了我們操作 Fragment 還有最後一步，提交。
看看這兩個是怎麼實現的：
@Override
public int commit() {
return commitInternal(false);
}
@Override
public int commitAllowingStateLoss() {
return commitInternal(true);
}
int commitInternal(boolean allowStateLoss) {
if (mCommitted) throw new IllegalStateException("commit already called");
//...
}
}
前面已經介紹過了， FragmentManager.enqueueAction() 最終是使用 Handler 實現的異步執行。
現在的問題是執行的任務是啥?
答案就是 Handler 發送的任務 mExecCommit :
代碼多了一點省略掉了，但我們終於找到了最終的實現：Handler 異步發到主線，調度執行後，聚合、修改 Ops的狀態，然後遍歷、修改 Fragment 棧中的 View 的狀態。
3.4.真正處理的部分
前面主要是對 Fragment 的包裝類 Ops 進行一些狀態修改，真正根據 Ops 狀態進行操作在這個部分：
/**
* Executes the operations contained within this transaction. The Fragment states will only
* be modified if optimizations are not allowed.
*/
void executeOps() {
final int numOps = mOps.size();
for (int opNum = 0; opNum < numOps; opNum++) {
final Op op = mOps.get(opNum);
final Fragment f = op.fragment;
f.setNextTransition(mTransition, mTransitionStyle); switch (op.cmd) {
case OP_ADD:
f.setNextAnim(op.enterAnim);
mManager.addFragment(f, false);
break;
case OP_REMOVE:
f.setNextAnim(op.exitAnim);
mManager.removeFragment(f);
break;
case OP_HIDE:
f.setNextAnim(op.exitAnim);
mManager.hideFragment(f);
break;
case OP_SHOW:
f.setNextAnim(op.enterAnim);
mManager.showFragment(f);
break;
case OP_DETACH:
f.setNextAnim(op.exitAnim);
mManager.detachFragment(f);
break;
case OP_ATTACH:
f.setNextAnim(op.enterAnim);
mManager.attachFragment(f);
break;
default:
throw new IllegalArgumentException("Unknown cmd: " + op.cmd);
}
if (!mAllowOptimization && op.cmd != OP_ADD) {
mManager.moveFragmentToExpectedState(f);
}
}
if (!mAllowOptimization) {
// Added fragments are added at the end to comply with prior behavior.mManager.moveToState(mManager.mCurState, true);
}
}
FragmentManager 對這些方法的實現也很簡單，修改 Fragment 的狀態值，比如remove(Fragment) :
public void removeFragment(Fragment fragment) {
if (DEBUG) Log.v(TAG, "remove: " + fragment + " nesting=" + fragment.mBackStackNesting);
final boolean inactive = !fragment.isInBackStack();
if (!fragment.mDetached || inactive) {
if (mAdded != null) {
mAdded.remove(fragment);
}
if (fragment.mHasMenu && fragment.mMenuVisible) {
mNeedMenuInvalidate = true;
}
fragment.mAdded = false; //設置屬性值
fragment.mRemoving = true;
}
}
代碼很長，先省略掉…但做的事情很簡單：
- 根據狀態調用對應的生命週期方法
- 如果是新創建的，就把佈局添加到
ViewGroup中
四丶總結
OK，看完這篇文章，相信對開頭提出的問題你已經有了答案，這裏再總結一下。
Fragment、FragmentManager、FragmentTransaction 關係
Fragment- 其實是對 View 的封裝，它持有
view, containerView, fragmentManager, childFragmentManager等信息
- 其實是對 View 的封裝，它持有
FragmentManager- 是一個抽象類，它定義了對一個
Activity/Fragment中 添加進來的Fragment列表、Fragment 回退棧的操作、管理方法 - 還定義了獲取事務對象的方法
- 具體實現在
FragmentImpl中
- 是一個抽象類，它定義了對一個
FragmentTransaction- 定義了對
Fragment添加、替換、隱藏等操作，還有四種提交方法 - 具體實現是在
BackStackRecord中
- 定義了對
Fragment 如何實現佈局的添加替換
通過獲得當前 Activity/Fragment 的FragmentManager/ChildFragmentManager，進而拿到事務的實
現類 BackStackRecord，它將目標 Fragment 構造成 Ops（包裝Fragment和狀態信息），然後提交給FragmentManager 處理。
如果是異步提交，就通過 Handler 發送 Runnable 任務，FragmentManager 拿到任務後，先處理 Ops
狀態，然後調用 moveToState() 方法根據狀態調用 Fragment 對應的生命週期方法，從而達到Fragment 的添加、佈局的替換隱藏等。
下面這張圖從下往上看就是一個 Fragment 創建經歷的方法：
嵌套 Fragment的原理
也比較簡單，Fragment 內部有一個 childFragmentManager，通過它管理子 Fragment。
在添加子 Fragment 時，把子 Fragment 的佈局 add 到父 Fragment 即可
由於很多代碼太長了，敲了一下午，眼睛和手都酸了，對這樣感興趣的可以拿這份筆記自己研究，有不懂的歡迎留言
知識彙總的PDF相關內容後續GitHub更新,想衝擊金三銀四的小夥伴可以找找看看，歡迎star
（順手留下GitHub鏈接，需要獲取相關面試等內容的可以自己去找）
https://github.com/xiangjiana/Android-MS
更多完整項目下載。未完待續。源碼。圖文知識後續上傳github。
可以點擊關於我聯繫我獲取