本文首发于微信公众号「Android开发之旅」，欢迎关注 ，获取更多技术干货

Jetpack版Wan-Android项目地址：Android Jetpack架构开发组件化应用实战 欢迎star

Flutter版Wan-Android项目地址：Flutter版Wan-Android 欢迎star

背景介绍

上一篇文章我们主要是介绍了Jetpack的由来以及四大组件各包含的组件库。本篇文章我们将来学习架构组件中的Lifecycle组件。Lifecycle组件是帮忙我们管理Activity和Fragment的生命周期，也就是说，当Activity或者Fragment的生命周期发送变化的时候我们可以得到通知。我们通常会在生命周期方法中调用各种方法或者初始化一些组件亦或是在某个生命周期中调用一些回调，这就导致生命周期相关方法代码比较臃肿，且耦合性高，不易维护。

我来来看下官方文档给出的回调例子：

class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {
        // ...
    }

    void start() {
        // connect to system location service
    }

    void stop() {
        // disconnect from system location service
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    @Override
    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, (location) -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        myLocationListener.start();
        // manage other components that need to respond
        // to the activity lifecycle
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

这些代码看起来还不错甚至是我们平常也是这么做的，但是我在响应生命周期的当前状态而进行过多的调用了管理UI和其他组件，这样会在生命周期的方法中书写大量代码，例如onStart()和onStop()，这样就会使代码难以维护。

基于以上种种原因，Lifecycle正式登场了。

Lifecycle介绍

Lifecycle管理生命周期也是观察者模式，其中主要涉及到以下几个类：LifecycleObserver、LifecycleOwner、Lifecycle、State、Event。

• LifecycleObserver：Lifecycle观察者。我们需要自定义类实现LifecycleObserver，通过注解的方式可观察生命周期方法。
• LifecycleOwner：Lifecycle持有者。让Activity或者fragment实现该接口，当生命周期改变是事件会被LifecycleObserver接收到。
• Lifecycle：生命周期抽象类。持有添加和移除监听方法。定义State和Event枚举。
• LifecycleRegistry：Lifecycle的实现类。
• State：当前生命周期所处状态。Lifecycle 将 Activity 的生命周期函数对应成 State .
• Event：当前生命周期变化所对应的事件。State 变化触发 Event 事件，事件会被注册的观察者LifecycleObserver 接收处理。

Event枚举：

 public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }

State枚举：

public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

State和Event的对应关系：

Lifecycle使用

如何项目已经迁移到AndroidX了，那么就不需要额外导包，因为AndroidX已经包含了Jetpack相关组件了​。如果没有迁移，则在build.gradle中配置如下​：

dependencies {
​    def lifecycle_version = "1.1.1"
​
    // ViewModel and LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    // alternatively - just ViewModel // For Kotlin use viewmodel-ktx
    implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" 
    // alternatively - just LiveData
    implementation "android.arch.lifecycle:livedata:$lifecycle_version"
    // alternatively - Lifecycles only (no ViewModel or LiveData).
    // Support library depends on this lightweight import
    implementation "android.arch.lifecycle:runtime:$lifecycle_version"
    // For Kotlin use kapt instead of annotationProcessor
    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" 
    // alternately - if using Java8, use the following instead of compiler
    implementation "android.arch.lifecycle:common-java8:$lifecycle_version"
    // optional - ReactiveStreams support for LiveData
    implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"
    // optional - Test helpers for LiveData
    testImplementation "android.arch.core:core-testing:$lifecycle_version"

​配置完成后我们先定义一个类实现LifecycleObserver：

class MyObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun connectListener() {
        Log.e("MyObserver","==ON_RESUME==")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun disconnectListener() {
        Log.e("MyObserver","==ON_PAUSE==")

    }
}

接受事件是通过注解OnLifecycleEvent来完成的，参数即为上文中的Event枚举。

接下来我们在Activity中添加这个观察者：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        lifecycle.addObserver(MyObserver())

    }
}

这就是最简单的使用，这个时候我们其实已经可以监听到Activity的生命周期变化了。

com.jetpack.jetpackdemo E/MyObserver: ==ON_RESUME==
com.jetpack.jetpackdemo E/MyObserver: ==ON_PAUSE==

这样使用，会不会有个疑问呢？我们在Observer中注册了Event事件，但是在Activity的生命周期方法中并没有指定State状态。这是如何做到关联的呢？在Android Support Library 26.1.0 及其之后的版本，Activity和Fragment已经默认实现了LifecycleOwner接口，所以不需要我们在重新设置。

自定义Lifecycle

当我们有些类没有实现AppCompatActivity的时候我们也想使用Lifecycle，那么就需要自定义了，也就是需要我们自己实现 LifecycleOwner接口。MyObserver类不变，MainActivity类改变如下：

class MainActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycle.addObserver(MyObserver())

    }

    override fun onResume() {
        super.onResume()
        lifecycleRegistry.currentState = Lifecycle.State.RESUMED
    }

    override fun onPause() {
        super.onPause()
        lifecycleRegistry.currentState = Lifecycle.State.DESTROYED
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

这样就是所有的设置必须由我们自己来完成。打印结果还是一样的，如下：

com.jetpack.jetpackdemo E/MyObserver: ==ON_RESUME==
com.jetpack.jetpackdemo E/MyObserver: ==ON_PAUSE==

总结

本文主要是介绍了Lifecycle相关的API以及简单的使用。在实际项目中还是要结合ViewModel和LiveData来使用。通过ViewModel来获取所需数据，并通过观察LiveData对象将数据变化反映到视图中。后续文章我们将继续介绍ViewModel和LiveData的使用。

扫描下方二维码关注公众号，获取更多技术干货。

推荐阅读

还不知道Android Jetpack是什么？你就out了

Jetpack架构组件 — LiveData与ViewModel入坑详解

Android Jetpack架构组件 — Room入坑详解