Android基礎：Fragment，看這篇就夠了

原文位址： https://mp.weixin.qq.com/s/dUuGSVhWinAnN9uMiBaXgw

導語 Fragment作為Android最基本，最重要的基礎概念之一，在開發中經常會和他打交道。本文從為什麼出現Fragment開始，介紹了Fragment相關的方方面面，包括Fragment的基本定義及使用、回退棧的内部實作、Fragment通信、DialogFragment、ViewPager+Fragment的使用、嵌套Fragment、懶加載等。

下文中FragmentDemo的源代碼位址：https://github.com/xiazdong/FragmentDemo

基本概念

Fragment，簡稱碎片，是Android 3.0（API 11）提出的，為了相容低版本，support-v4庫中也開發了一套Fragment API，最低相容Android 1.6。

過去support-v4庫是一個jar包，24.2.0版本開始，将support-v4庫子產品化為多個jar包，包含：support-fragment, support-ui, support-media-compat等，這麼做是為了減少APK包大小，你需要用哪個子產品就引入哪個子產品。

如果想引入整個support-v4庫，則compile 'com.android.support:support-v4:24.2.1'，

如果隻想引入support-fragment庫，則com.android.support:support-fragment:24.2.1。

因為support庫是不斷更新的，是以建議使用support庫中的android.support.v4.app.Fragment，而不要用系統自帶的android.app.Fragment。而如果要使用support庫的Fragment，Activity必須要繼承FragmentActivity（AppCompatActivity是FragmentActivity的子類）。

Fragment官方的定義是：

A Fragment represents a behavior or a portion of user interface in an Activity. You can combine multiple fragments in a single activity to build a multi-pane UI and reuse a fragment in multiple activities. You can think of a fragment as a modular section of an activity, which has its own lifecycle, receives its own input events, and which you can add or remove while the activity is running.

根據上面的定義可知：

• Fragment是依賴于Activity的，不能獨立存在的。
• 一個Activity裡可以有多個Fragment。
• 一個Fragment可以被多個Activity重用。
• Fragment有自己的生命周期，并能接收輸入事件。
• 我們能在Activity運作時動态地添加或删除Fragment。

Android 3.0系統隻針對平闆電腦，且閉源，那時候針對手機和針對平闆是兩套源代碼，後來Android 4.0時整合了手機和平闆的源碼，是以市面上很難看到Android 3.0系統。

Fragment的優勢有以下幾點：

• 子產品化（Modularity）：我們不必把所有代碼全部寫在Activity中，而是把代碼寫在各自的Fragment中。
• 可重用（Reusability）：多個Activity可以重用一個Fragment。
• 可适配（Adaptability）：根據硬體的螢幕尺寸、螢幕方向，能夠友善地實作不同的布局，這樣使用者體驗更好。

Fragment核心的類有：

• Fragment：Fragment的基類，任何建立的Fragment都需要繼承該類。
• FragmentManager：管理和維護Fragment。他是抽象類，具體的實作類是FragmentManagerImpl。

• FragmentTransaction：對Fragment的添加、删除等操作都需要通過事務方式進行。他是抽象類，具體的實作類是BackStackRecord。

  Nested Fragment（Fragment内部嵌套Fragment的能力）是Android 4.2提出的，support-fragment庫可以相容到1.6。通過getChildFragmentManager()

  能夠獲得管理子Fragment的FragmentManager，在子Fragment中可以通過getParentFragment()

  獲得父Fragment。

基本使用

這裡給出Fragment最基本的使用方式。首先，建立繼承Fragment的類，名為Fragment1：

public class Fragment1 extends Fragment{
    private static String ARG_PARAM = "param_key";
    private String mParam;
    private Activity mActivity;
    public void onAttach(Context context) {
        mActivity = (Activity) context;
        mParam = getArguments().getString(ARG_PARAM);  //擷取參數
    }
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View root = inflater.inflate(R.layout.fragment_1, container, false);
        TextView view = root.findViewById(R.id.text);
        view.setText(mParam);
        return root;
    }
    public static Fragment1 newInstance(String str) {
        Fragment1 frag = new Fragment1();
        Bundle bundle = new Bundle();
        bundle.putString(ARG_PARAM, str);
        fragment.setArguments(bundle);   //設定參數
        return fragment;
    }
}
           

Fragment有很多可以複寫的方法，其中最常用的就是onCreateView()

，該方法傳回Fragment的UI布局，需要注意的是inflate()

