文章目录

一、导入 Library
二、监听 Activity 生命周期

方式一：继承 DefaultLifecycleObserver
方式二：使用注解

三、Lifecycle 的状态

3.1.五种状态
3.2.状态改变的时机
3.3.active 与 inactive 的 Lifecycle

四、监听 Application 生命周期
五、监听 app 前后台切换
六、总结

一、导入 Library

在 build.gradle 中导入库：

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

添加 Java 和 Kotlin 的 java8 支持：

compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
}
kotlinOptions {
    jvmTarget = '1.8'
}

二、监听 Activity 生命周期

监听生命周期有两种方式，一是继承 DefaultLifecycleObserver，在其重载方法中处理。二是使用注解，在方法上添加生命周期回调事件的注解，就能接收到对应回调。
Google 官方推荐使用方式一，因为随着 Java8 的流行，注解可能会被废弃。

方式一：继承 DefaultLifecycleObserver

新建 MyLifecycleObserver 类，继承自 DefaultLifecycleObserver

class MyLifecycleObserver : DefaultLifecycleObserver{
    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        Log.d("~~~", "onCreate")
    }

    override fun onResume(owner: LifecycleOwner) {
        super.onResume(owner)
        Log.d("~~~", "onResume")
    }

    override fun onPause(owner: LifecycleOwner) {
        super.onPause(owner)
        Log.d("~~~", "onPause")
    }

    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        Log.d("~~~", "onStart")
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        Log.d("~~~", "onStop")
    }

    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        Log.d("~~~", "onDestroy")
    }
}

在需要监听生命周期的 Activity 中，给 lifecycle 添加此观察者：

