Android 实现LazyFragment

最新推荐文章于 2024-04-16 06:14:40 发布

如果可以003

最新推荐文章于 2024-04-16 06:14:40 发布

阅读量2.2k

点赞数

分类专栏： Android 文章标签：懒加载 Fragment

本文链接：https://blog.csdn.net/xiaozhiwz/article/details/49230597

版权

Android 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

人类的幸福和欢乐在于奋斗，而最有价值的是为了理想而奋斗 ——苏格拉底(我是路人甲)

不管是现在还是过去ViewPager+Fragment实现的App数不甚数，而通常看这些应用基本上都有一个共同点，就是我们滑动到那一页的时候才加载数据（当然用来显示图片的时候，默认使用缓存就好）；说实在的懒加载的Fragment的网上也提到过很多，自己实践了下总是不令人满意；于是自己总结了下并梳理出这篇文章；

Fragment的生命周期

首先我们需要了解Fragment的生命周期,以下是官网盗图

生命周期也算是个老生常谈的问题，Activity的、Service、Fragment的等等…我们总是在想这么多方法怎么才能记得住啊，其实完全不用刻意记，开发一个网络相关的应用自然就明了；详细说明还是建议去官网查看，一般我都是把文档下载到本地离线阅读这样速度比较快（如果你不会翻墙的话）具体地址是docs/guide/components/fragments.html;

ViewPager中Fragment生命周期查看

接下来我们看看在ViewPager中Fragment的生命周期回调

content_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    app:layout_behavior="@string/appbar_scrolling_view_behavior"
    tools:context=".MainActivity"
    tools:showIn="@layout/activity_main">

    <android.support.design.widget.TabLayout
        android:id="@+id/tabLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

    <android.support.v4.view.ViewPager
        android:id="@+id/viewPager"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"/>
</LinearLayout>

很简单就只是一个ViewPager
activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    tools:context=".MainActivity">

    <android.support.design.widget.AppBarLayout
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:theme="@style/AppTheme.AppBarOverlay">

        <android.support.v7.widget.Toolbar
            android:id="@+id/toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            android:background="?attr/colorPrimary"
            app:popupTheme="@style/AppTheme.PopupOverlay"/>

    </android.support.design.widget.AppBarLayout>

    <include layout="@layout/content_main"/>

    <android.support.design.widget.FloatingActionButton
        android:id="@+id/fab"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom|end"
        android:layout_margin="@dimen/fab_margin"
        android:src="@android:drawable/ic_dialog_email"/>

</android.support.design.widget.CoordinatorLayout>

上面的布局看着很复杂，其实都是Android studio自动生成的（这里我也懒得改:)）,只要知道我们的目的是查看Fragment在ViewPager中生命周期的回调即可；

剩下的3个Fragment的布局我就不贴了了，里面只有一个TextView；

OneFragment.java

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

/**
 * Created by Xiaozhi on 2015/11/13.
 */
public class OneFragment extends Fragment {

    private static final String TAG = "OneFragment";

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

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.i(TAG,"onCreate...");
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        Log.i(TAG,"setUserVisibleHint..." + isVisibleToUser);
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        Log.i(TAG,"onCreateView...");
        View v = inflater.inflate(R.layout.fragment_one, container, false);
        return super.onCreateView(inflater, container, savedInstanceState);
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        Log.i(TAG,"onActivityCreated...");
        super.onActivityCreated(savedInstanceState);
    }

    @Override
    public void onResume() {
        super.onResume();
        Log.i(TAG, "onResume...");
    }

    @Override
    public void onPause() {
        super.onPause();
        Log.i(TAG, "onPause...");
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        Log.i(TAG, "onDestroyView...");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "onDestroy...");
    }
}

TwoFragment.java同上类似
ThreeFragment.java同上类似

MainActivity.java

import android.os.Bundle;
import android.support.design.widget.TabLayout;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentPagerAdapter;
import android.support.v4.view.ViewPager;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;

import java.util.ArrayList;
import java.util.List;

import butterknife.Bind;
import butterknife.ButterKnife;

public class MainActivity extends AppCompatActivity {

    private List<Fragment> mFragments = new ArrayList<>();

    @Bind(R.id.viewPager)
    ViewPager mViewPager;

    @Bind(R.id.tabLayout)
    TabLayout mTabLayout;

    private FragmentPagerAdapter mFragmentPagerAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        mFragments.add(OneFragment.newInstance());
        mFragments.add(TwoFragment.newInstance());
        mFragments.add(ThreeFragment.newInstance());
        mFragmentPagerAdapter = new FragmentPagerAdapter(getSupportFragmentManager()) {
            @Override
            public Fragment getItem(int position) {
                return mFragments.get(position);
            }

            @Override
            public int getCount() {
                return mFragments.size();
            }

            @Override
            public CharSequence getPageTitle(int position) {
                return "Tap" + position;
            }
        };
        mViewPager.setAdapter(mFragmentPagerAdapter);
        mTabLayout.setupWithViewPager(mViewPager);
    }

}