的第三個參數是false，因為在Fragment内部實作中，會把該布局添加到container中，如果設為true，那麼就會重複做兩次添加，則會抛如下異常：

Caused by: java.lang.IllegalStateException: The specified child already has a parent. You must call removeView() on the child's parent first.
           

如果在建立Fragment時要傳入參數，必須要通過setArguments(Bundle bundle)

方式添加，而不建議通過為Fragment添加帶參數的構造函數，因為通過setArguments()

方式添加，在由于記憶體緊張導緻Fragment被系統殺掉并恢複（re-instantiate）時能保留這些資料。官方建議如下：

It is strongly recommended that subclasses do not have other constructors with parameters, since these constructors will not be called when the fragment is re-instantiated.
           

我們可以在Fragment的onAttach()

中通過getArguments()

獲得傳進來的參數，并在之後使用這些參數。如果要擷取Activity對象，不建議調用getActivity()

，而是在onAttach()

中将Context對象強轉為Activity對象。

建立完Fragment後，接下來就是把Fragment添加到Activity中。在Activity中添加Fragment的方式有兩種：

• 靜态添加：在xml中通過的方式添加，缺點是一旦添加就不能在運作時删除。
• 動态添加：運作時添加，這種方式比較靈活，是以建議使用這種方式。

雖然Fragment能在XML中添加，但是這隻是一個文法糖而已，Fragment并不是一個View，而是和Activity同一層次的。

這裡隻給出動态添加的方式。首先Activity需要有一個容器存放Fragment，一般是FrameLayout，是以在Activity的布局檔案中加入FrameLayout：

<FrameLayout
    android:id="@+id/container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>
           

然後在

onCreate()

中，通過以下代碼将Fragment添加進Activity中。

if (bundle == null) {
    getSupportFragmentManager().beginTransaction()
        .add(R.id.container, Fragment1.newInstance("hello world"), "f1")        //.addToBackStack("fname")
        .commit();
}
           

這裡需要注意幾點：

• 因為我們使用了support庫的Fragment，是以需要使用getSupportFragmentManager()

  擷取FragmentManager。

• add()

  是對Fragment衆多操作中的一種，還有

  remove()

  , 

  replace()

  等，第一個參數是根容器的id（FrameLayout的id，即”@id/container”），第二個參數是Fragment對象，第三個參數是fragment的tag名，指定tag的好處是後續我們可以通過

  Fragment1 frag = getSupportFragmentManager().findFragmentByTag("f1")

  從FragmentManager中查找Fragment對象。
• 在一次事務中，可以做多個操作，比如同時做

  add().remove().replace()

  。

• commit()

  操作是異步的，内部通過

  mManager.enqueueAction()

  加入處理隊列。對應的同步方法為

  commitNow()

  ，

  commit()

  内部會有

  checkStateLoss()

  操作，如果開發人員使用不當（比如

  commit()

  操作在

  onSaveInstanceState()

  之後），可能會抛出異常，而

  commitAllowingStateLoss()

  方法則是不會抛出異常版本的

  commit()

  方法，但是盡量使用

  commit()

  ，而不要使用

  commitAllowingStateLoss()

  。

• addToBackStack("fname")

  是可選的。FragmentManager擁有回退棧（BackStack），類似于Activity的任務棧，如果添加了該語句，就把該事務加入回退棧，當使用者點選傳回按鈕，會回退該事務（回退指的是如果事務是

  add(frag1)

  ，那麼回退操作就是

  remove(frag1)

  ）；如果沒添加該語句，使用者點選傳回按鈕會直接銷毀Activity。
• Fragment有一個常見的問題，即Fragment重疊問題，這是由于Fragment被系統殺掉，并重新初始化時再次将fragment加入activity，是以通過在外圍加if語句能判斷此時是否是被系統殺掉并重新初始化的情況。

Fragment有個常見的異常：

java.lang.IllegalStateException: Can not perform this action after onSaveInstanceState
    at android.support.v4.app.FragmentManagerImpl.checkStateLoss(FragmentManager.java:1341)
    at android.support.v4.app.FragmentManagerImpl.enqueueAction(FragmentManager.java:1352)
    at android.support.v4.app.BackStackRecord.commitInternal(BackStackRecord.java:595)
    at android.support.v4.app.BackStackRecord.commit(BackStackRecord.java:574)
           

該異常出現的原因是：

commit()

在

onSaveInstanceState()

