阅读 689

Jetpack 之 LifeCycle 组件使用详解

一、LifeCycle 简介

LifeCycle 是一个可以感知宿主生命周期变化的组件。常见的宿主包括 Activity/Fragment、Service 和 Application。LifeCycle 会持有宿主的生命周期状态的信息,当宿主生命周期发生变化时,会通知监听宿主的观察者。

LifeCycle 的出现主要是为了解决: 系统组件的生命周期与普通组件之间的耦合性。

  • 系统组件指:Activity/Fragment、Service 和 Application。
  • 普通组件指:将代码按照功能或者作用封装成的组件。

LifeCycle 的原理

哪些情况下,系统组件的生命周期会和普通组件的生命周期耦合在一起呢?

举个栗子:

在 58 部落业务中有视频播放的业务需求。我们需要在 Activity 中对视频播放组件进行初始化,在 onPause() 方法中停止视频的播放,在 onDestroy() 方法中对视频播放组件以及一些资源进行回收。这样的做法非常繁琐,会让页面与组件之间的耦合度变高。

对于这类问题,完全可以使用 LifeCycle 来解决。它不仅降低了模块之间的耦合度,还降低了内存泄露发生的可能性

二、LifeCycle 的使用

Jetpack 为我们提供了两个接口:

被观察者:LifecycleOwner

观察者:LifecycleObserver

被监听的系统组件需要去实现 LifecycleOwner 接口,观察者需要实现 LifecycleObserver 接口。

(一)使用场景1:使用 LifeCycle 解耦页面与组件

(1)解耦 Activity

第一步:添加依赖

implementation 'androidx.appcompat:appcompat:1.2.0'
复制代码

在 AndroidX 里面 ComponentActivity 已经默认实现了 LifecycleOwner 接口。如果项目没有迁移到 AndroidX,还是用的 Support 库,新版本的 SDK 也通过 SupportActivity 实现了 LifecycleOwner 接口。

在 LifecycleOwner 接口中,只有一个 getLifecycle 方法。

第二步:实现观察者

如果是想监听某个 Activity 的生命周期,需要我们做的就是自定义组件,实现 LifecycleObserver 接口即可,该接口没有接口方法,不需要任何具体的实现。

比如以刚刚的视频播放为例:

  1. 创建一个 MyVideoPlayListener 类,实现 LifecycleObserver 接口,与视频播放相关的逻辑全在这个类里面完成。对于组件里面需要在 Activity 生命周期变化时得到通知的方法,用 @OnLifecycleEvent(Lifecycle.Event.ON_XXX) 注解进行标记,这样当 Activity 生命周期发生变化时,被标记过的方法便会被自动调用。
public class MyVideoPlayListener implements LifecycleObserver {
    private static String TAG = "MyVideoPlayListener";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void initVideo(){
        Log.d(TAG,"initVideo");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private void startPlay(){
        Log.d(TAG,"startPlay");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private void pausePlay(){
        Log.d(TAG,"pausePlay");
    }
}
复制代码

2.在 MainActivity 中对 MyVideoPlayListener 进行引用即可。

public class MainActivity extends AppCompatActivity {

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

        MyVideoPlayListener listener = new MyVideoPlayListener();
        getLifecycle().addObserver(listener);
    }
}
复制代码

(2)解耦 Fragment

在新版的 SDK 中,Fragment 同样也默认实现了 LifecycleOwner 接口,因此,以上的例子同样适合于 Fragment。

(二)使用场景2:使用 LifecycleService 解耦 Service 与组件

(1)LifecycleService 基本介绍

Android 中拥有生命周期的组件除了 Activity/Fragment ,还有一个非常重要的组件就是 Service。LifecycleService 就是用来监听和解耦 Service 组件的。

public class LifecycleService extends Service implements LifecycleOwner {

    private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);

    ......

    @Override
    @NonNull
    public Lifecycle getLifecycle() {
        return mDispatcher.getLifecycle();
    }
}
复制代码

(2)具体使用方法

第一步:添加相关依赖

implementation "androidx.lifecycle:lifecycle-service:2.2.0"
复制代码

第二步:创建 MyServiceObserver 类,实现 LifecycleObserver 接口。使用 @OnLifecycleEvent 标记希望在 Server 生命周期发生变化时得到同步调用的方法。

public class MyServiceObserver implements LifecycleObserver {
    private static String TAG = "MyServiceObserver";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void initVideo(){
        Log.d(TAG,"initVideo");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private void pausePlay(){
        Log.d(TAG,"stopPlay");
    }
}
复制代码

第三步:创建一个 MyService 的类,继承 LifecycleService。由于 LifecycleService 是 Service 的直接子类,所以使用起来与普通的 Service 没有差别。

public class MyService extends LifecycleService {
    private MyServiceObserver myServiceObserver;
    
    public MyService(){
        myServiceObserver = new MyServiceObserver();
        getLifecycle().addObserver(myServiceObserver);
    }
}
复制代码

(三)使用场景3:使用 ProcessLifecycleOwner 监听应用程序的生命周期

具有生命周期的组件除了 Activity、Fragment 和 Service 外,还有 Application。ProcessLifecycleOwner 就是用来监听整个应用程序的生命周期情况。

具体使用方法:

第一步:添加依赖项

implementation "androidx.lifecycle:lifecycle-process:2.2.0"
复制代码

第二步:定义一个 ApplicationObserver,实现 LifecycleObserver 接口。

public class ApplicationObserver implements LifecycleObserver {
    private String TAG = this.getClass().getName();