class MainActivity : AppCompatActivity() {

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

大功告成，现在这个 activity 的生命周期回调触发时，MyLifecycleObserver 的对应方法就能监听到了。

方式二：使用注解

新建 MyLifecycleObserver 类，让其继承自 LifecycleObserver。通过给方法添加 OnLifecycleEvent 注解的方式监听生命周期。

class MyLifecycleObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create() {
        Log.d("~~~", "ON_CREATE")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun start() {
        Log.d("~~~", "ON_START")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun resume() {
        Log.d("~~~", "ON_RESUME")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun pause() {
        Log.d("~~~", "ON_PAUSE")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun stop() {
        Log.d("~~~", "ON_STOP")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun destroy() {
        Log.d("~~~", "ON_DESTROY")
    }
}

在需要监听生命周期的 Activity 中，给 lifecycle 添加此观察者：

class MainActivity : AppCompatActivity() {

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

两种方式的效果是一样的。

三、Lifecycle 的状态

3.1.五种状态

Lifecycle 一共有五种状态，分别是：

INITIALIZED
CREATED
STARTED
RESUMED
DESTROYED

官网上用一张图表示了 Lifecycle 的状态与生命周期的关系：

3.2.状态改变的时机

我们修改一下 MainActivity，来测一下 Lifecycle 的几种状态改变的时机。

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        Log.d("~~~", "OnCreate start, ${lifecycle.currentState}")
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        lifecycle.addObserver(MyLifecycleObserver())
        Log.d("~~~", "OnCreate end, ${lifecycle.currentState}")
    }

    override fun onStart() {
        Log.d("~~~", "onStart start, ${lifecycle.currentState}")
        super.onStart()
        Log.d("~~~", "onStart end, ${lifecycle.currentState}")
    }

    override fun onResume() {
        Log.d("~~~", "onResume start, ${lifecycle.currentState}")
        super.onResume()
        Log.d("~~~", "onResume end, ${lifecycle.currentState}")
        Thread(Runnable {
            Thread.sleep(1000)
            Log.d("~~~", "waiting 1 second after onResume, ${lifecycle.currentState}")
        }).start()
    }

    override fun onPause() {
        Log.d("~~~", "onPause start, ${lifecycle.currentState}")
        super.onPause()
        Log.d("~~~", "onPause end, ${lifecycle.currentState}")
    }

    override fun onStop() {
        Log.d("~~~", "onStop start, ${lifecycle.currentState}")
        super.onStop()
        Log.d("~~~", "onStop end, ${lifecycle.currentState}")
    }

    override fun onDestroy() {
        Log.d("~~~", "onDestroy start, ${lifecycle.currentState}")
        super.onDestroy()
        Log.d("~~~", "onDestroy end, ${lifecycle.currentState}")
    }
}

运行程序，程序打开后，等待 1 秒多的时间（等待 1 秒是为了便于观察 RESUMED 状态），点击返回键退出。Log 输出如下：

2020-03-03 22:29:39.569 20742-20742/com.example.myapplication D/~~~: OnCreate start, currentState is INITIALIZED
2020-03-03 22:29:39.747 20742-20742/com.example.myapplication D/~~~: OnCreate end, currentState is INITIALIZED
2020-03-03 22:29:39.750 20742-20742/com.example.myapplication D/~~~: ON_CREATE
2020-03-03 22:29:39.754 20742-20742/com.example.myapplication D/~~~: onStart start, currentState is CREATED
2020-03-03 22:29:39.758 20742-20742/com.example.myapplication D/~~~: onStart end, currentState is CREATED
2020-03-03 22:29:39.758 20742-20742/com.example.myapplication D/~~~: ON_START
2020-03-03 22:29:39.759 20742-20742/com.example.myapplication D/~~~: onResume start, currentState is STARTED
2020-03-03 22:29:39.759 20742-20742/com.example.myapplication D/~~~: onResume end, currentState is STARTED
2020-03-03 22:29:39.760 20742-20742/com.example.myapplication D/~~~: ON_RESUME
2020-03-03 22:29:40.761 20742-20794/com.example.myapplication D/~~~: waiting 1 second after onResume, currentState is RESUMED
2020-03-03 22:29:48.028 20742-20742/com.example.myapplication D/~~~: ON_PAUSE
2020-03-03 22:29:48.028 20742-20742/com.example.myapplication D/~~~: onPause start, currentState is STARTED
2020-03-03 22:29:48.029 20742-20742/com.example.myapplication D/~~~: onPause end, currentState is STARTED
2020-03-03 22:29:48.655 20742-20742/com.example.myapplication D/~~~: ON_STOP
2020-03-03 22:29:48.655 20742-20742/com.example.myapplication D/~~~: onStop start, currentState is CREATED
2020-03-03 22:29:48.656 20742-20742/com.example.myapplication D/~~~: onStop end, currentState is CREATED
2020-03-03 22:29:48.660 20742-20742/com.example.myapplication D/~~~: ON_DESTROY
2020-03-03 22:29:48.660 20742-20742/com.example.myapplication D/~~~: onDestroy start, currentState is DESTROYED
2020-03-03 22:29:48.661 20742-20742/com.example.myapplication D/~~~: onDestroy end, currentState is DESTROYED

经过测试，我们发现打开 app 时：

Lifecycle 在 Activity 的 onCreate 方法中，状态一直是 INITIALIZED。Activity 的 onCreate 执行完后，才会回调 Observer 的 onCreate 方法，然后状态变成 CREATED
Lifecycle 在 Activity 的 onStart 方法中，状态一直是 CREATED。Activity 的 onStart 执行完后，才会回调 Observer 的 onStart 方法，然后状态变成 STARTED
Lifecycle 在 Activity 的 onResume 方法中，状态一直是 STARTED。Activity 的 onResume 执行完后，才会回调 Observer 的 onResume 方法，然后状态变成 RESUMED

关闭 app 时：

Activity 的 onPause 执行前，先回调 Lifecycle 的 onPause 方法，Lifecycle 状态变为 STARTED。然后再去执行 Activity 的 onPause 方法，在 Activity 的 onPause 方法中，Lifecycle 的状态一直是 STARTED
Activity 的 onStop 执行前，先回调 Lifecycle 的 onStop 方法，Lifecycle 状态变为 CREATED。然后再去执行 Activity 的 onStop 方法，在 Activity 的 onStop 方法中，Lifecycle 的状态一直是 CREATED
Activity 的 onDestroy 执行前，先回调 Lifecycle 的 onDestroy 方法，Lifecycle 状态变为 DESTROYED。然后再去执行 Activity 的 onDestroy 方法，在 Activity 的 onDestroy 方法中，Lifecycle 的状态一直是 DESTROYED

总结起来就是：进入时最后改 Lifecycle 状态，退出时最先改 Lifecycle 状态。

3.3.active 与 inactive 的 Lifecycle

当 Lifecycle 处于 STARTED 或 RESUMED 状态时，我们认为 Lifecycle 是 active 的，否则认为是 inactive 的。

四、监听 Application 生命周期

监听整个 app 的生命周期，官方文档推荐使用 ProcessLifecycleOwner。
同样可以使用继承或注解两种方式。MyLifecycleObserver 类和上述代码一模一样。在 Application 中，使用 ProcessLifecycleOwner 添加此观察者：

class MyApplication : Application(), LifecycleObserver {
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(MyLifecycleObserver())
    }
}

当 app 启动时，依次回调 onCreate、onStart、onResume，当 app 退出时，依次回调 onPause、onStop，并且永远不会回调 onDestroy。官方文档中提到，onPause、onStop 回调是有一定间隔的，目的是保证在手机旋转等配置改变时引起的 Activity 销毁和重建时不发送 Event。查看源码可以发现，这个间隔时间是 700ms。并且源码中是通过监听前台 Activity 的数量实现的此功能。我们也可以通过这种方式来监听 app 前后台切换。

注：笔者在 mac 的安卓模拟器上使用 ProcessLifecycleOwner 没有监听到 onPause、onStop 回调，但 Windows 的模拟器上可以监听到，暂不清楚原因。

五、监听 app 前后台切换

新建 MyActivityLifecycleCallbacks 单例：

object MyActivityLifecycleCallbacks : Application.ActivityLifecycleCallbacks {
    private var foregroundActivityCounts = 0

    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
    }

    override fun onActivityStarted(activity: Activity) {
        if (foregroundActivityCounts++ == 0) {
            Log.d("~~~", "foreground")
        }
    }

    override fun onActivityResumed(activity: Activity) {
    }

    override fun onActivityPaused(activity: Activity) {
    }

    override fun onActivityStopped(activity: Activity) {
        if (--foregroundActivityCounts == 0) {
            Log.d("~~~", "background")
        }
    }

    override fun onActivityDestroyed(activity: Activity) {
    }

    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {
    }

    fun isAppForeground(): Boolean {
        return foregroundActivityCounts > 0
    }

}

在 Application 中注册此 LifecycleCallbacks

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        registerActivityLifecycleCallbacks(MyActivityLifecycleCallbacks)
    }
}

