前言

本篇文章我们将来学习 Android Jetpack 架构组件中的 Lifecycle 组件。Lifecycle 组件是帮忙我们管理 Activity 和Fragment 的生命周期，也就是说，当 Activity 或者 Fragment 的生命周期发生变化的时候我们可以得到通知。我们通常会在生命周期方法中调用各种方法，这就导致生命周期相关方法代码比较臃肿，且耦合性高，不易维护。

1. 为什么需要Lifecycle

在应用开发中，处理 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
    }
}

这些代码看起来还不错甚至是我们平常也是这么做的，但是实际开发中可能会有多个组件在 Activity 的生命周期中进行回调，这样 Activity 的生命周期的方法中可能就需要放大量的代码，这就使得它们难以维护。

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

2. 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 接收处理。

3. 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"
 }

特别说明：本文所使用的是AndroidX中的Jetpack组件。

1. 我们先定义一个类 MyObserver 实现 LifecycleObserver，说明MyObserver成为了一个Lifecycle的观察者，代码如下所示：

   public class MyObserver implements LifecycleObserver {
       @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
       public void connectListener() {
           Log.e("MyObserver", "==ON_RESUME==");
       }
   
       @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
       public void disconnectListener() {
           Log.e("MyObserver", "==ON_PAUSE==");
       }
   }
   

2. 接下来在 Activity 中添加这个观察者，代码如下所示：

public class MainActivity extends AppCompatActivity {

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

        Lifecycle lifecycle = getLifecycle(); // ... 1
        lifecycle.addObserver(new MyObserver());
    }
}

将 MyObserver 添加到 LifecycleOwner 中。LifecycleOwner 是一个接口，其内部只有一个方法 getLifecycle()，getLifecycle 方法用于获取 Lifecycle，这样就可以将 MyObserver 添加到 Lifecycle 中，当 Lifecycle 的生命周期发生变化时，MyObserver 就可以感知到。

这就是最简单的使用，这个时候我们其实已经可以监听到Activity的生命周期变化了，运行之后运行结果如下所示:

这样使用，会不会有个疑问呢？我们在 Observer 中注册了Event事件，但是在 Activity 的生命周期方法中并没有指定 State 状态。这是如何做到关联的呢？因为在AndroidX中，AppCompatActivity 和 Fragment 已经默认实现了 LifecycleOwner 接口，所以在注释1处可以直接使用 getLifecycle 方法获取 Lifecycle 对象，这样 MyObserver就可以观察 MainActivity 的生命周期变化了，LifecycleOwner 可以理解为被观察者，MainActivity 默认实现了LifecycleOwner 接口，也就是说 MainActivity 是被观察者。

4. 自定义Lifecycle

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

public class MainActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;

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

        lifecycleRegistry = new LifecycleRegistry(this);

        Lifecycle lifecycle = getLifecycle();
        lifecycle.addObserver(new MyObserver());
    }

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

    @Override
    protected void onResume() {
        super.onResume();
        lifecycleRegistry.setCurrentState(Lifecycle.State.RESUMED);
    }

    @Override
    protected void onPause() {
        lifecycleRegistry.setCurrentState(Lifecycle.State.DESTROYED);
        super.onPause();
    }
}

运行结果和直接继承 AppCompatActivity 一样。

总结

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

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