Android Fragment 使用解析

時間  2019-11-06
標籤 android fragment 使用 解析 欄目 Android 简体版
原文   原文鏈接

1. 基本概念

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

過去support-v4庫是一個jar包，24.2.0版本開始，將support-v4庫模塊化爲多個jar包，包含：support-fragment, support-ui, support-media-compat等，這麼作是爲了減小APK包大小，你須要用哪一個模塊就引入哪一個模塊。android

若是想引入整個support-v4庫，則compile 'com.android.support:support-v4:24.2.1'，若是隻想引入support-fragment庫，則com.android.support:support-fragment:24.2.1。git

由於support庫是不斷更新的，所以建議使用support庫中的android.support.v4.app.Fragment，而不要用系統自帶的android.app.Fragment。而若是要使用support庫的Fragment，Activity必需要繼承FragmentActivity（AppCompatActivity是FragmentActivity的子類）。github

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.數據庫

根據上面的定義可知：json

  • Fragment是依賴於Activity的，不能獨立存在的。
  • 一個Activity裏能夠有多個Fragment。
  • 一個Fragment能夠被多個Activity重用。
  • Fragment有本身的生命週期，並能接收輸入事件。
  • 咱們能在Activity運行時動態地添加或刪除Fragment。

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。api

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，那麼就會重複作兩次添加，則會拋以下異常：bash

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)方式添加，setArguments方法必須在fragment建立之後，添加給Activity前完成,而不建議經過爲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中經過的方式添加，缺點是一旦添加就不能在運行時刪除。 
    <?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:orientation="vertical">
      <fragment
          android:layout_width="match_parent"
          android:layout_height="match_parent"
          class="com.samples.Fragment1"/>
</LinearLayout>
複製代碼
  • 動態添加：運行時添加，這種方式比較靈活，所以建議使用這種方式。 雖然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,經過getSupportFragmentManager()獲取的FragmentManager只能管理Activity裏面嵌入的全部一級fragment。

    • 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語句能判斷此時是不是被系統殺掉並從新初始化的狀況。解決方法有三種

      • 第一種方式，在 Activity 提供的 onAttachFragment() 方法中處理：
      @Override
public void onAttachFragment(Fragment fragment) {
super.onAttachFragment(fragment);
if (fragment instanceof  OneFragment){
    oneFragment = (OneFragment) fragment;
    }
}
複製代碼
      • 第二種方式，在建立 Fragment 前添加判斷，判斷是否已經存在：
      Fragment tempFragment = getSupportFragmentManager()
.findFragmentByTag("OneFragment");
if (tempFragment==null) {
    oneFragment = OneFragment.newInstance();
    ft.add(R.id.fl_content, oneFragment, "OneFragment");
    }else {
    oneFragment = (OneFragment) tempFragment;
    }
複製代碼
      • 第三種方式，更爲簡單，直接利用 savedInstanceState 判斷便可：
      if (savedInstanceState==null) {
oneFragment = OneFragment.newInstance();
ft.add(R.id.fl_content, oneFragment, "OneFragment");
}else {
oneFragment = (OneFragment) getSupportFragmentManager().findFragmentByTag("OneFragment");
}
複製代碼
    複製代碼

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()是在Activity有可能被系統回收的狀況下，並且是在onPause()以後，onStop()以前調用。onRestoreInstanceState()在onStart()以後，onResume()以前。

解釋一下：onSaveInstanceState()是當activity有可能被系統回收的狀況下，並且是在onStop()以前。注意是有可能，若是是已經肯定會被銷燬，好比用戶按下了返回鍵，或者調用了finish()方法銷燬activity，則onSaveInstanceState不會被調用。或者也能夠說，此方法只有在activity被異常終止的狀況下會被調用。

onRestoreInstanceState(Bundle savedInstanceState)只有在activity確實是被系統回收，從新建立activity狀況下才會被調用，而且是在onStart()以後，onResume()以前的。

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

  • 不要把Fragment事務放在異步線程的回調中，好比不要把Fragment事務放在AsyncTask的onPostExecute()，所以onPostExecute()可能會在onSaveInstanceState()以後執行。
  • 逼不得已時使用commitAllowingStateLoss()。

2. Fragment的生命週期

Fragment必須是依存與Activity而存在的，所以Activity的生命週期會直接影響到Fragment的生命週期。