後調用。首先，

onSaveInstanceState()

在

onPause()

之後，

onStop()

之前調用。

onRestoreInstanceState()

在

onStart()

之後，

onResume()

之前。

是以避免出現該異常的方案有：

• 不要把Fragment事務放在異步線程的回調中，比如不要把Fragment事務放在AsyncTask的

  onPostExecute()

  ，是以

  onPostExecute()

  可能會在

  onSaveInstanceState()

  之後執行。
• 逼不得已時使用

  commitAllowingStateLoss()

  。

生命周期

Fragment的生命周期和Activity類似，但比Activity的生命周期複雜一些，基本的生命周期方法如下圖：

解釋如下：

• onAttach()：Fragment和Activity相關聯時調用。可以通過該方法擷取Activity引用，還可以通過getArguments()擷取參數。
• onCreate()：Fragment被建立時調用。
• onCreateView()：建立Fragment的布局。
• onActivityCreated()：當Activity完成onCreate()時調用。
• onStart()：當Fragment可見時調用。
• onResume()：當Fragment可見且可互動時調用。
• onPause()：當Fragment不可互動但可見時調用。
• onStop()：當Fragment不可見時調用。
• onDestroyView()：當Fragment的UI從視圖結構中移除時調用。
• onDestroy()：銷毀Fragment時調用。
• onDetach()：當Fragment和Activity解除關聯時調用。

上面的方法中，隻有onCreateView()在重寫時不用寫super方法，其他都需要。

因為Fragment是依賴Activity的，是以為了講解Fragment的生命周期，需要和Activity的生命周期方法一起講，即Fragment的各個生命周期方法和Activity的各個生命周期方法的關系和順序，如圖：

image.png

我們這裡舉個例子來了解Fragment生命周期方法。功能如下：共有兩個Fragment：F1和F2，F1在初始化時就加入Activity，點選F1中的按鈕調用replace替換為F2。

當F1在Activity的

onCreate()

中被添加時，日志如下：

BasicActivity: [onCreate] 
BEGINBasicActivity: [onCreate] END
BasicActivity: [onStart] BEGIN
Fragment1: [onAttach] BEGIN 
Fragment1: [onAttach] END
BasicActivity: [onAttachFragment] BEGIN
BasicActivity: [onAttachFragment] END
Fragment1: [onCreate] BEGIN
Fragment1: [onCreate] END
Fragment1: [onCreateView]
Fragment1: [onViewCreated] BEGIN
Fragment1: [onViewCreated] END
Fragment1: [onActivityCreated] BEGIN
Fragment1: [onActivityCreated] END
Fragment1: [onStart] BEGIN
Fragment1: [onStart] END
BasicActivity: [onStart] END
BasicActivity: [onPostCreate] BEGIN
BasicActivity: [onPostCreate] END
BasicActivity: [onResume] BEGIN
BasicActivity: [onResume] END
BasicActivity: [onPostResume] BEGIN
Fragment1: [onResume] BEGIN
Fragment1: [onResume] END
BasicActivity: [onPostResume] END
BasicActivity: [onAttachedToWindow] BEGIN
BasicActivity: [onAttachedToWindow] END
           

可以看出：

• Fragment的onAttach()->onCreate()->onCreateView()->onActivityCreated()->onStart()都是在Activity的onStart()中調用的。
• Fragment的onResume()在Activity的onResume()之後調用。

接下去分兩種情況，分别是不加addToBackStack()和加addToBackStack()。

1、當點選F1的按鈕，調用replace()替換為F2，且不加addToBackStack()時，日志如下：

Fragment2: [onAttach] BEGIN
Fragment2: [onAttach] END
BasicActivity: [onAttachFragment] BEGIN
BasicActivity: [onAttachFragment] END
Fragment2: [onCreate] BEGIN
Fragment2: [onCreate] END
Fragment1: [onPause] BEGIN
Fragment1: [onPause] END
Fragment1: [onStop] BEGIN
Fragment1: [onStop] END
Fragment1: [onDestroyView] BEGIN
Fragment1: [onDestroyView] END
Fragment1: [onDestroy] BEGIN
Fragment1: [onDestroy] END
Fragment1: [onDetach] BEGIN
Fragment1: [onDetach] END
Fragment2: [onCreateView]
Fragment2: [onViewCreated] BEGIN
Fragment2: [onViewCreated] END
Fragment2: [onActivityCreated] BEGIN
Fragment2: [onActivityCreated] END
Fragment2: [onStart] BEGIN
Fragment2: [onStart] END
Fragment2: [onResume] BEGIN
Fragment2: [onResume] END
           

