Android-Fragment的生命周期较详细理解实践

Fragment生命周期看官方图：Fragment | Android Developers

看点原始的东东：

added in API level 11 
Deprecated since API level 28
Fragment
public class Fragment 
extends Object implements ComponentCallbacks2, View.OnCreateContextMenuListener

java.lang.Object
   ↳    android.app.Fragment
Known direct subclasses
DialogFragment, ListFragment, PreferenceFragment, WebViewFragment

都继承了啥，哪些东东继承了Fragment，简单了解下总归还是挺好的。

然后发现

image

这个类过期了，而是有support库的fragment类替代。

Fragment | Android Developers

public class Fragment 
extends Object implements ComponentCallbacks, View.OnCreateContextMenuListener, LifecycleOwner, ViewModelStoreOwner

java.lang.Object
   ↳    android.support.v4.app.Fragment
Known Direct Subclasses
AmbientModeSupport,BrandedSupportFragment,DialogFragment,GuidedStepSupportFragment,HeadersSupportFragment,ListFragment,MediaRouteDiscoveryFragment,OnboardingSupportFragment,PlaybackSupportFragment,PreferenceFragmentCompat,RowsSupportFragment,SearchSupportFragment
Known Indirect Subclasses
AppCompatDialogFragment,BaseSupportFragment,BrowseSupportFragment,DetailsSupportFragment,EditTextPreferenceDialogFragmentCompat,ErrorSupportFragment,ListPreferenceDialogFragmentCompat,MediaRouteChooserDialogFragment,MediaRouteControllerDialogFragment,MultiSelectListPreferenceDialogFragmentCompat,PreferenceDialogFragmentCompat,VerticalGridSupportFragment,VideoSupportFragment

其中support库的fragment的使用区别如下：

The main differences when using this support version instead of the framework version are:

Your activity must extend FragmentActivity
You must call getSupportFragmentManager() to get the FragmentManager

activity必须继承FragmentActivity，必须调用getSupportFragmentManager获取fragment随便管理器FragmentManager.

而过期的Fragment的方式是：

A Fragment is a piece of an application's user interface or behavior
 that can be placed in an Activity. Interaction with fragments is done 
through FragmentManager, which can be obtained via Activity.getFragmentManager() and 
Fragment.getFragmentManager().

Activity、Activity.getFragmentManager()，或者Fragment.getFragmentManager()。区别还是大哟。具体内部，后续再研究了哟。。。

嘿嘿_{不过新版的网址上没有具体单独说fragment生命周期，所以我们还是结合过期的fragment的官方文档看看吧}~~

Lifecycle
Though a Fragment's lifecycle is tied to its owning activity, it has its own wrinkle on the standard activity lifecycle. It includes basic activity lifecycle methods such as onResume(), but also important are methods related to interactions with the activity and UI generation.

The core series of lifecycle methods that are called to bring a fragment up to resumed state (interacting with the user) are:

1.onAttach(Activity) called once the fragment is associated with its activity.
2.onCreate(Bundle) called to do initial creation of the fragment.
3.onCreateView(LayoutInflater, ViewGroup, Bundle) creates and returns the view hierarchy associated with the fragment.
4.onActivityCreated(Bundle) tells the fragment that its activity has completed its own Activity.onCreate().
5.onViewStateRestored(Bundle) tells the fragment that all of the saved state of its view hierarchy has been restored.
6.onStart() makes the fragment visible to the user (based on its containing activity being started).
7.onResume() makes the fragment begin interacting with the user (based on its containing activity being resumed).
As a fragment is no longer being used, it goes through a reverse series of callbacks:

1.onPause() fragment is no longer interacting with the user either because its activity is being paused or a fragment operation is modifying it in the activity.
2.onStop() fragment is no longer visible to the user either because its activity is being stopped or a fragment operation is modifying it in the activity.
3.onDestroyView() allows the fragment to clean up resources associated with its View.
4.onDestroy() called to do final cleanup of the fragment's state.
5.onDetach() called immediately prior to the fragment no longer being associated with its activity.

翻一下：

