Lifycycle(AAC) 使用详解

最新推荐文章于 2020-08-27 15:57:47 发布

P.TAN

最新推荐文章于 2020-08-27 15:57:47 发布

阅读量365

点赞数

分类专栏： android

原文链接：https://blog.csdn.net/gdutxiaoxu/article/details/86660746

版权

android 专栏收录该内容

221 篇文章 1 订阅

订阅专栏

Lifycycle 其实是用观察者模式实现的，当 Activity 生命周期变化的时候，通知相应的 Observers 即观察者

代码很简单：

//1、继承 AppCompatActivity
//2、订阅 状态变化 addObserver
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        //Lifecycle可以同时发送事件给多个下游，这里有两个下游观察者
        getLifecycle().addObserver(new MyObserver());
        //GenericLifecycleObserver 虽然被限制了使用范围，报红，但还是可以用
        //DefaultLifecycleObserver 要 minSdkVersion 》=24 才可以使用
        getLifecycle().addObserver(new GenericLifecycleObserver() {
            @Override
            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
                Log.w(TAG, "onStateChanged: event =" + event+""+ ",thread is :"+ Thread.currentThread().getName());
            }
        });

       ...

    }
}

 onCreate(),thread is :main
 当前生命周期状态=CREATED
 onStateChanged: event =ON_CREATE,thread is :main
 onStart(),thread is :main
 当前生命周期状态=STARTED
 onStateChanged: event =ON_START,thread is :main
 onResume(),thread is :main
 当前生命周期状态=RESUMED
 onStateChanged: event =ON_RESUME,thread is :main
 onChanged: networkInfo=[type: WIFI[], state: CONNECTED/CONNECTED, reason: (unspecified), extra: "mobile3", failover: false, available: true, roaming: false, metered: false]
 onStateChanged: event =ON_PAUSE,thread is :main
 onPause(),thread is :main
 当前生命周期状态=STARTED
 onStateChanged: event =ON_STOP,thread is :main
 onStop(),thread is :main
 当前生命周期状态=CREATED
 onStateChanged: event =ON_DESTROY,thread is :main
 onDestroy() ,thread is :main
 当前生命周期状态=DESTROYED

event ？当前生命周期状态=CREATED？ getLifecycle？？这些是什么鬼，不急，先看两个基本概念

一、几个重要的类和接口。（粗粗看一下就行，一看代码就会用的）

Lifecycle
Lifecycle是一个持有组件生命周期状态（如Activity或Fragment）的信息的类，并允许其他对象观察此状态。
Event ：从框架和Lifecycle类派发的生命周期事件。这些事件映射到活动和片段中的回调事件。
State ：由Lifecycle对象跟踪的组件的当前状态。
LifecycleOwner （重要）Lifecycle持有者
实现该接口的类持有生命周期(Lifecycle对象)，该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。
LifecycleObserver（重要）Lifecycle观察者
实现该接口的类，通过注解的方式，可以通过被LifecycleOwner类的addObserver(LifecycleObserver o)方法注册,被注册后，LifecycleObserver便可以观察到LifecycleOwner的生命周期事件。

二、Lifecycle 主要用 State 和 Event 这两个枚举类来表达 Activity/Fragment 的生命周期和状态. LifecycleRegistry 是它的主要实现类,用于分发生命周期的变化.

State 和 Event 之间的关系用下图表示:

三、Lifycycle 的使用步骤

1、引入相关的依赖包
Lifecycle 已经是稳定版，它包含在 support library 26.1.0 及之后的依赖包中，如果我们的项目基于这些依赖包，那么不需要额外的引用。

// alternatively, just ViewModel
implementation "android.arch.lifecycle:viewmodel:1.1.0"
// alternatively, just LiveData
implementation "android.arch.lifecycle:livedata:1.1.0"
def lifecycle_version = "1.1.0"
// ViewModel and LiveData
implementation "android.arch.lifecycle:extensions:$lifecycle_version"
//使用这些类，要引入下面GenericLifecycleObserver，FullLifecycleObserver，DefaultLifecycleObserver
implementation "android.arch.lifecycle:common-java8:$lifecycle_version"

2、support library 26.1.0 之后，且继承 FragmentActivity（AppCompatActivity已经继承FragmentActivity），那么我们直接调用 getLifecycle().addObserver 方法即可，当 Activity 的生命周期变化的时候，将会回调 onStateChanged 的方法，状态分别是一一对应的。（请看文章开头的例子）

addObserver的使用

实现DefultLifecyceObserver接口，然后重写里面生命周期方法；
直接实现LifecycleObserver接口，然后通过注解的方式来接收生命周期的变化；

Lifecycle.java文档中是建议使用第一种方式，因为文档中说明了，随着Java8成为主流，注解的方式会被弃用。DefaultLifecycleObserver是需要另外声明的java8 比如下面
GenericLifecycleObserver，FullLifecycleObserver，DefaultLifecycleObserver 这三个接口都是直接或者间接继承的LifecycleObserver

 // 如果使用的是java 8要显示声明如下的
def lifecycle_version = "1.1.1"
implementation "android.arch.lifecycle:common-java8:$lifecycle_version"

这是DefultLifecyceObserver的代码，注意注释，注释写明了每个方法调用的时机

时机：

onCreate onStart onResume 都是 after
This method will be called after the {@link LifecycleOwner}'s {@code onCreate}
onPause onStop onDestroy 都是  before
This method will be called before the {@link LifecycleOwner}'s {@code onPause} method