可以看到，F1最後調用了onDestroy()和onDetach()。

2、當點選F1的按鈕，調用replace()替換為F2，且加addToBackStack()時，日志如下：

Fragment2: [onAttach] BEGIN
Fragment2: [onAttach] END
BasicActivity: [onAttachFragment] BEGIN
BasicActivity: [onAttachFragment] END
Fragment2: [onCreate] BEGIN
Fragment2: [onCreate] END
Fragment1: [onPause] BEGIN
Fragment1: [onPause] END
Fragment1: [onStop] BEGIN
Fragment1: [onStop] END
Fragment1: [onDestroyView] BEGIN
Fragment1: [onDestroyView] END
Fragment2: [onCreateView]
Fragment2: [onViewCreated] BEGIN
Fragment2: [onViewCreated] END
Fragment2: [onActivityCreated] BEGIN
Fragment2: [onActivityCreated] END
Fragment2: [onStart] BEGIN
Fragment2: [onStart] END
Fragment2: [onResume] BEGIN
Fragment2: [onResume] END
           

可以看到，F1被替換時，最後隻調到了

onDestroyView()

，并沒有調用

onDestroy()

和

onDetach()

。當使用者點傳回按鈕回退事務時，F1會調

onCreateView()->onStart()->onResume()

，是以在Fragment事務中加不加

addToBackStack()

會影響Fragment的生命周期。

FragmentTransaction有一些基本方法，下面給出調用這些方法時，Fragment生命周期的變化：

• add(): onAttach()->…->onResume()。
• remove(): onPause()->…->onDetach()。
• replace(): 相當于舊Fragment調用remove()，新Fragment調用add()。
• show(): 不調用任何生命周期方法，調用該方法的前提是要顯示的Fragment已經被添加到容器，隻是純粹把Fragment UI的setVisibility為true。
• hide(): 不調用任何生命周期方法，調用該方法的前提是要顯示的Fragment已經被添加到容器，隻是純粹把Fragment UI的setVisibility為false。
• detach(): onPause()->onStop()->onDestroyView()。UI從布局中移除，但是仍然被FragmentManager管理。
• attach(): onCreateView()->onStart()->onResume()。

Fragment實作原理和Back Stack

我們知道Activity有任務棧，使用者通過startActivity将Activity加入棧，點選傳回按鈕将Activity出棧。Fragment也有類似的棧，稱為回退棧（Back Stack），回退棧是由FragmentManager管理的。預設情況下，Fragment事務是不會加入回退棧的，如果想将Fragment事務加入回退棧，則可以加入addToBackStack("")

。如果沒有加入回退棧，則使用者點選傳回按鈕會直接将Activity出棧；如果加入了回退棧，則使用者點選傳回按鈕會復原Fragment事務。

我們将通過最常見的Fragment用法，講解Back Stack的實作原理：

getSupportFragmentManager().beginTransaction()
    .add(R.id.container, f1, "f1")
    .addToBackStack("")
    .commit();
           

上面這個代碼的功能就是将Fragment加入Activity中，内部實作為：建立一個BackStackRecord對象，該對象記錄了這個事務的全部操作軌迹（這裡隻做了一次add操作，并且加入回退棧），随後将該對象送出到FragmentManager的執行隊列中，等待執行。

BackStackRecord類的定義如下

class BackStackRecord extends FragmentTransaction implements FragmentManager.BackStackEntry, Runnable {}
           

從定義可以看出，BackStackRecord有三重含義：

• 繼承了FragmentTransaction，即是事務，儲存了整個事務的全部操作軌迹。
• 實作了BackStackEntry，作為回退棧的元素，正是因為該類擁有事務全部的操作軌迹，是以在popBackStack()時能回退整個事務。
• 繼承了Runnable，即被放入FragmentManager執行隊列，等待被執行。

先看第一層含義，getSupportFragmentManager.beginTransaction()

傳回的就是BackStackRecord對象，代碼如下：

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

BackStackRecord類包含了一次事務的整個操作軌迹，是以連結清單形式存在的，連結清單的元素是Op類，表示其中某個操作，定義如下：

static final class Op {
    Op next; //連結清單後一個節點
    Op prev; //連結清單前一個節點
    int cmd;  //操作是add或remove或replace或hide或show等
    Fragment fragment; //對哪個Fragment對象做操作
}
           