onAttach(Activity) 一旦fragment和activity关联就被调用.
onCreate(Bundle) fragment初始化创建调用（可以做一些数据的初始化操作，切勿操作视图）.
onCreateView(LayoutInflater, ViewGroup, Bundle) 创建与fragment关联的视图并且返回该视图时调用（也就是平常我们创建布局视图的地方）.
onActivityCreated 告诉fragment，与它管理的activity已经创建完成，此时可以进行fragment与activity的交换操作（比如此时改变activity的视图布局，背景等，一般不太怎么操作，除非遇到特殊需求）Activity.onCreate()
onViewStateRestored(Bundle) 告诉fragment，之前保存的视图结构相关状态以及恢复（一会看下，感觉应该是崩溃重启，或者说休眠返回等....）
onStart() 此时fragment对用户可见 (activity以及启动了)
onResume() 此时碎片可以与用户进行交互操作了(activity以及完成resumed初始化了)

当Fragment不再被使用了：

onPause() fragment不可交互了
onStop() fragment对用户不可见了
onDestroyView() 此时可以进行碎片的视图资源的释放
onDestroy() 碎片状态的最终清理
onDetach() 解除fragment与activity的关联

Android-Fragment的生命周期较详细理解实践 - 还得琢磨琢磨_第1张图片

image

a. setUserVisibleHint oncreateView之前使用, 设置Fragment可见或者不可见时会调用此方法。在该方法里面可以通过调用getUserVisibleHint()获得Fragment的状态是可见还是不可见的，如果可见则进行懒加载（就是不多次进行视图创建，只进行视图的更新）操作。（**关于懒加载后面简单总结一篇入门使用篇 - **fragment结合viewpager）

b. onHiddenChanged 使用add hide() show()方法切换fragment 不会走任何的生命周期无法通过生命周期进行刷新, 这个时候另一个方法就派上用处了我们的主题之一：onHiddenChanged()

 @Override
    public void onHiddenChanged(boolean hidden) {
        super.onHiddenChanged(hidden);

        if (hidden) {   // 不在最前端显示 相当于调用了onPause();

            //做一些事情 你懂得

            return;
        }else{  // 在最前端显示 相当于调用了onResume();
           //数据刷新做一些自己的事情--你懂得
        }
    }

c. onSaveInstanceState 保存当前Fragment的状态。该方法会自动保存Fragment的状态，比如EditText键入的文本，即使Fragment被回收又重新创建，一样能恢复EditText之前键入的文本。 - 与onViewStateRestored相关，后面看能不能复现下

d. onViewCreated onCrateaView执行完成后立即调用，表示视图创建完成并且返回到这里，此时可以获取的view视图对象。比如有时候我们需要保存视图做懒加载处理....

以上有几个疑问？

1.onDestroyView() - > onCreateView()怎么发生的？'

添加到回退栈

Android-Fragment的生命周期较详细理解实践 - 还得琢磨琢磨_第2张图片

image

从栈中退出

image

这样就会知识销毁和重建视图，但是不会从新onCreate，也不会解除和activity的attach关联。

2. onSaveInstanceState - onViewStateRestored的示例 - 编辑框的保存和恢复

 @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        ///< EditText etCon
        //String content = etCon.getText().toString();
        //outState.putString("inputmsg", content);
    }

    @Override
    public void onViewStateRestored(@Nullable Bundle savedInstanceState) {
        super.onViewStateRestored(savedInstanceState);
        if(savedInstanceState != null){
            ///< EditText etCon
            //etCon.setText(savedInstanceState.getString("inputmsg", ""));
        }
    }

3. onHiddenChanged - 有什么场景需要处理 - 下面是页面进行碎片切换时每次都获取个人算力信息（因为我的页面是一个需要实时刷新显示的信息的页面，我们并没有做什么定时器，就是每次切换到该页面我们就信息一次刷新）

  /**
     * 碎片隐藏或显示是否登录的基本状态
     * @note 如果之前由于一些网络等原因未获取到信息，可以切换显示时再尝试请求一次...
     * @param hidden
     */
    @Override
    public void onHiddenChanged(boolean hidden) {
        super.onHiddenChanged(hidden);
        if (hidden) {   ///< 不在最前端界面显示

        } else {        ///< 重新显示到最前端中
            if (!UserInfoControlPresenter.bIsLogined()){
                presenter.setNoneUserBaseInfo();
                return;
            }
            presenter.getUserInfoSuanli();
        }
    }

