Android 生命周期组件 Lifecycle 使用详解

前言

2018 年的 Google I/O 大会上，Google 发布了 Android Jetpack，并称其为下一代的 Android 组件，旨在帮助开发者加快应用开发速度。准确来说，Jetpack 是一系列 Android 软件组件的集合，它包括基础组件、架构组件、行为组件、界面组件。其中的 Android Architecture Components 指的就是这里的 “架构组件”。

Android Architecture Components 是 Google 推荐的一个构建 APP 的应用架构，它包含了一些列架构相关组件。而本篇文章咱们要介绍的 Lifecycle 就是其中的一个与生命周期相关的库，同时，Lifecycle 也跟 LiveData 和 ViewModel 两个库紧密联系，想要搞懂后二者，就必须先搞懂它。

具体各组件之间的关系，以及各自在 Jetpack 中的地位，能够参见下面两幅来源于官网的图片。

Lifecycle 的做用

Lifecycle 是具备生命周期感知能力的组件，也就是说，咱们能在 Activity 或者 Fragment 的生命周期发生变化的时候获得通知。咱们每每会在 Activity 的各类生命中周期方法里执行特定的方法，好比，进行广播的注册和解绑、Eventbus 的注册和解绑等:

public class TestActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);
    }

    @Override
    protected void onStart() {
        super.onStart();
        EventBus.getDefault().register(this);
    }

    @Override
    protected void onDestroy() {
        EventBus.getDefault().unregister(this);
        super.onDestroy();
    }
}

若是咱们把不少这种须要跟生命周期相关的逻辑代码都直接放在 Activity 的生命周期方法中，Activity 将会变得难以维护。经过 Lifecycle，咱们就能经过把这些逻辑抽离出来，进而避免这种问题。由于本质上咱们须要的只是 Activity 或者 Fragment 的生命周期发生改变的时候能通知到咱们，以便咱们在对应生命周期中执行对应的方法。

Lifecycle 的基本使用

2.0、 导入 Lifecycle 依赖

Lifecycle 被包含在 support library 26.1.0 及以后的依赖包中，若是咱们的项目依赖的支持库版本在 26.1.0及以上，那么不须要额外导入 Lifecycle 库，本篇例子中使用的支持库是 28.0.0 ：

implementation 'com.android.support:appcompat-v7:28.0.0'

若是支持库版本小于 26.1.0 ，就须要单独导入 Lifecycle 库 ：

implementation "android.arch.lifecycle:runtime:1.1.1"

固然，若是项目已经迁移到了 AndroidX，可使用下面的方式引入 ：

implementation "androidx.lifecycle:lifecycle-runtime:2.0.0"

仍是建议你们尝试尽快把项目迁移为 AndroidX，由于不少更新，会最早在 AndroidX 中发布，逐渐摆脱传统的support包。好比这里要讲的 Lifecycle 在 AndroidX 中已经升级到了 2.x 版本，而支持库中仍是 1.x 版本。

鉴于支持库通常都在 26.1.0 以上，而且尚有大部分用户未迁移到AndroidX，在本篇文章中，咱们使用 support library 28.0.0 中默认包含的 Lifecycle 库。咱们在项目的 app 目录下的 build.gradle 文件中添加如下依赖：

implementation 'com.android.support:appcompat-v7:28.0.0'

以 support library 版本在 26.1.0 及以上为前提，这里咱们分两种状况来说。一种是咱们建立的Activity 继承自 AppCompatActivity(以Activity 为例，Fragment相似)，另外一种是建立的 Activity 继承自普通的 Activity，而非 AppCompatActivity。

这里要先说一点， Lifecycle 的实现机制是观察者模式，意识到这点，再讲它的使用过程及原理就比较容易理解了。

总体流程：

1. 构建一个 Lifecycle 对象（经过一个实现了 LifecycleOwner 接口的对象的 getLifecycle()方法返回），这个对象就是一个被观察者，具备生命周期感知能力
2. 构建一个 LifecycleObserver 对象，它对指定的 Lifecycle 对象进行监听
3. 经过将 Lifecycle 对象的 addObserver(...) 方法，将 Lifecycle 对象和 LifecycleObserver 对象进行绑定

2.一、 方式一：继承自 AppCompatActivity

首先，咱们建立一个 MyObserver.java 类，让它实现 LifecycleObserver 接口( LifecycleObserver 接口是一个空接口，主要是给注解处理器使用)，以下：

