[移动开发]Android Jetpack学习（一）--Lifecycles

一、Jetpack是什么

Jetpack是Google为了解决Android架构问题而引入的一套库、工具和指南，可以帮助开发者更轻松地编写应用程序。Jetpack包含了架构组件、基础组件、行为组件和界面组件；这里主要介绍架构组件的学习，最后再介绍google官方推出的架构。

架构组件包含了：

1. Lifecycles 生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。
2. Navigation
   它管理应用中多个屏幕之间的复杂导航、过渡动画、深层链接以及编译时间检查参数传递。
3. ViewModel ViewModel 类旨在以注重生命周期的方式存储和管理界面相关的数据。ViewModel类让数据可在发生屏幕旋转等配置更改后继续留存。（例如屏幕旋转）。通常和DataBinding配合使用，为开发者实现MVVM架构提供了强有力的支持。
4. LiveData 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。
5. Room Room 在 SQLite 上提供了一个抽象层，以便在充分利用 SQLite 的强大功能的同时，能够流畅地访问数据库。
6. WorkManager 供开发者“轻松调度”那些即使在退出应用或重启设备后仍应运行的“可靠”异步任务
7. DataBinding 使用声明性格式（而非程序化地）将布局中的界面组件绑定到应用中的数据源。
8. Paging 分页加载

二、介绍

1.Lifecycles

1.1 诞生的背景：

以往我们使用的类通常依赖于系统组件（如 Activity 和 Fragment ）的生命周期状态的变化.例如：我们
在页面的onCreate()方法中对自己的组件进行初始化，在onPause()方法中停止组件，而在页面的onDestroy()方法中对组件进行资源回收工作。但是这样的工作非常烦琐，会让页面与组件之间的耦合度变高。但这些工作又不得不做，因为这可能会引发内存泄漏。
Lifecycle就是为了解决这种生命周期感知模式下，耦合度变高，代码不易扩展，难以维护的问题。

1.2 如何使用

1. 迁移到AndroidX

androidx.lifecycle 软件包提供了可用于构建生命周期感知型组件的类和接口 - 这些组件可以根据 Activity 或 Fragment 的当前生命周期状态自动调整其行为。

如果你想使用jetpack相关的组件，请将项目迁移至Androidx中（如果你已经在使用androidx库了，请忽略）

Android Studio 3.2 及更高版本，您只需从菜单栏中依次选择 Refactor > Migrate to AndroidX，即可将现有项目迁移到 AndroidX。

点击Migrate.
Android 插件会通过重写现有第三方库的二进制文件，自动将这些库迁移为使用 AndroidX。

重构命令使用两个标记。默认情况下，这两个标记在 gradle.properties 文件中都设为 true：

android.useAndroidX=true

Android 插件会使用对应的 AndroidX 库而非支持库。

android.enableJetifier=true

此外您的编译 SDK 设置为 Android 9.0（API 级别 28）或更高版本

2、配置依赖

有的博客添加的依赖是：

implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'

注意：

lifecycle-extensions 中的 API 已弃用。您可以为特定 Lifecycle 工件添加所需的依赖项

JAVA:

    dependencies {
        def lifecycle_version = "2.4.0-alpha02"
        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"
    }
    

当前lifecycle_version信息和Kotlin的依赖请参考：
lifecycle版本号

3、案例

假设我们需要做一个视频播放功能：在打开页面的时候进行视频的播放，关闭页面停止播放。我们首先定义一个PlayerManager，我们通常这样做

在不使用Lifecycle组件的情况下

public class PlayerManager   {

    /**
     * 创建播放器
     */
    public void createrPlay(){
        LoggeHelper.E("createrPlay");
    }

    /**
     * 开始播放
     */
    public void startPlay(){
        LoggeHelper.E("startPlay");
    }

    /**
     * 停止播放
     */
    public void stopPlay(){
        LoggeHelper.E("stopPlay");
    }

    /**
     * 销毁播放器
     */
    public void destoryPlay(){
        LoggeHelper.E("destoryPlay");
    }

}