我們來看下具體場景下這些類是怎麼被使用的，比如我們的事務做add操作。add函數的定義：

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

doAddOp()方法就是建立Op對象，并加傳入連結表，定義如下：

private void doAddOp(int containerViewId, Fragment fragment, String tag, int opcmd) {
    fragment.mTag = tag;  //設定fragment的tag
    fragment.mContainerId = fragment.mFragmentId = containerViewId;  //設定fragment的容器id
    Op op = new Op();
    op.cmd = opcmd;
    op.fragment = fragment;
    addOp(op);
}
           

addOp()是将建立好的Op對象加傳入連結表，定義如下：

void addOp(Op op) {
   if (mHead == null) {
        mHead = mTail = op;
    } else {
        op.prev = mTail;
        mTail.next = op;
        mTail = op;
    }
    mNumOp++;
}
           

addToBackStack(“”)

是将mAddToBackStack變量記為true，在

commit()

中會用到該變量。

commit()

是異步的，即不是立即生效的，但是後面會看到整個過程還是在主線程完成，隻是把事務的執行扔給主線程的Handler，

commit()

内部是

commitInternal()

，實作如下：

int commitInternal(boolean allowStateLoss) {
    mCommitted = true;
   if (mAddToBackStack) {
        mIndex = mManager.allocBackStackIndex(this);
    } else {
        mIndex = -1;
    }
    mManager.enqueueAction(this, allowStateLoss); //将事務添加進待執行隊列中
    return mIndex;
}
           

如果mAddToBackStack為true，則調用

allocBackStackIndex(this)

将事務添加進回退棧，FragmentManager類的變量ArrayListmBackStackIndices;就是回退棧。實作如下：

public int allocBackStackIndex(BackStackRecord bse) {
   if (mBackStackIndices == null) {
        mBackStackIndices = new ArrayList<BackStackRecord>();
   }
   int index = mBackStackIndices.size();
   mBackStackIndices.add(bse);
   return index;
}
           

在

commitInternal()

中，

mManager.enqueueAction(this, allowStateLoss)

;是将BackStackRecord加入待執行隊列中，定義如下：

public void enqueueAction(Runnable action, boolean allowStateLoss) {
   if (mPendingActions == null) {
        mPendingActions = new ArrayList<Runnable>();
    }
    mPendingActions.add(action);
    if (mPendingActions.size() == 1) {
        mHost.getHandler().removeCallbacks(mExecCommit);
        mHost.getHandler().post(mExecCommit); //調用execPendingActions()執行待執行隊列的事務
    }
}
           

mPendingActions就是前面說的待執行隊列，

mHost.getHandler()

就是主線程的Handler，是以Runnable是在主線程執行的，mExecCommit的内部就是調用了

execPendingActions()

，即把mPendingActions中所有積壓的沒被執行的事務全部執行。執行隊列中的事務會怎樣被執行呢？就是調用BackStackRecord的

run()

方法，

run()

方法就是執行Fragment的生命周期函數，還有将視圖添加進container中。

與

addToBackStack()

對應的是

popBackStack()

，有以下幾種變種：

• popBackStack()：将回退棧的棧頂彈出，并回退該事務。
• popBackStack(String name, int flag)：name為addToBackStack(String name)的參數，通過name能找到回退棧的特定元素，flag可以為0或者FragmentManager.POP_BACK_STACK_INCLUSIVE，0表示隻彈出該元素以上的所有元素，POP_BACK_STACK_INCLUSIVE表示彈出包含該元素及以上的所有元素。這裡說的彈出所有元素包含回退這些事務。
• popBackStack()是異步執行的，是丢到主線程的MessageQueue執行，popBackStackImmediate()是同步版本。

我們通過講解Demo1來更清晰地了解回退棧的使用。功能如下：共有三個Fragment：F1, F2, F3，F1在初始化時就加入Activity，點選F1中的按鈕跳轉到F2，點選F2的按鈕跳轉到F3，點選F3的按鈕回退到F1。

在Activity的onCreate()中，将F1加入Activity中：

getSupportFragmentManager().beginTransaction()
    .add(R.id.container, f1, "f1")
    .addToBackStack(Fragment1.class.getSimpleName())
    .commit();
           

F1按鈕的onClick()内容如下：