public class MyObserver implements LifecycleObserver {

    private static final String TAG = "MyObserver";

    // 使用注解  @OnLifecycleEvent 来代表该方法须要监听指定的生命周期事件
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void connectListener() {
//        ...
        Log.d(TAG, "connectListener:  --------   onResume" );
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void disconnectListener() {
//        ...
        Log.d(TAG, "disconnectListener: -------   onPause");
    }
}

能够看到，咱们经过在方法上使用@OnLifecycleEvent 注解使得该方法具备了生命周期感知能力。括号里面的参数，代表须要监听的是什么生命周期事件。Lifecycle 主要就是经过 Event 和 State 这两个枚举类来跟踪所关联组件的生命周期状态。具体的 Event 和 State 之间的转换关系，能够参照下图：

接下来，让咱们的 Activity 继承自 AppCompatActivity，而后在 onCreate(...) 方法中经过getLifecycle().addObserver(new MyObserver())完成 Lifecycle 和LifecycleObserver 的绑定。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 就只须要这一行代码，简洁吧
        getLifecycle().addObserver(new MyObserver());
    }
}

而后咱们就能够运行下程序，跑起来以后按 Home 键或者按返回键进行操做。能看到，随着生命周期的变化，MyObserver() 中定义的方法在控制台中也被正确地打印了出来。

是否是以为特别简单。

但之因此绝不费力，是由于有人替你“负重前行”。在 support library 26.1.0 及之后的支持库中，AppCompatActivity 的祖先类 SupportActivity已经默认实现了 LifecycleOwner 接口，经过其 getLifecycle() 方法能够直接返回一个 Lifecycle 对象。以后咱们就能够经过该对象的 addObserver(...) 方法将 Lifecycle 跟指定的 LifecycleObserver 进行绑定。

2.二、 方式二：继承自普通的 Activity

首先，咱们仍然须要像上面的方式，来建立一个MyObserver 对象。

此次咱们建立一个继承自普通的 Activity 的 Activity ，那天然没法直接使用 getLifecycle() 方法来获取 Lifecycle 。没法直接使用，那咱们可否模仿 AppCompatActivity的实现，来本身建立 Lifecycle 对象呢？固然能够。这时候，咱们就须要本身实现LifecycleOwner接口，并在具体的生命周期下经过 LifecycleRegistry 的 markState(...)方法来主动进行事件的分发。请看下面改造过的 MainActivity.java 代码 ：

public class MainActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry mLifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mLifecycleRegistry = new LifecycleRegistry(this);
        getLifecycle().addObserver(new MyObserver());
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    protected void onResume() {
        super.onResume();
        mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
    }

    @Override
    protected void onPause() {
        super.onPause();
        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

而后运行代码，发现结果和上面的彻底同样。

能够看到，MainActivity实现了LifecycleOwner接口（实现该接口的对象，便是 Lifecycle 的持有者），并在其 getLifecycle( ) 方法中返回了一个 LifecycleRegistry对象，而 LifecycleRegistry 是 Lifecycle 的实现类，能处理多个 Observer，咱们自定义 LifecycleOwner的时候就能够直接使用它。其余使用方式，则彻底相同。

为了让使用更加方便灵活，Lifecycle 还提供了查询当前组件所处的生命周期状态的方法：

lifecycle.getCurrentState().isAtLeast(STARTED)

总结

1. 实现了 LifecycleObserver 接口的类能够和实现了 LifecycleOwner 接口的类无缝工做，由于 LifecycleOwner 能够提供一个 Lifecycle 对象，而 LifecycleObserver 就正须要对这个 Lifecycle 对象进行监听呢。
2. LifecycleOwner 是从特定的类（好比 Activity 或者 Fragment 等）中抽象出来的Lifecycle 的持有者。
3. LifecycleRegistry 是 Lifecycle 的实现类，用于注册和反注册那些须要监听当前组件生命周期的 LifecycleObserver

注意

从 1.0.0-rc1 版本的 Lifecycle 包开始，当 Activity 的 onSaveInstanceState() 方法调用结束以后，Lifecycle 将马上被标记为 CREATED 和 ON_STOP ，而不是等 onStop() 方法调用结束。这点和 API level 26 或者更低版本上 Activity 的生命周期的调用顺序并不匹配，须要稍加注意。有具体需求的能够进一步查阅相关文档。

更多最新消息，欢迎关注个人公众号获取：