package android.arch.lifecycle;

import android.support.annotation.NonNull;

/**
 * Callback interface for listening to {@link LifecycleOwner} state changes.
 * <p>
 * If you use Java 8 language, <b>always</b> prefer it over annotations.
 */
@SuppressWarnings("unused")
public interface DefaultLifecycleObserver extends FullLifecycleObserver {

    /**
     * Notifies that {@code ON_CREATE} event occurred.
     * <p>
     * This method will be called after the {@link LifecycleOwner}'s {@code onCreate}
     * method returns.
     *
     * @param owner the component, whose state was changed
     */
    @Override
    default void onCreate(@NonNull LifecycleOwner owner) {
    }

    /**
     * Notifies that {@code ON_START} event occurred.
     * <p>
     * This method will be called after the {@link LifecycleOwner}'s {@code onStart} method returns.
     *
     * @param owner the component, whose state was changed
     */
    @Override
    default void onStart(@NonNull LifecycleOwner owner) {
    }

    /**
     * Notifies that {@code ON_RESUME} event occurred.
     * <p>
     * This method will be called after the {@link LifecycleOwner}'s {@code onResume}
     * method returns.
     *
     * @param owner the component, whose state was changed
     */
    @Override
    default void onResume(@NonNull LifecycleOwner owner) {
    }

    /**
     * Notifies that {@code ON_PAUSE} event occurred.
     * <p>
     * This method will be called before the {@link LifecycleOwner}'s {@code onPause} method
     * is called.
     *
     * @param owner the component, whose state was changed
     */
    @Override
    default void onPause(@NonNull LifecycleOwner owner) {
    }

    /**
     * Notifies that {@code ON_STOP} event occurred.
     * <p>
     * This method will be called before the {@link LifecycleOwner}'s {@code onStop} method
     * is called.
     *
     * @param owner the component, whose state was changed
     */
    @Override
    default void onStop(@NonNull LifecycleOwner owner) {
    }

    /**
     * Notifies that {@code ON_DESTROY} event occurred.
     * <p>
     * This method will be called before the {@link LifecycleOwner}'s {@code onStop} method
     * is called.
     *
     * @param owner the component, whose state was changed
     */
    @Override
    default void onDestroy(@NonNull LifecycleOwner owner) {
    }
}

3、要保证在Activity或者Fragment的有效生命周期内进行的操作，所以必须判断，当前lifecycle的状态是否至少是CREATED状态，避免Activity或者fragment销毁了以后，回调或者网络请求才回来，此时做一些操作会导致异常。

添加以下代码，就是我们把lifecycle对象传给观察者，让它自己去判断回调后的代码，保证至少是CREATED状态

 private Lifecycle lifecycle;
   public MyObserver(Lifecycle lifecycle) {
        this.lifecycle = lifecycle;
    }
//然后再相应的回调方法中使用下面代码判断，保证数据回调回来，当前activity是存在的
    if (lifecycle.getCurrentState().isAtLeast(CREATED)) {
            //这里只是示例，不一定是CREATED
    }

4、Lifecycle 实战例子：

MediaCompoment 在 Activity ondestroy 的时候，我们需要销毁一些资源，用传统的方法，我们需要在 Activity onDestroy 的时候手动调用 onDestroy 方法。这样会存在一个问题，调用者必须知道比较清楚得知道 MediaCompoment 的设计，否则可能会忘记调用 onDestroy 的方法。

那有没有一种方法，当 Activity 生命周期变化的时候，MediaCompoment 自身能够检测到 Activity 的生命周期变化，从而做相应的处理。

答案当然是有的，使用 lifycycle。（LifecycleOwner是lifycycle的拥有者）

public class MediaCompoment {
    private static final String TAG = "MediaCompoment";

    private final LifecycleOwner mLifecycleOwner;

    public MediaCompoment(LifecycleOwner lifecycleOwner) {
        mLifecycleOwner = lifecycleOwner;
        mLifecycleOwner.getLifecycle().addObserver(new GenericLifecycleObserver() {
            @Override
            public void onStateChanged(LifecycleOwner source, final Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_CREATE) {
                    onCreate();
                } else if (event == Lifecycle.Event.ON_START) {
                    onStart();
                } else if (event == Lifecycle.Event.ON_RESUME) {
                    onResume();
                } else if (event == Lifecycle.Event.ON_PAUSE) {
                    onPause();
                } else if (event == Lifecycle.Event.ON_STOP) {
                    onStop();
                } else if (event == Lifecycle.Event.ON_DESTROY) {
                    onDestroy();
                }
            }
        });
    }

    public void onCreate() {
        Log.d(TAG, "onCreate:");
    }

    public void onStart() {
        Log.d(TAG, "onStart:");
    }

    public void onResume() {
        Log.d(TAG, "onResume:");
    }

    public void onPause() {
        Log.d(TAG, "onPause:");
    }

    public void onStop() {
        Log.d(TAG, "onStop:");
    }

    public void onDestroy() {
        Log.d(TAG, "onDestroy:");
    }
}

参与文章

一、Android lifecycle 使用详解

二、Android 架构组件之 LifeCycle详解

P.TAN

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Lifycycle(AAC) 使用详解

Lifycycle 其实是用观察者模式实现的，当 Activity 生命周期变化的时候，通知相应的 Observers 即观察者代码很简单：//1、继承 AppCompatActivity//2、订阅状态变化 addObserverpublic class MainActivity extends AppCompatActivity { @Override pro...
复制链接

扫一扫

专栏目录