getFragmentManager().beginTransaction()
    .replace(R.id.container, f2, "f2")
    .addToBackStack(Fragment2.class.getSimpleName())
    .commit();
           

F2按鈕的onClick()如下：

getFragmentManager().beginTransaction()
    .replace(R.id.container, f3, "f3")
    .addToBackStack(Fragment3.class.getSimpleName())
    .commit();
           

F3按鈕的onClick()如下：

getFragmentManager().popBackStack(Fragment2.class.getSimpleName(), FragmentManager.POP_BACK_STACK_INCLUSIVE);
           

這樣就完成了整個界面的跳轉邏輯。

這裡補充一個點

getSupportFragmentManager().findFragmentByTag()

是經常用到的方法，他是FragmentManager的方法，FragmentManager是抽象類，FragmentManagerImpl是繼承FragmentManager的實作類，他的内部實作是：

class FragmentManagerImpl extends FragmentManager {
    ArrayList<Fragment> mActive;
    ArrayList<Fragment> mAdded;

    public Fragment findFragmentByTag(String tag) {
        if (mAdded != null && tag != null) {
            for (int i = mAdded.size() - 1; i >= 0; i--) {
                Fragment f = mAdded.get(i);
                if (f != null && tag.equals(f.mTag)) {
                    return f;
                }
            }
        }
        if (mActive != null && tag != null) {
            for (int i = mActive.size() - 1; i >= 0; i--) {
                Fragment f = mActive.get(i);
                if (f != null && tag.equals(f.mTag)) {
                    return f;
                }
            }
        }
        return null;
    }
}
           

從上面看到，先從mAdded中查找是否有該Fragment，如果沒找到，再從mActive中查找是否有該Fragment。mAdded是已經添加到Activity的Fragment的集合，mActive不僅包含mAdded，還包含雖然不在Activity中，但還在回退棧中的Fragment。

Fragment通信

Fragment向Activity傳遞資料

首先，在Fragment中定義接口，并讓Activity實作該接口（具體實作省略）：

public interface OnFragmentInteractionListener {
    void onItemClick(String str);  //将str從Fragment傳遞給Activity
}
           

在Fragment的onAttach()中，将參數Context強轉為OnFragmentInteractionListener對象：

public void onAttach(Context context) {
    super.onAttach(context);
    if (context instanceof OnFragmentInteractionListener) {
        mListener = (OnFragmentInteractionListener) context;
    } else {
        throw new RuntimeException(context.toString() + " must implement OnFragmentInteractionListener");
    }
}
           

并在Fragment合适的地方調用

mListener.onItemClick("hello")

将”hello”從Fragment傳遞給Activity。

FABridge

由于通過接口的方式從Fragment向Activity進行資料傳遞比較麻煩，需要在Fragment中定義interface，并讓Activity實作該interface，FABridge(https://github.com/hongyangAndroid/FABridge)通過注解的形式免去了這些定義。

在build.gradle中添加依賴：

annotationProcessor 'com.zhy.fabridge:fabridge-compiler:1.0.0'compile 'com.zhy.fabridge:fabridge-api:1.0.0'
           

首先定義方法ID，這裡為FAB_ITEM_CLICK，接着在Activity中定義接口：

@FCallbackId(id = FAB_ITEM_CLICK)
public void onItemClick(String str) {  //方法名任意
    Toast.makeText(this, str, Toast.LENGTH_SHORT).show();
}
           

最後，在Fragment中，通過以下形式調用”ID=FAB_ITEM_CLICK”的方法（該方法可能在Activity中，也可能在任何類中）：

Fabridge.call(mActivity,FAB_ITEM_CLICK,"data");  //調用ID對應的方法，"data"為參數值
           

Activity向Fragment傳遞資料

Activity向Fragment傳遞資料比較簡單，擷取Fragment對象，并調用Fragment的方法即可，比如要将一個字元串傳遞給Fragment，則在Fragment中定義方法：

public void setString(String str) {
    this.str = str;
}
           

并在Activity中調用

fragment.setString("hello")

即可。

Fragment之間通信

由于Fragment之間是沒有任何依賴關系的，是以如果要進行Fragment之間的通信，建議通過Activity作為中介，不要Fragment之間直接通信。

DialogFragment

DialogFragment是Android 3.0提出的，代替了Dialog，用于實作對話框。他的優點是：即使旋轉螢幕，也能保留對話框狀态。

如果要自定義對話框樣式，隻需要繼承DialogFragment，并重寫

onCreateView()

，該方法傳回對話框UI。這裡我們舉個例子，實作進度條樣式的圓角對話框。

public class ProgressDialogFragment extends DialogFragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        getDialog().requestWindowFeature(Window.FEATURE_NO_TITLE); //消除Title區域 
        getDialog().getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));  //将背景變為透明
        setCancelable(false);  //點選外部不可取消
        View root = inflater.inflate(R.layout.fragment_progress_dialog, container);
        return root;
    }

    public static ProgressDialogFragment newInstance() {
        return new ProgressDialogFragment();
    }
}
           