    /**
     * 在应用程序的整个生命周期中只会被调用一次
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.d(TAG,"Lifecycle.Event.ON_CREATE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Log.d(TAG,"Lifecycle.Event.ON_START");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Log.d(TAG,"Lifecycle.Event.ON_RESUME");
    }

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

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.d(TAG,"Lifecycle.Event.ON_STOP");
    }

    /**
     * 永远不会被调用,系统不会分发调用 ON_DESTROY 事件
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.d(TAG,"Lifecycle.Event.ON_DESTROY");
    }
}
复制代码

第三步:在 Application 中关联 ApplicationObserver。

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());
    }
}
复制代码

注意事项:

  1. ProcessLifecycleOwner 是针对整个应用程序的监听,与 Activity 的数量无关。
  2. Lifecycle.Event.ON_CREATE 只会被调用一次,而 Lifecycle.Event.ON_DESTROY 永远不会被调用。
  3. Lifecycle.Event.ON_PAUSE 和 Lifecycle.Event.ON_STOP 的调用会有一定的延后,因为系统需要为“屏幕旋转,由于配置发生变化而导致的 Activity 重新创建” 的情况预留一些时间。

三、LifeCycle 的另外两种写法

LifeCycle 有三种实现方法:

  1. LifecycleObserver 配合 @OnLifecycleEvent 注解
  2. DefaultLifecycleObserver 拥有宿主所有生命周期事件
  3. LifecycleEventObserver 将宿主生命周期事件封装成 Lifecycle.Event

在上一节使用介绍中,我们用的是第一种方式:LifecycleObserver 配合 @OnLifecycleEvent 注解。

这种方式使用比较简单,但是注意最好添加 lifecycle-compiler 这个注解处理器,否者在运行时会使用反射的形式回调到对应的方法上:

annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.2.0"
复制代码

加上这个注解处理器后,用 @OnLifecycleEvent 标记的方法就不能再声明成 private ,否者会报如下的错误:

method marked with OnLifecycleEvent annotation can not be private
复制代码

下面介绍一下另外两种实现方式:

(一)DefaultLifecycleObserver 拥有宿主所有生命周期事件

使用 DefaultLifecycleObserver 需要用到 Java8,我们首先添加依赖:

implementation "androidx.lifecycle:lifecycle-common-java8:2.2.0"
复制代码

然后在模块级别的 build.gradle 中添加:

android {
  ...
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}
复制代码

使用 lifecycle-common-java8 依赖后,就可以将 lifecycle-compiler 依赖去掉。

DefaultLifecycleObserver 接口中有 6 个生命周期方法:

public interface DefaultLifecycleObserver extends FullLifecycleObserver {

    @Override
    default void onCreate(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onStart(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onResume(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onPause(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onStop(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onDestroy(@NonNull LifecycleOwner owner) {
    }
}
复制代码

该接口继承自 FullLifecycleObserver ,由于权限问题,我们不能直接使用 FullLifecycleObserver 来拥有宿主的所有生命周期事件。

所以,我们需要通过实现 DefaultLifecycleObserver 接口,然后重写自己业务需要监听的生命周期方法。

(二)LifecycleEventObserver 宿主生命周期事件封装成 Lifecycle.Event

//通过实现 LifecycleEventObserver 接口,重写 onStateChanged 方法,在该方法内部
//通过判断 Lifecycle.Event 来实现具体的业务逻辑
public class MyVideoPlayObserver implements LifecycleEventObserver {
    private static String TAG = "MyVideoPlayObserver";

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event){
            case ON_CREATE:
                Log.d(TAG,"initVideo");
                break;
            case ON_START:
                Log.d(TAG,"startPlay");
                break;
            case ON_RESUME:
                Log.d(TAG,"resumePlay");
                break;
            default:
                 break;
        }
    }
}
复制代码

对于这三种实现方式如何选择呢?

建议使用 DefaultLifecycleObserver 和 LifecycleEventObserver 的方式。

  1. Java8 使用 DefaultLifecycleObserver 来实现 Lifecycle,Java7 使用注解的方式。如果一旦 Java8 成为 Android 的主流后,注解的方式会被弃用。
  2. 如果一个类同时实现了 DefaultLifecycleObserver 接口和 LifecycleEventObserver 接口,那么 DefaultLifecycleObserver 中的方法会先触发,然后才执行 LifecycleEventObserver 的 onStateChanged 方法。
  3. 如果一个类实现了 DefaultLifecycleObserver 接口,同时使用了 @OnLifecycleEvent 注解,那么注解的方式会被自动忽略掉。

四、总结

LifeCycle 组件存在的主要意义是帮助我们解耦,让自己定义的组件也能够感受到生命周期的变化。

五、补充

截止本文发布时,lifecycle_version 最新版本是 2.2.0,如需获取最新版本请查看官网:

developer.android.google.cn/jetpack/and…

注:lifecycle-extensions 中的 API 已弃用,需要使用到 Lifecycle 下的某个工具时,添加对应的依赖即可:

    dependencies {
        def lifecycle_version = "2.2.0"
        def arch_version = "2.1.0"

        // ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
        // LiveData
        implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
        // Lifecycles only (without ViewModel or LiveData)
        implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

        // Saved state module for ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

        // Annotation processor
        annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

        // optional - ReactiveStreams support for LiveData
        implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"

        // optional - Test helpers for LiveData
        testImplementation "androidx.arch.core:core-testing:$arch_version"
    }
    
复制代码

六、参考资料

Google Jetpack 官方文档

慕课专栏:跟架构师学Jetpack

《Android Jetpack 应用指南》叶坤