能夠看到Fragment比Activity多了幾個額外的生命週期回調方法：

  • onAttach(Context context)：Fragment和Activity相關聯時調用。若是不是必定要使用具體的宿主 Activity 對象的話，可使用這個方法或者getContext()獲取 Context 對象，用於解決Context上下文引用的問題。同時還能夠在此方法中能夠經過getArguments()獲取到須要在Fragment建立時須要的參數。
  • 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的各個生命週期方法的關係和順序，如圖：

咱們這裏舉個例子來理解Fragment生命週期方法。功能以下：共有兩個Fragment：FragmentTest和FragmentTestReplace，FragmentTest經過點擊按鈕初時加入Activity，點擊F1中的按鈕調用replace替換爲F2。

activity的初始化時，日誌以下：

當點擊Activity中的按鈕在Activity中添加FragmentTest時，日誌以下：

在Activity的onCreate（）中添加，日誌以下：

能夠看出：Fragment的onAttach()->onCreate()->onCreateView()->onActivityCreated()->onStart()都是在Activity的onStart()中調用的。

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

  1. 當點擊按鈕，調用replace()將FragmentTest替換爲FragmentTestReplace，且不加addToBackStack()時，日誌以下：

能夠看到，F1最後調用了onDestroy()和onDetach()。

  1. 當點擊按鈕，調用replace()將FragmentTest替換爲FragmentTestReplace，加addToBackStack()時，日誌以下：

能夠看到，F1被替換時，最後只調到了onDestroyView()，並無調用onDestroy()和onDetach()。當用戶點返回按鈕回退事務時，F1會調onCreateView()->onStart()->onResume()，所以在Fragment事務中加不加addToBackStack()會影響Fragment的生命週期。

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

  • add(): onAttach()->onCreate()->onCreateView()->onActivityCreated()->onStart()->onResume()，在執行add（）時，同一個Fragment不容許被add()兩次
  • remove(): onPause()->onStop()->onDestroyView()->onDestroy()->onDetach()。
  • replace():至關於新Fragment調用add()，舊Fragment調用remove(), replace() 方法不會保留 Fragment 的狀態，也就是說諸如 EditText 內容輸入等用戶操做在 remove() 時會消失。分爲兩種狀況
    • 不加addToBackStack（）: new onAttach() -> new onCreate() -> old onPause()-> old onStop()-> old onDestroyView()-> old onDestroy()-> old onDetach() -> new onCreateView() -> new onActivityCreated() -> new onStart()。
    • 加addToBackStack（）: new onAttach() -> new onCreate() -> old onPause()-> old onStop()-> old onDestroyView() -> new onCreateView -> new onActivityCreated() -> new onStart()。
  • show(): 不調用任何生命週期方法，調用該方法的前提是要顯示的Fragment已經被添加到容器，只是純粹把Fragment UI的setVisibility爲true。
  • hide(): 不調用任何生命週期方法，調用該方法的前提是要顯示的Fragment已經被添加到容器，只是純粹把Fragment UI的setVisibility爲false。
  • detach(): onPause()->onStop()->onDestroyView()。

    Detach the given fragment from the UI. This is the same state as when it is put on the back stack: the fragment is removed from the UI, however its state is still being actively managed by the fragment manager. When going into this state its view hierarchy is destroyed.。從中能夠看出detach僅僅是銷燬fragment的UI，Fragment還被fragmentManager管理。

  • attach(): onCreateView() -> onActivityCreated -> onStart() -> onResume()。 Re-attach a fragment after it had previously been detached from the UI with detach(android.app.Fragment).意思就是attach從新添加是被detach銷燬的fragment.
  • commit():提交事務·每次提交以前，必須經過mFragmentManager.beginTransaction()從新開始一個事務。

Fragment的返回棧

咱們知道Activity有任務棧，用戶經過startActivity將Activity加入棧，點擊返回按鈕將Activity出棧。Fragment也有相似的棧，稱爲回退棧（Back Stack），回退棧是由FragmentManager管理的。默認狀況下，Fragment事務是不會加入回退棧的，若是想將Fragment事務加入回退棧，則能夠加入addToBackStack("")。若是沒有加入回退棧，則用戶點擊返回按鈕會直接將Activity出棧；若是加入了回退棧，則用戶點擊返回按鈕會回滾Fragment事務。

3. 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經過@FCallbackId註解的形式免去了這些定義。

  1. 在module的build.gradle中添加依賴：