進度條動畫我們使用Lottie(https://github.com/airbnb/lottie-android)實作，Lottie動畫從這裡(https://www.lottiefiles.com/)找到。使用非常友善，隻需要下載下傳JSON動畫檔案，然後在XML中寫入：

<com.airbnb.lottie.LottieAnimationView
    android:layout_width="wrap_content"  //大小根據JSON檔案确定
    android:layout_height="wrap_content"
    app:lottie_fileName="loader_ring.json"   //JSON檔案
    app:lottie_loop="true"    //循環播放
    app:lottie_autoPlay="true" />  //自動播放
           

然後通過下面代碼顯示對話框：

ProgressDialogFragment fragment = ProgressDialogFragment.newInstance();
fragment.show(getSupportFragmentManager(), "tag");//fragment.dismiss();
           

為了實作圓角，除了在onCreateView()中把背景設為透明，還需要對UI加入背景：

<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <solid android:color="#ffffff"/>
    <corners android:radius="20dp"/>
</shape>
           

ViewPager+Fragment相關

基本使用

ViewPager是support v4庫中提供界面滑動的類，繼承自ViewGroup。PagerAdapter是ViewPager的擴充卡類，為ViewPager提供界面。但是一般來說，通常都會使用PagerAdapter的兩個子類：FragmentPagerAdapter和FragmentStatePagerAdapter作為ViewPager的擴充卡，他們的特點是界面是Fragment。

在support v13和support v4中都提供了FragmentPagerAdapter和FragmentStatePagerAdapter，差別在于：support v13中使用android.app.Fragment，而support v4使用android.support.v4.app.Fragment。一般都使用support v4中的FragmentPagerAdapter和FragmentStatePagerAdapter。

預設，ViewPager會緩存目前頁相鄰的界面，比如當滑動到第2頁時，會初始化第1頁和第3頁的界面（即Fragment對象，且生命周期函數運作到

onResume()

），可以通過

setOffscreenPageLimit(count)

設定離線緩存的界面個數。

FragmentPagerAdapter和FragmentStatePagerAdapter需要重寫的方法都一樣，常見的重寫方法如下：

• public FragmentPagerAdapter(FragmentManager fm): 構造函數，參數為FragmentManager。如果是嵌套Fragment場景，子 PagerAdapter的參數傳入getChildFragmentManager()。
• Fragment getItem(int position): 傳回第position位置的Fragment，必須重寫。
• int getCount(): 傳回ViewPager的頁數，必須重寫。
• Object instantiateItem(ViewGroup container, int position): container是ViewPager對象，傳回第position位置的Fragment。
• void destroyItem(ViewGroup container, int position, Object object): container是ViewPager對象，object是Fragment對象。
• getItemPosition(Object object): object是Fragment對象，如果傳回POSITION_UNCHANGED，則表示目前Fragment不重新整理，如果傳回POSITION_NONE，則表示目前Fragment需要調用

  destroyItem()

  和

  instantiateItem()

  進行銷毀和重建。 預設情況下傳回POSITION_UNCHANGED。

懶加載

懶加載主要用于ViewPager且每頁是Fragment的情況，場景為微信主界面，底部有4個tab，當滑到另一個tab時，先顯示”正在加載”，過一會才會顯示正常界面。

預設情況，ViewPager會緩存目前頁和左右相鄰的界面。實作懶加載的主要原因是：使用者沒進入的界面需要有一系列的網絡、資料庫等耗資源、耗時的操作，預先做這些資料加載是不必要的。

這裡懶加載的實作思路是：使用者不可見的界面，隻初始化UI，但是不會做任何資料加載。等滑到該頁，才會異步做資料加載并更新UI。

這裡就實作類似微信那種效果，整個UI布局為：底部用PagerBottomTabStrip(https://github.com/tyzlmjj/PagerBottomTabStrip)項目實作，上面是ViewPager，使用FragmentPagerAdapter。邏輯為：當使用者滑到另一個界面，首先會顯示正在加載，等資料加載完畢後（這裡用睡眠1秒鐘代替）顯示正常界面。

ViewPager預設緩存左右相鄰界面，為了避免不必要的重新資料加載（重複調用

onCreateView()

），因為有4個tab，是以将離線緩存的半徑設定為3，即

setOffscreenPageLimit(3)

。

懶加載主要依賴Fragment的

setUserVisibleHint(boolean isVisible)

方法，當Fragment變為可見時，會調用

setUserVisibleHint(true)

；當Fragment變為不可見時，會調用

setUserVisibleHint(false)

，且該方法調用時機：

• onAttach()之前，調用

  setUserVisibleHint(false)

  。
• onCreateView()之前，如果該界面為目前頁，則調用

  setUserVisibleHint(true)

  ，否則調用

  setUserVisibleHint(false)

  。
• 界面變為可見時，調用

  setUserVisibleHint(true)

  。*界面變為不可見時，調用

  setUserVisibleHint(false)

  。

懶加載Fragment的實作：

public class LazyFragment extends Fragment {
    private View mRootView;
    private boolean mIsInited;
    private boolean mIsPrepared;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        mRootView = inflater.inflate(R.layout.fragment_lazy, container, false);
        mIsPrepared = true;
        lazyLoad();
        return mRootView;
    }

    public void lazyLoad() {
        if (getUserVisibleHint() && mIsPrepared && !mIsInited) {
            //異步初始化，在初始化後顯示正常UI
            loadData();
        }
    }

    private void loadData() {
        new Thread() {
            public void run() {
                //1. 加載資料
                //2. 更新UI
                //3. mIsInited = true
            }
        }.start();
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        if (isVisibleToUser) {
            lazyLoad();
        }
    }

    public static LazyFragment newInstance() {
        return new LazyFragment();
    }
}
           

注意點：

• 在Fragment中有兩個變量控制是否需要做資料加載：
  • mIsPrepared：表示UI是否準備好，因為資料加載後需要更新UI，如果UI還沒有inflate，就不需要做資料加載，因為setUserVisibleHint()會在onCreateView()之前調用一次，如果此時調用，UI還沒有inflate，是以不能加載資料。
  • mIsInited：表示是否已經做過資料加載，如果做過了就不需要做了。因為setUserVisibleHint(true)在界面可見時都會調用，如果滑到該界面做過資料加載後，滑走，再滑回來，還是會調用setUserVisibleHint(true)，此時由于mIsInited=true，是以不會再做一遍資料加載。
• lazyLoad()：懶加載的核心類，在該方法中，隻有界面可見（getUserVisibleHint()==true）、UI準備好（mIsPrepared==true）、過去沒做過資料加載（mIsInited==false）時，才需要調loadData()做資料加載，資料加載做完後把mIsInited置為true。

布局XML主要分兩個container，一個是初始顯示的狀态，即R.id.container_empty，當資料加載完成，就顯示R.id.container：

<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent">
    <RelativeLayout
        android:id="@+id/container_empty"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:text="正在加載"
            />
    </RelativeLayout>
    <RelativeLayout
        android:id="@+id/container"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone"
        >
        ... 
   </RelativeLayout>
</FrameLayout>
           

參考文獻

• 入門(https://www.raywenderlich.com/169885/android-fragments-tutorial-introduction-2)

• 教程1

  (http://assets.en.oreilly.com/1/event/68/Fragments%20for%20All%20Presentation.pdf)

• 教程2

  (http://vinsol.com/blog/2014/09/15/advocating-fragment-oriented-applications-in-android/)

• 生命周期(https://github.com/xxv/android-lifecycle)

• detach vs remove

  (https://stackoverflow.com/questions/9156406/whats-the-difference-between-detaching-a-fragment-and-removing-it)

• Google I/O 2016: What the Fragment?(https://www.youtube.com/watch?v=k3IT-IJ0J98)

• Google I/O 2017: Fragment Tricks

  (https://www.youtube.com/watch?v=eUG3VWnXFtg)

• mAdded和mActive的差別(https://stackoverflow.com/questions/25695960/difference-between-madded-mactive-in-source-code-of-support-fragmentmanager)
• 如何避免IllegalStateException異常(http://www.androiddesignpatterns.com/2013/08/fragment-transaction-commit-state-loss.html)