Android lifecycle的使用

1. 简介

为了应用的安全，常常会有从后台切回前台时进行软件确认等安全确认处理的需求。若是是之前的话，这个需求实际上是挺难实现的。 但自从Google推出Lifecycle组件之后，这个需求就简单了不少。Lifecycle除了感知从后台切回前台之外， 利用这个组件能够更简单的实现复杂的处理生命周期的操做。这篇只讲述如何实现感知从后台切回前台时的生命周期。

2. Lifecycle组件

2.1 介绍

用Lifecycle组件能够感知Activity和Fragment的生命周期。

• 该组件的实现方式是观察者模式。在生命周期拥有者和生命周期的观察者之间创建观察与被观察的关系。当生命周期拥有者的生命周期发生变化时会通知观察者生命周期观察者，观察者收到通知后会进行各类处理。
• 能够方便获取生命周期拥有者的生命周期。

生命周期使用两个主要枚举来跟踪相关组件的生命周期：

1. Event : 从框架和LifeCycle类派发的生命周期事件。这些事件映射到Activity和Fragment中的回调事件。
2. State : 有LifeCycle对象跟踪的组件的当前状态。

evernotecid://BF69E971-D524-44B7-91DB-A61998A9A576/appyinxiangcom/18475009/ENResource/p1942

2.2 使用场景

• 能够集中处理生命周期事件，不用反复在不一样的Activity中写生命周期事件(如解除广播)。
• 能够实现感知整个应用的生命周期。

3. LifeCycle的使用

3.1 添加到依赖库

根据本身的须要添加LifeCycle的依赖到本身的项目中。

// ViewModel and LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    // alternatively - just ViewModel
    implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" // use -ktx for Kotlin
    // 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"
    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"
复制代码

3.2 LifeCyleOwner

LifeCycleOwner是生命周期的观察者。会根据收到的通知进行相应处理。LifeCycleOwner的接口很简单，以下：

public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}
复制代码

在Activity和Fragment中添加生命周期的观察者。

lifecycle.addObserver(AppLifecycleObserver(object:AppLifecycleCallback(){
    // Do something
}))
复制代码

3.3 LifeCycleObserver

LifeCyclObserver是生命周期的被观察者。在这里须要定义咱们在生命周期的各个阶段中进行的操做。咱们须要经过LifeCycle的注解来标注该方法是在哪一个生命周期被调用。以下：

class AppLifecycleObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        // Do something
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        // Do something
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {
        // Do something
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        // Do something
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        // Do something
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
        // Do something
    }

    // 全部的生命周期都会调用这个方法
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun onAny() {
        // Do something
    }
}
复制代码

@OnLifecycleEvent(Lifecycle.Event.ON_ANY)的注解如其名，会在全部的生命周期阶段都会被调用。

4. 应用切换先后台的生命周期感知

4.1 实现LifeCyCleObserver类

首先咱们要实现当感知到切回前台时的操做，因此须要实现的处理写入到LifeCycleObserver中。 在这里咱们加入了回调，这些回调将会在Application类中实现。

class AppLifecycleObserver(val callback: AppLifecycleCallback) : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        callback.onStart()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        callback.onPause()
    }
}
复制代码

固然还有建立回调类。

interface AppLifecycleCallback {

    fun onStart()

    fun onPause()
    
}
复制代码

4.2 LifeCycleOwner

接下来是在Android中实现LifeCycleOwner类。还有要设置一个Flag，用于记录先后台的切状态。
在这里说明一下， 为何会在onStart中进行onForeground操做缘由，而不是onResume。 由于从后台切回前台时，都是先调用Activity的生命周期，而后再调用Android的。即Acitivty的OnResume() -> Application的onResume()。这种状况若是咱们在Application的onResume中进行onForeground操做，Activity会拿到onBackground的flag。 因此若是想在Activity的onResume中判断切回前台的状态，则须要在Application中比onResume状态以前的状态中实现。

ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver(object :
            AppLifecycleCallback {
            override fun onStart() {
                onForeground()
                Log.d(TAG, "onStart")
            }

            override fun onPause() {
                onBackground()
                Log.d(TAG, "onPause")
            }
        }))

    }

    fun getAppStatus(): Boolean {
        return isAppActive
    }

    fun onBackground() {
        isAppActive = false
    }

    fun onForeground() {
        isAppActive = true
    }
复制代码

在Application中只能经过ProcessLifecycleOwner中得到lifecycle。

4.3 在具体的Acitivty中获取Flag

虽然能够在Android实现感知的具体操做， 但实际需求是不须要全部的Activity都须要感知。这个时候能够在Activity中获取Flag，根据Flag进行相关处理。

override fun onResume() {
        super.onResume()

        Log.d("MainActivity", "onResume")

        val app = application as AndroidApplication
        Log.d("MainActivity", app.getAppStatus().toString())
        if (app.getAppStatus()) {
            Log.d("MainActivity", "onResume work")
            Toast.makeText(this, "App is in Foreground", Toast.LENGTH_LONG).show()
        }
    }
复制代码

4.4 实际效果

5. 总结

• LifeCycleObserver应该避免引用Context和View等， 防止发生内存泄露。应对这个问题可使用回调，即在LifeCycleObserver中加入回调，在Activity和Fragment中实现。
• 虽然LifeCycle很好用，但不要滥用。 若是项目中不须要大量的生命周期处理，就不须要使用这个组件。

github: github.com/HyejeanMOON…