Android Jetpack架构组件——Lifecycle使用篇

系列文章往这看

Android Jetpack架构组件——什么是Jetpack？

Android Jetpack架构组件——Lifecycle使用篇

Android Jetpack架构组件——Lifecycle原理篇

Android Jetpack架构组件——一文带你了解ViewModel的使用及原理

Android Jetpack架构组件——LiveData使用篇

Android Jetpack架构组件——LiveData原理篇

概述

Lifecycle是一个持有组件生命周期状态的class，并且允许其他组件来观察生命周期的变化。并不局限于Activity或者Fragment。我们只知道生命周期是由操作系统或者进程中运行的代码进行管理。而且生命周期是Android工作原理的核心，所以应用必须遵循它们。否则会引起OOM或者Crash。

为什么需要使用Lifecycle管理生命周期

在此我们用官网提供的一个示例：

 internal class MyLocationListener(
        private val context: Context,
        private val callback: (Location) -> Unit
) {

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

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

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        myLocationListener.start()
        // manage other components that need to respond
        // to the activity lifecycle
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

从逻辑上看这段代码其实没什么问题，但是在真实应用场景中，我们需要管理很多组件和当前页面的调用，以响应当前生命周期的状态。所以会导致我们在onStop和onStart中存放大量的代码，导致它们难以维护。

所以官方提供lifecycle就是为了可以帮助我们以弹性和隔离的方式解决这些问题。

如何使用Lifecycle

lifecycle依赖

如果需要使用lifecycle的依赖，需要家google的maven仓库添加到项目中，在项目中的build.gradle新增：

allprojects {
    repositories {
        google()
    }
}

在你的工程目录中的build.gradle中新增如下依赖：

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

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

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

    // Annotation processor
    kapt "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-ktx:$lifecycle_version"

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

使用方法

• 生命周期拥有者使用getLifecycle()或者实例，然后通过addObserver添加观察者。
• 观察者实现LifecycleObserver接口，通过使用OnLifecycleEvent注解关注相应的生命周期。

使用示例

我们这里依然使用官方的例子：

class MyObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun connectListener() {
        ...
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun disconnectListener() {
        ...
    }
}

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

首先MyObserver实现LifecycleObserver接口，并使用ON_RESUME和ON_PAUSE注解对方法加上了生命周期的限制。然后拥有者直接通过添加观察者的形式进行调用即可。

实现自定义的LifecycleOwner

在26.1.0及更高版本中的Fragment和Activity已经默认实现了LifecycleOwner接口。
如果你需要自定义类并希望它成为LifecycleOwner。你可以使用 LifecycleRegistry。示例代码如下：

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

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

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

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

通过makeState设置Lifecycle的各种状态，然后通过getLifecycle返回该实例。

实战

我们简单通过lifecycle对应用的前后台进行一个监听。我们先看下我们使用lifecycle之前是怎么对应用的前后台监听的。

/**
 * @date:2020/12/30
 * @author:Silence
 * @describe:
 **/
 open class BaseActivityLifecycleCallback : Application.ActivityLifecycleCallbacks {

    private var currentResumedActivity: WeakReference<Activity>? = null

    //监听app前后台的监听器
    private var listener: OnAppStatusListener? = null

    //打开的Activity数量统计
    private var activityStartCount = 0

    fun registerAppStatusListener(listener: OnAppStatusListener) {
        this.listener = listener
    }

    override fun onActivityPaused(activity: Activity) {
        currentResumedActivity == null
    }

    override fun onActivityStarted(activity: Activity) {
        activityStartCount++
        if (activityStartCount == 1) {
            listener?.onAppFront()
        }
    }

    override fun onActivityDestroyed(activity: Activity) = Unit

    override fun onActivitySaveInstanceState(activity: Activity, bundle: Bundle) = Unit

    override fun onActivityStopped(activity: Activity) {
        activityStartCount--
        if (activityStartCount == 0) {
            listener?.onAppBackground()
        }
    }

    override fun onActivityCreated(activity: Activity, bundle: Bundle?) = Unit

    override fun onActivityResumed(activity: Activity) {
        currentResumedActivity = WeakReference(activity)
    }

    fun getCurrentActivity(): Activity? {
        return currentResumedActivity?.get()
    }
}

是不是感觉代码有点繁琐？需要通过对activity记数来判断应用是否在前后台。那么如果我们通过lifecycle会变成怎样呢？那我们来看一下：

/**
 * @date:2021/02/08
 * @author:Silence
 * @describe:
 **/
class AppLifeObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onForeground() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onBackground() {
    }
}

然后我们在application直接调用如下代码：

ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifeObserver())

是不是相对之前的记数方法简单很多。而且通过lifecycle的实现可读性相对而言会更高。

总结

本篇我们简单介绍了lifecycle的使用以及通过尝试使用lifecycle这个歌简单的例子对app前台后做监听。可以发现lifecycle的使用很简单。但是本篇并没有讲到lifecycle的原理。因为你只有会使用了才会愿意了解原理。那么下一篇我们讲lifecycle的实现原理。

参考

官方文档

本文首发于我的个人博客：Android Jetpack架构组件——Lifecycle使用篇

更多文章请关注我的公众号：码农职场