我们运行程序查看OneFragment的生命周期日志（ViewPager默认显示第一个吗当然是看OneFragment喽，嘿嘿）

OneFragment第一次加载并可见的生命周期

初次加载OneFragment生命周期走向：

setUserVisibleHint回调了两次，当他可见的时候返回true
视图创建及完成的方法都是在setUserVisibleHint之后调用

TwoFragment预加载生命周期

基本上和OneFragment生命周期类似，只是少调用了一次 setUserVisibleHint
预加载除了不可见外，其他的和可见的视图生命周期一样；也就说只要我们在生命周期内做的复杂操作都已经完成了；

ThreeFragment生命周期

此时ViewPager只加载看见视图相邻的页面，所以他的生命周期还未调用

OneFragment不可见（视图未被销毁）

当他不可见时只是回调了setUserVisibleHint方法，并置为false

TwoFragment可见（视图已创建好）

当他可见时也只是回调了setUserVisibleHint方法，并置为true

ThreeFragment预加载

同上，略。。。

OneFragment视图销毁

视图销毁时我们调用了onDestroyView方法，也就是说我们再次可见时还得从新创建视图层；
值得庆幸的是视图层虽然销毁了，但是数据层也就是Fragment实例以及它的属性变量等等都是存在的而且没有变，这也就保证了我们在视图重新创建后可以使用之前保存的数据（网络获取的）来填充视图而不用重新读取；

TwoFragment不可见（视图未被销毁）

同上，略。。。

ThreeFragment预加载

同上，略。。。

OneFragment视图重新创建

我们由ThreeFragment直接跳转到OneFragment生命周期如下：

除了onCreate未被调用外，其余的生命周期都走了一遍；也由此可得出结论，Fragment的销毁只是销毁了视图层并不是Fragment实例，也就是说onCreate在整个生命周期只调用一次，其余生命周期方法会重复的多次调用（依情况而定）；

抽象接口

以上我们基本上把每种情况的生命周期都列了一遍，可以分析得出以下结论：

视图真正可见的关键是setUserVisibleHint回调方法，当他为true时Fragment才可见
setUserVisibleHint方法的回调往往要先于视图创建的方法，如果此时我们在该方法中进行视图操作，很显然我们会得到NullPointerException；

以上两点我们抽象出以下接口：

    /**
     * initialized data but view is not initialized
     * 通常在onCreate中回调，用于接受参数或者初始化数据等
     */
    protected abstract void initData();

    /**
     * when view created for the first time,we can set data on the View
     * 视图创建好后，并且数据已经加载过调用该方法给视图设置数据
     */
    protected abstract void initViewData();

    /**
     * get LayoutId
     * @return
     */
    public abstract int getLayoutId();

    /**
     * when fragment is visible for the first time, here we can do something Time-consuming operation like network access
     * 当Fragment第一次可见时回调（视图也已经创建好），我们可以在这里进行耗时操作（网络访问）
     */
    protected abstract void onFirstUserVisible();

    /**
     * this method like the fragment's lifecycle method onResume()
     * 视图可见调用，相当于onResume
     */
    protected abstract void onUserVisible();

    /**
     * when fragment is invisible for the first time
     */
    private void onFirstUserInvisible() {
    }

    /**
     * this method like the fragment's lifecycle method onPause()
     * 视图不可见调用，相当于onPause
     */
    protected abstract void onUserInvisible();

在合适的时机调用合适的接口

直接上代码了

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import butterknife.ButterKnife;

/**
 * Created by Xiaozhi on 2015/11/13.
 */
public abstract class BaseLazyFragment extends Fragment {

    View v;