annotationProcessor 'com.zhy.fabridge:fabridge-compiler:1.0.0'
implementation 'com.zhy.fabridge:fabridge-api:1.0.0'
複製代碼
  1. 在須要進行Fragment向Activity進行數據傳遞Fragment中定義方法ID，這裏爲FAB_CLICK，接着在Activity中定義接口,接口必須爲public：
@FCallbackId(id = FAB_CLICK)
public void onFabClick(String str) {  //方法名任意
     mTextView.setText(str + "小哥哥");
}
複製代碼
  1. 在Fragment中，經過如下形式調用ID=FAB_CLICK的方法（該方法可能在Activity中，也可能在任何類中）：
Fabridge.call(mActivity,FAB_ITEM_CLICK,"我是");  //調用ID對應的方法，"data"爲參數值
複製代碼

Activity向Fragment傳遞數據

  1. 若是在建立Fragment時要傳入參數，必需要經過setArguments(Bundle bundle)方式添加，setArguments方法必須在fragment建立之後，添加給Activity前完成,而不建議經過爲Fragment添加帶參數的構造函數，由於經過setArguments()方式添加，在因爲內存緊張致使Fragment被系統殺掉並恢復（re-instantiate）時能保留這些數據。
public static Fragment newInstance(String str) {
        FragmentTest fragment = new FragmentTest();

        Bundle bundle = new Bundle();
        bundle.putString(ARG_PARAM, str);
        fragment.setArguments(bundle);//設置參數
        return fragment;
    }
複製代碼
  1. Activity向Fragment傳遞數據比較簡單，獲取Fragment對象，並調用Fragment的方法便可，好比要將一個字符串傳遞給Fragment，則在Fragment中定義方法：
public void setString(String str) {
     this.str = str;
}
複製代碼

並在Activity中調用fragment.setString("hello")便可。

Fragment之間通訊

因爲Fragment之間是沒有任何依賴關係的，所以若是要進行Fragment之間的通訊，建議經過Activity做爲中介，不要Fragment之間直接通訊。

4. 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實現，Lottie動畫從這裏找到。使用很是方便，只須要下載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>
複製代碼

5. 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。

Fragment 處理返回鍵

雖然Activity做爲Fragment的載體，可是在有些特殊（例如按下返回鍵，Fragment 直接把結果發送到 Activity載體）的狀況下，Fragment也不得不處理返回鍵事件。若是是Activity的話還好說，直接覆蓋Activity的onBackPressed便可，可是Fragment卻沒有這個onBackPressed方法，須要本身進行處理。其實在開發的時候都會封裝Fragment和Activity的用於實現本身的邏輯。

  1. 新建一個接口：OnBackPressed
    public interface OnBackPressed {
 boolean onBackPressed();
}
複製代碼
  2. 封裝一個片斷：BaseFragment 實現 OnBackPressed
    public class BaseFragment extends Fragment implements OnBackPressed {

 /**
  * fragment 中的返回鍵
  * 默認返回 false,交給Activity 處理
  * 返回 true:執行fragment中須要執行的邏輯
  * 返回 false:執行Activity中的onBackPressed
  */
 @Override
 public boolean onBackPressed() {
     return false;
 }
}
複製代碼
  3. 在Activity中的onBackPressed進行判斷便可:
    @Override
    public void onBackPressed() {
    List<Fragment> fragments = getSupportFragmentManager().getFragments();

    for (Fragment f : fragments) {
        if (f != null && f instanceof BaseFragment&& ((BaseFragment) f).onBackPressed()) {
           /*在Fragment中處理返回事件*/
           return;
        }
    }
    super.onBackPressed();
}
複製代碼
  4. 本身的Fragment繼承BaseFragment並重寫onBackPressed方法
    @Override
public boolean onBackPressed() {
    super.onBackPressed();
   /*處理返回事件*/
    return true;
}
複製代碼

懶加載

懶加載主要用於ViewPager且每頁是Fragment的狀況，場景爲微信主界面，底部有4個tab，當滑到另外一個tab時，先顯示」正在加載」，過一會纔會顯示正常界面。

默認狀況，ViewPager會緩存當前頁和左右相鄰的界面。實現懶加載的主要緣由是：用戶沒進入的界面須要有一系列的網絡、數據庫等耗資源、耗時的操做，預先作這些數據加載是沒必要要的。

這裏懶加載的實現思路是：用戶不可見的界面，只初始化UI，可是不會作任何數據加載。等滑到該頁，纔會異步作數據加載並更新UI。

這裏就實現相似微信那種效果，整個UI佈局爲：底部用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>
複製代碼

參考文獻

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

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程