然后我们在Activity或者Fragment的生命周期中使用这些方法。

使用Lifecycle组件

public class PlayerManager  implements LifecycleObserver {

    /**
     * 创建播放器
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void createrPlay(){
        LoggeHelper.E("createrPlay");
    }

    /**
     * 开始播放
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void startPlay(){
        LoggeHelper.E("startPlay");
    }

    /**
     * 停止播放
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void stopPlay(){
        LoggeHelper.E("stopPlay");
    }

    /**
     * 销毁播放器
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void destoryPlay(){
        LoggeHelper.E("destoryPlay");
    }

}

在Activity中我们这样调用

public class Jetpack_LifecycleActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_jetpack__lifecycle);
        getLifecycle().addObserver(new PlayerManager());
    }
}

是不是很简单，业务控件PlayerManager只管处理自己的逻辑，不需要再Activity的生命周期中多余的事情。
它是怎么做的呢？在上述代码中：

• 首先我们让PlayerManager实现LifecycleObserver接口。在需要依赖于生命周期调用方法上使用＠OnLifecycleEvent（Lifecycle.Event.ON_XXX）标签进行标识。这样，当页面生命周期发生变化时，这些被标识过的方法便会被自动调用。
• 在Activity中通过getLifecycle().addObserver()方法，将观察者与被观察者绑定起来即可。

Jetpack为我们提供了两个类：LifecycleOwner（被观察者）和LifecycleObserver（观察者）。即通过观察者模式，实现对页面生命周期的监听。在新版本的SDK包中，Activity(framgent)已经默认实现了LifecycleOwner接口。LifecycleOwner接口中只有一个getLifecycle（LifecycleObserverobserver）方法，LifecycleOwner正是通过该方法实现观察者模式的。

我们看一下Lifecycle的源码

public abstract class Lifecycle {

    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    @NonNull
    AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();

    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    @MainThread
    @NonNull
    public abstract State getCurrentState();

    @SuppressWarnings("WeakerAccess")
    public enum Event {

        ON_CREATE,

        ON_START,

        ON_RESUME,

        ON_PAUSE,

        ON_STOP,

        ON_DESTROY,

        ON_ANY
    }

    @SuppressWarnings("WeakerAccess")
    public enum State {

        DESTROYED,

        INITIALIZED,

        CREATED,

        STARTED,

        RESUMED;

        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

除了addObserver(),removeObserver();Lifecycle使用两个枚举来跟踪其关联组件的生命周期状态，这两个枚举分别是Event和State。

• State：Lifecycle的生命周期所处的状态。
• Event：Lifecycle生命周期对应的事件，这些事件会映射到Activity和Fragment中的回调事件中。

Event中的ON_ANY指代的是匹配所有的事件；
关于State和Event的所对应的关系。官方的图示说明的很清楚：

如果 Lifecycle 现在未处于良好的状态，则应避免调用某些回调。Lifecycle 类允许其他对象查询当前状态。示例：

lifecycle.getCurrentState().isAtLeast(STARTED)

自定义LifecycleOwner

使用 LifecycleRegistry 类，但需要将事件转发到该类

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

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

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

1.4 LifecycleService

为了便于对Service生命周期的监听，达到解耦Service与组件的目的，Android提供了一个名为LifecycleService的类。该类继承自Service，并实现了LifecycleOwner接口。与Activity/Fragment类似，它也提供了一个名为getLifecycle()的方法供我们使用。使用方法和前面类似，就不介绍了。

1.5 ProcessLifecycIeOwner

ProcessLifecycIeOwner用于管理整个应用进程的生命周期。
ProcessLifecycleOwner的使用方式与Activity、Fragment和Service是类似的，其本质也是观察者模式。由于我们要观察的是整个应用程序，因此，需要在Application中进行相关代码的编写。
使用方法与前面的类似，我们只列举Applicaion中的代码

public class MyApplication  extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new MyApplicationObserver());
    }
}

注意：在Application中，Lifecycle.Event.ON_CREATE只会被调用一次，而Lifecycle.Event.ON_DESTROY永远不会被调用。