    /** 第一次可见的标识 */
    private boolean isFirstVisible = true;
    /** 第一次不可见标识 */
    private boolean isFirstInvisible = true;
    /** 数据是否加载完成，由具体的子类来维护 */
    protected boolean isLoaded = false;
    /** 视图创建完成标识 */
    private boolean isPrepared;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initData();
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        // 我们只在视图创建完成后，调用视图是否可见的方法
        if (isPrepared) {
            if (isVisibleToUser) {
                isFirstVisible();
            } else {
                isFirstInvisible();
            }
        }
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        if (getLayoutId() != 0) {
            v = inflater.inflate(getLayoutId(), container, false);
        } else {
            v = super.onCreateView(inflater, container, savedInstanceState);
        }
        return v;
    }

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        ButterKnife.bind(this, v);
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        // 视图准备完成
        isPrepared = true;
        // 视图是否可见
        isVisibleToUser();
        // 初始化视图数据
        if (isLoaded()) {
            initViewData();
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        if (getUserVisibleHint()) {
            onUserVisible();
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        if (getUserVisibleHint()) {
            onUserInvisible();
        }
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        ButterKnife.unbind(this);
        // 视图销毁后将isPrepared重置
        isPrepared = false;
    }

    private void isVisibleToUser() {
        if (getUserVisibleHint()) {
            isFirstVisible();
        }
    }

    private void isFirstVisible() {
        if (isFirstVisible) {
            isFirstVisible = false;
            onFirstUserVisible();
        } else {
            onUserVisible();
        }
    }

    private void isFirstInvisible() {
        if (isFirstInvisible) {
            isFirstInvisible = false;
            onFirstUserInvisible();
        } else {
            onUserInvisible();
        }
    }

    private boolean isLoaded() {
        return isLoaded;
    }

    public void loaded() {
        isLoaded = true;
    }

    /**
     * initialized data but view is not initialized
     */
    protected abstract void initData();

    /**
     * when view created for the first time,we can set data on the View
     */
    protected abstract void initViewData();

    /**
     * get LayoutId
     * @return
     */
    public abstract int getLayoutId();

    /**
     * when fragment is visible for the first time, here we can do something Time-consuming operation like network access
     */
    protected abstract void onFirstUserVisible();

    /**
     * this method like the fragment's lifecycle method onResume()
     */
    protected abstract void onUserVisible();

    /**
     * when fragment is invisible for the first time
     */
    private void onFirstUserInvisible() {
    }

    /**
     * this method like the fragment's lifecycle method onPause()
     */
    protected abstract void onUserInvisible();
}

isPrepared的状态在onActivityCreated中改变，一定要记得在onDestroyView方法中恢复，因为Fragment在与当前显示的页面不相邻时都会被销毁视图层，以防止我们在判断是否创建了视图时视图还未重新创建的bug；
上面的具体调用我已经加了注释，在这我也不多加解释了

Demo

该示例图我是用网络访问加载三个页面，很简单相信大家根据这几个生命周期也能完美实现了；

最后

说实在的ViewPager加Fragment的组合他的生命周期还是比较复杂的（我自己弄的时候也时常被绕晕），主要因为各种情况太多而且上面我也没有把所有的情况都讨论；当然其他情况也大同小异只是有略微的差别；其实上面我们还可以加入出错的接口就是加载出错是的回调和initViewData()对应，当然也可以在子类中自己维护；

可能会有人说博主我的setUserVisibleHint方法怎么没有回调啊，你这不骗人吗；确实通常setUserVisibleHint都是由外部组件来调用；其实我们上面使用的FragmentPagerAdapter才是用来主动调用Fragment的setUserVisibleHint方法的；这也就解释了我们直接在Activity中填充为啥不调用呢:)；

FragmentPagerAdapter源码

    ...
    @Override
    public Object instantiateItem(ViewGroup container, int position) {
        if (mCurTransaction == null) {
            mCurTransaction = mFragmentManager.beginTransaction();
        }

        final long itemId = getItemId(position);

        // Do we already have this fragment?
        String name = makeFragmentName(container.getId(), itemId);
        Fragment fragment = mFragmentManager.findFragmentByTag(name);
        if (fragment != null) {
            if (DEBUG) Log.v(TAG, "Attaching item #" + itemId + ": f=" + fragment);
            mCurTransaction.attach(fragment);
        } else {
            fragment = getItem(position);
            if (DEBUG) Log.v(TAG, "Adding item #" + itemId + ": f=" + fragment);
            mCurTransaction.add(container.getId(), fragment,
                    makeFragmentName(container.getId(), itemId));
        }
        if (fragment != mCurrentPrimaryItem) {
            fragment.setMenuVisibility(false);
            // 主动调用，并将它设置为false
            fragment.setUserVisibleHint(false);
        }

        return fragment;
    }

    @Override
    public void setPrimaryItem(ViewGroup container, int position, Object object) {
        Fragment fragment = (Fragment)object;
        if (fragment != mCurrentPrimaryItem) {
            if (mCurrentPrimaryItem != null) {
                mCurrentPrimaryItem.setMenuVisibility(false);
                // 主动调用
                mCurrentPrimaryItem.setUserVisibleHint(false);
            }
            if (fragment != null) {
                fragment.setMenuVisibility(true);
                // 主动调用，并将它设置为true
                fragment.setUserVisibleHint(true);
            }
            mCurrentPrimaryItem = fragment;
        }
    }