注意，此时onResume并没有走，如果是在当前碎片页面进行页面跳转，然后回到该页面，此时这个就不是隐藏或者显示，所以此时回调走的是：

    @Override
    public void onResume() {
        super.onResume();
        if (!UserInfoControlPresenter.bIsLogined()){
            presenter.setNoneUserBaseInfo();
            return;
        }
        ///< 修改为每次都刷新
        presenter.getUserInfoSuanli();
    }

所以相当于我们进行了两个地方的处理，保证了个人中心页面的实时刷新.

4. setUserVisibleHint 关于懒加载

直接看个文件吧 LazyBaseFragment.java ，具体懒加载我们后面分析吧...核心就是利用setUserVisibleHint的回调来实现界面的复用和视图的刷新....

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.view.View;

/**
 * Created by dasu on 2016/9/27.
 *
 * Fragment基类，封装了懒加载的实现
 *
 * 1、Viewpager + Fragment情况下，fragment的生命周期因Viewpager的缓存机制而失去了具体意义
 * 该抽象类自定义新的回调方法，当fragment可见状态改变时会触发的回调方法，和 Fragment 第一次可见时会回调的方法
 *
 * @see #onFragmentVisibleChange(boolean)
 * @see #onFragmentFirstVisible()
 */
public abstract class LazyBaseFragment extends BaseFragment {

    private static final String TAG = LazyBaseFragment.class.getSimpleName();

    private boolean isFragmentVisible;
    private boolean isReuseView;
    private boolean isFirstVisible;
    private View rootView;

    //setUserVisibleHint()在Fragment创建时会先被调用一次，传入isVisibleToUser = false
    //如果当前Fragment可见，那么setUserVisibleHint()会再次被调用一次，传入isVisibleToUser = true
    //如果Fragment从可见->不可见，那么setUserVisibleHint()也会被调用，传入isVisibleToUser = false
    //总结：setUserVisibleHint()除了Fragment的可见状态发生变化时会被回调外，在new Fragment()时也会被回调
    //如果我们需要在 Fragment 可见与不可见时干点事，用这个的话就会有多余的回调了，那么就需要重新封装一个
    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        //setUserVisibleHint()有可能在fragment的生命周期外被调用
        if (rootView == null) {
            return;
        }
        if (isFirstVisible && isVisibleToUser) {
            onFragmentFirstVisible();
            isFirstVisible = false;
        }
        if (isVisibleToUser) {
            onFragmentVisibleChange(true);
            isFragmentVisible = true;
            return;
        }
        if (isFragmentVisible) {
            isFragmentVisible = false;
            onFragmentVisibleChange(false);
        }
    }

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

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        //如果setUserVisibleHint()在rootView创建前调用时，那么
        //就等到rootView创建完后才回调onFragmentVisibleChange(true)
        //保证onFragmentVisibleChange()的回调发生在rootView创建完成之后，以便支持ui操作
        if (rootView == null) {
            rootView = view;
            if (getUserVisibleHint()) {
                if (isFirstVisible) {
                    onFragmentFirstVisible();
                    isFirstVisible = false;
                }
                onFragmentVisibleChange(true);
                isFragmentVisible = true;
            }
        }
        super.onViewCreated(isReuseView ? rootView : view, savedInstanceState);
    }

    //    @Override
    //    public void onDestroyView() {
    //        super.onDestroyView();
    //    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        initVariable();
    }

    private void initVariable() {
        isFirstVisible = true;
        isFragmentVisible = false;
        rootView = null;
        isReuseView = true;
    }

    /**
     * 设置是否使用 view 的复用，默认开启
     * view 的复用是指，ViewPager 在销毁和重建 Fragment 时会不断调用 onCreateView() -> onDestroyView()
     * 之间的生命函数，这样可能会出现重复创建 view 的情况，导致界面上显示多个相同的 Fragment
     * view 的复用其实就是指保存第一次创建的 view，后面再 onCreateView() 时直接返回第一次创建的 view
     *
     * @param isReuse
     */
    protected void reuseView(boolean isReuse) {
        isReuseView = isReuse;
    }

    /**
     * 去除setUserVisibleHint()多余的回调场景，保证只有当fragment可见状态发生变化时才回调
     * 回调时机在view创建完后，所以支持ui操作，解决在setUserVisibleHint()里进行ui操作有可能报null异常的问题
     *
     * 可在该回调方法里进行一些ui显示与隐藏，比如加载框的显示和隐藏
     *
     * @param isVisible true  不可见 -> 可见
     *                  false 可见  -> 不可见
     */
    protected abstract void onFragmentVisibleChange(boolean isVisible);

    /**
     * 在fragment首次可见时回调，可在这里进行加载数据，保证只在第一次打开Fragment时才会加载数据，
     * 这样就可以防止每次进入都重复加载数据
     * 该方法会在 onFragmentVisibleChange() 之前调用，所以第一次打开时，可以用一个全局变量表示数据下载状态，
     * 然后在该方法内将状态设置为下载状态，接着去执行下载的任务
     * 最后在 onFragmentVisibleChange() 里根据数据下载状态来控制下载进度ui控件的显示与隐藏
     */
    protected abstract void onFragmentFirstVisible();

    protected boolean isFragmentVisible() {
        return isFragmentVisible;
    }
}

