Jetpack：LifeCycle全面解析（包含检测app启动、进入前台、进入后台例子）。

---

简介

LifeCycle可以帮助开发者创建可感知生命周期的组件。这样，组件便能够在其内部管理自己的生命周期，从而降低模块间的耦合度，并降低内存泄漏发生的可能性。LifeCycle可用于Activity、Fragment、Service以及Application中。

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

public class ComponentActivity extends Activity implements
        LifecycleOwner,
        KeyEventDispatcher.Component {
        
        ...
        
        private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
        
        public Lifecycle getLifecycle() {
        	return mLifecycleRegistry;
        }
        
        ...
        
}

Lifecycle使用到的依赖

buildscript {
    //android lifecycle version
    ext.lifecycle_version = "2.3.0"
}
dependencies {
    //Lifecycles only (without ViewModel or LiveData) 
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
    //lifecycle-service  支持
    implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"
    //lifecycle-application  支持
    implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
}

使用LifeCycle解耦activity与fragment

监听activity的生命周期

1.继承LifecycleEventObserver，在onStateChanged方法中可以监听到对应生命周期的变化，监听到activity销毁的时候，可以移除observer。

class LocationLifecycleListener(private val block: (Pair<Int, Int>) -> Unit) :
    LifecycleEventObserver {

    init {
        //初始化
        MockLocationManager.initLocationManager()
    }

    /**
     * 生命周期状态改变后回调这里
     */
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_START -> {
                //开始获取位置信息
                MockLocationManager.startGetLocation()
            }
            Lifecycle.Event.ON_PAUSE -> {
                //停止获取位置信息
                MockLocationManager.stopGetLocation()
            }
            Lifecycle.Event.ON_DESTROY -> {
                //移除生命周期监听
                source.lifecycle.removeObserver(this)
                LogUtil.i("MockLocationManager ${event.name} lifecycle observer remove success.")
            }
            else -> {
                //其他生命周期监听
                LogUtil.i("MockLocationManager ${event.name}")
            }
        }
    }

}

2.在activity中添加对应的observer. 注意：initView是自己封装了一层BaseActivity。在onCreate里面调用了initView()，所以initView相当于onCreate里面执行。

class LifecycleActivity : BaseActivity() {

    lateinit var binding: ActivityCommonBinding
    
    @SuppressLint("SetTextI18n")
    override fun initView() {
        binding = ActivityCommonBinding.inflate(layoutInflater)
        setContentView(binding.root)
        binding.tvContent.text = "LifecycleActivity"

        //初始化生命周期监听
        val locationLifecycleListener = LocationLifecycleListener {
            // TODO: 2021/9/2 接收到位置信息处理
        }
        //增加生命周期监听
        lifecycle.addObserver(locationLifecycleListener)
    }
}

监听fragment的生命周期

复用上方的LocationLifecycleListener生命周期监听，只需要在Fragment中注册监听即可。

class LifecycleFragment : Fragment() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val locationLifecycleListener = LocationLifecycleListener {
            // TODO: 2021/9/2 模拟接收地理数据
        }
        lifecycle.addObserver(locationLifecycleListener)
    }

}

使用LifecycleService解耦Service

LifecycleService继承自Service，并实现了LifecycleOwner接口。与Activity/Fragment类似，它也提供了一个名为getLifecycle()的方法供我们使用。
1.继承LifecycleEventObserver，实现service事件监听：在onStateChanged方法中可以监听到对应生命周期的变化。

class LocationServiceLifecycleListener : LifecycleEventObserver {
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        LogUtil.i("service event : $event")
    }
}

2.在LifeService中添加对应的监听

class MyLifecycleService : LifecycleService() {
    init {
        val locationServiceLifecycleListener = LocationServiceLifecycleListener()
        lifecycle.addObserver(locationServiceLifecycleListener)
    }
}

使用ProcessLifecycleOwner监听应用程序的生命周期

LifeCycle提供了一个名为ProcessLifecycleOwner的类，以方便我们知道整个应用程序的生命周期情况。

使用方式：

1.ProcessLifecycleOwner的使用方式与Activity、Fragment和Service是类似的，其本质也是观察者模式。需要在Application中进行观察者的注册。

class AppApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        //process 生命周期注册
        ProcessLifecycleOwner.get().lifecycle.addObserver(ProcessLifecycleObserver())
    }
}

2.创建名字为ProcessLifecycleObserver的类，实现LifecycleEventObserver接口。

class ProcessLifecycleObserver : LifecycleEventObserver {
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        LogUtil.i("service event : $event")
    }
}

注意点

process注册生命周期介绍：

* onCreate 在应用程序整个生命周期中只调用一次
* onStart 当应用程序出现在前台的时候被调用
* onResume 当应用程序出现在前台的时候被调用
* onPause 当应用程序退到后台时调用
* onStop 当应用程序退到后台时调用
* onDestroy 不调用

当应用程序从前台退到后台（用户按下Home键或任务菜单键），会依次调用ON_PAUSE和ON_STOP。注意，这两个方法的调用会有一定的延后。因为系统需要为“屏幕旋转，由于配置发生变化而导致Activity重新创建”的情况预留一些时间。系统需要保证当设备出现这种情况时，这两个事件不会被调用。因为当旋转屏幕时，你的应用程序并没有退到后台，它只是进入了横/竖屏模式而已。

实现监听app启动、进入前台、进入后台

通过ProcessLifecycleOwner优雅的实现监听，app启动、进入前台、进入后台。
1.完整的ProcessLifecycleObserver监听。

typealias processEvent = () -> Unit

class ProcessLifecycleObserver : LifecycleEventObserver {

    /**
     * process 上一个生命周期事件
     */
    var lastEvent = Lifecycle.Event.ON_ANY

    /**
     * app启动
     */
    var appStart: processEvent? = null
        private set

    /**
     * app回到前台
     */
    private var appForeground: processEvent? = null
        private set

    /**
     * app回到后台
     */
    private var appBackground: processEvent? = null
        private set

    /**
     * 注册APP 启动  回到前台  退到后台 事件
     */
    fun inject(
        appStart: processEvent? = null,
        appForeground: processEvent? = null,
        appBackground: processEvent? = null
    ) {
        this.appStart = appStart
        this.appForeground = appForeground
        this.appBackground = appBackground
    }

    /**
     * process event
     */
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        LogUtil.i("process lifecycle $event")

        //判断 APP 启动  回到前台  退到后台
        when (event) {
            Lifecycle.Event.ON_CREATE -> lastEvent = Lifecycle.Event.ON_CREATE
            Lifecycle.Event.ON_RESUME -> {
                if (lastEvent == Lifecycle.Event.ON_CREATE) {
                    //启动
                    appStart?.invoke()
                } else {
                    //回到前台
                    appForeground?.invoke()
                }
            }
            Lifecycle.Event.ON_STOP -> {
                //回到后台
                appBackground?.invoke()
                lastEvent = Lifecycle.Event.ON_STOP
            }
            else -> {
            }
        }
    }
}

2.application中继承使用。

class AppApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        //process 生命周期注册
        ProcessLifecycleOwner.get().lifecycle.addObserver(ProcessLifecycleObserver().also { processLifecycleObserver ->
            processLifecycleObserver.inject({
                //app启动
                LogUtil.i("app start")
            }, {
                //app进入前台
                LogUtil.i("app foreground")
            }, {
                //app进入后台
                LogUtil.i("app background")
            })
        })
    }
}