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教程