使用的地方, 这样就避免了总是不停销毁和创建视图的问题，当然小白看了很多多碎片的页面，基本上还是冰没有这样做，可能常规的做法还是没什么问题，也不会说很慢呀，很影响体验。或许每次刷新那种还是蛮不错滴哈....：

    @Override
    protected void onFragmentVisibleChange(boolean isVisible) {
        Log.e(TAG, mParam1 + "onFragmentVisibleChange isVisible=" + isVisible);
        if (isVisible) {
            //更新界面数据，如果数据还在下载中，就显示加载框
            //            notifyDataSetChanged();
            //            if (mRefreshState == STATE_REFRESHING) {
            //                mRefreshListener.onRefreshing();
            //            }
            videoAdapter.notifyDataSetChanged();
            advBanner.setImages(bannerListImageUrl)
                    .setDelayTime(3000)
                    .isAutoPlay(true)
                    .start();
        } else {
            //关闭加载框
            //mRefreshListener.onRefreshFinish();
        }
    }

    @Override
    protected void onFragmentFirstVisible() {
        Log.e(TAG, mParam1 + "onFragmentFirstVisible");

        viedoBeanList.clear();
        viedoBeanList.add(new VideoBean());
        viedoBeanList.add(new VideoBean());
        viedoBeanList.add(new VideoBean());
        viedoBeanList.add(new VideoBean());
        viedoBeanList.add(new VideoBean());
        viedoBeanList.add(new VideoBean());
        viedoBeanList.add(new VideoBean());

        bannerListImageUrl.clear();
        bannerListImageUrl.add(R.drawable.umeng_socialize_share_video);
        bannerListImageUrl.add(R.drawable.umeng_socialize_share_video);
        bannerListImageUrl.add(R.drawable.umeng_socialize_share_video);
        bannerListImageUrl.add(R.drawable.umeng_socialize_share_video);
    }

小白平常小白解除最多的也就是onCreateView，onAttach（保存上下文），onDestroyView（销毁资源），onHiddenChanged（隐藏或者显示的情况是否刷新），还有就是setUserVisibleHint 的懒加载处理（其实这个都不怎么用到，因为有些项目没有做懒加载处理），然后就没有特别常用的了。不过我们仔细看过碎片的生命周期以后是时候需要好好考虑下每个回调应该做的事情了，或许一个生命周期里面做貌似也没事，但是毕竟不是最好的方式。

比如onActivityCreated里做碎片操作activity的视图的动作， onViewCreated里面可以拿到视图做一些初始化操作（以往我们的操作都是在onCreateView创建完视图后里面进行initView的初始化操作），这样做改动其实逻辑性会清晰更多了一点点，有木有。所以了解生命周期有助于我们做更好的逻辑，写更优秀些的代码....同时也能解决一些个性化的需求表....

懒加载后面续哈，顺便再次加深哈理解....搞个demo啥的验证哈....

几个参考可以看哈，好不好没关系，努力过了 Fragment 生命周期的详情 [整] Android Fragment 生命周期图

坚持，改掉坏习惯好嘛，宝贝---黄磊

Android-Fragment的生命周期较详细理解实践 - 还得琢磨琢磨

你可能感兴趣的:(Android-Fragment的生命周期较详细理解实践 - 还得琢磨琢磨)