在 MyActivityLifecycleCallbacks 中，我们维护了一个 int 变量 foregroundActivityCounts ，用来记录此 app 前台 Activity 的数量。
每当 Activity 的 onStart 回调时，foregroundActivityCounts++，每当 Activity 的 onStop 回调时，–foregroundActivityCounts。

如果 foregroundActivityCounts 从 0 变成 1，说明 app 进入前台，如果 foregroundActivityCounts 从 1 变成 0，说明 app 进入后台。

MyActivityLifecycleCallbacks 声明了 isAppForeground 方法，通过 foregroundActivityCounts 是否大于 0 来判断 app 是否在前台。

六、总结

在应用开发中，我们常常会有一些逻辑需要与生命周期绑定。比如：页面展示在前台时播放视频，切换到后台时暂停播放。应用开始时初始化，应用退出时释放资源。通过本文介绍的这些监听方法，可以让这些代码逻辑自己处理生命周期，实现更好的解耦。

伪代码表示如下，使用 Lifecycle 前：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        LibraryA.init()
        LibraryB.init()
        LibraryC.init()
    }

    override fun onResume() {
        super.onResume()
        LibraryA.resume()
        LibraryB.resume()
        LibraryC.resume()
    }

    override fun onPause() {
        super.onPause()
        LibraryA.pause()
        LibraryB.pause()
        LibraryC.pause()
    }

    override fun onDestroy() {
        super.onDestroy()
        LibraryA.release()
        LibraryB.release()
        LibraryC.release()
    }
}

使用 Lifecycle 后：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        lifecycle.addObserver(LifecycleObserverA())
        lifecycle.addObserver(LifecycleObserverB())
        lifecycle.addObserver(LifecycleObserverC())
    }
}

AlpinistWang

原创文章 67 获赞 68 访问量 6万+

关注私信

Android Jitpack 组件之 Lifecycle（Kotlin）