初入Android开发的同学，第一个开始接触的就是四大组件，而在四大组件中第一个必须掌握的技能就是其对应的生命周期，但是很多时候在过往的做法中，我们会将系统组件的生命周期与普通组件耦合在一起，那么，有没有什么办法可以将系统组件的生命周期与普通组件之间分开呢？答案就是使用Jetpack 系列中的Lifecycle。
Lifecycle的简介
LifeCycle 是一个可以感知宿主生命周期变化的组件。常见的宿主包括 Activity/Fragment、Service 和 Application。LifeCycle 会持有宿主的生命周期状态的信息，当宿主生命周期发生变化时，会通知监听宿主的观察者。
Lifecycle的优点
- 降低系统组件
（Activity/Fragment、Service 和 Application）和普通组件之间的耦合。 - 将通用代码从业务层剥离，有利于后期的代码维护和扩展。
Lifecycle的作用场景
1.Activity/Fragment
2.Service
3.Application
在使用LifeCycle的时候，我们需要注意，被观察者需要去实现LifecycleOwner 接口，观察者需要去实现LifecycleObserver 接口。
Lifecycle的应用
1.Lifecycle在Activity/Fragment中的使用
1.添加依赖
implementation 'androidx.appcompat:appcompat:1.2.0'
在 AndroidX 里面 ComponentActivity 已经默认实现了 LifecycleOwner 接口。如果项目没有迁移到 AndroidX，还是用的 Support 库，新版本的 SDK 也通过 SupportActivity 实现了 LifecycleOwner 接口。
2.实现观察者
class WorkUtil : LifecycleObserver {
companion object {
const val TAG = "LifecycleActivity"
var whetherToCount = true
var count = 0
}
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun create(){
Log.d(TAG, "create：----")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun start() {
whetherToCount = true
Thread(Runnable {
while (whetherToCount) {
Thread.sleep(1000)
count++
Log.d(TAG, "onResume：$count")
}
}).start()
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun stop() {
Log.d(TAG, "onStop：----")
whetherToCount = false
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun destroy() {
whetherToCount = false
count = 0
Log.d(TAG, "onDestroy：$count")
}
}
一般情况下，为了代码的可读性和后期的可扩展性，我们会将可观察者与业务层的代码进行剥离，而触发事件的发送则通过LifeCycle的注解来进行实现。
3.实现被观察者
在Activity中，只要使用的Activity是ComponentActivity及其子类的话，系统就已经默认帮你实现了LifecycleOwner 接口，你可以直接拿到Lifecycle的实例
class LifecycleActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_lifecycle)
lifecycle.addObserver(WorkUtil())
}
}
但是如果你直接使用的是Activity的话，则需要你直接注册并进行添加
class LifecycleActivity : Activity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_lifecycle)
val mLifecycleRegistry = LifecycleRegistry(this)
mLifecycleRegistry.addObserver(WorkUtil())
}
}
接下来你会发现，在你运行的时候，每当执行Activity对应的生命周期的方法的时候都会同步执行WorkUtil类中对应的注解所包含的方法。Fragment与Activity写法一致，这里就不过多展示了。
2.Lifecycle在Service中的使用
Lifecycle在Service中的使用与在Activity中的使用类似。
1.添加依赖
implementation "androidx.lifecycle:lifecycle-service:2.2.0"
2.实现观察者
class WorkUtil : LifecycleObserver {
companion object {
const val TAG = "LifecycleActivity"
var whetherToCount = true
var count = 0
}
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun create(){
Log.d(TAG, "create：----")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun start() {
whetherToCount = true
Thread(Runnable {
while (whetherToCount) {
Thread.sleep(1000)
count++
Log.d(TAG, "onResume：$count")
}
}).start()
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun stop() {
Log.d(TAG, "onStop：----")
whetherToCount = false
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun destroy() {
whetherToCount = false
count = 0
Log.d(TAG, "onDestroy：$count")
}
}
3.实现被观察者
class MyService : LifecycleService() {
init {
lifecycle.addObserver(WorkUtil())
}
}
需要注意的是，在使用Service的时候，不是继承Service类而是继承LifecycleService类。
3.Lifecycle在Application中的使用
1.添加依赖
implementation "androidx.lifecycle:lifecycle-process:2.2.0"
2.实现观察者
class WorkUtil : LifecycleObserver {
companion object {
const val TAG = "LifecycleActivity"
var whetherToCount = true
var count = 0
}
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun create(){
Log.d(TAG, "create：----")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun start() {
whetherToCount = true
Thread(Runnable {
while (whetherToCount) {
Thread.sleep(1000)
count++
Log.d(TAG, "onResume：$count")
}
}).start()
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun stop() {
Log.d(TAG, "onStop：----")
whetherToCount = false
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun destroy() {
whetherToCount = false
count = 0
Log.d(TAG, "onDestroy：$count")
}
}
3.实现被观察者
class IApplication : Application(), Listener {
companion object {
const val TAG = "IApplication"
}
override fun onCreate() {
super.onCreate()
ProcessLifecycleOwner.get().lifecycle.addObserver(WorkUtil())
}
}
总结：其实Lifecycle相对来说使用起来非常的简单，并没有太多高深的东西，其主要使用的就是配合注解达到实现监听的效果。其真正的核心在于在实际的应用开发过程中如何与业务组件进行解耦，我觉得这是使用Lifecycle需要好好去思考的问题。
最后附上一个实现监听APP位于前台与后台的小功能
/**
* @author: zhoufan
* @date: 2021/8/31 11:19
*/
interface Listener {
/**
* APP位于前台
*/
fun onBecomeForeground()
/**
* APP位于后台
*/
fun onBecomeBackground()
}
/**
* @author: zhoufan
* @date: 2021/8/31 11:10
* 监听 Activity的生命周期的方法
* 同步判断APP前台后台的状况
*/
class ForegroundCallbacks : Application.ActivityLifecycleCallbacks {
private var runnable: Runnable? = null
private var handler: Handler? = null
private var onResume = false
private var onPause = true
private var listener: Listener? = null
fun addListener(listener: Listener) {
this.listener = listener
handler = Handler(Looper.myLooper()!!)
}
companion object {
const val TAG = "ForegroundCallbacks"
private var instance: ForegroundCallbacks? = null
fun init(appApplication: IApplication): ForegroundCallbacks {
instance = ForegroundCallbacks()
appApplication.registerActivityLifecycleCallbacks(instance)
return instance!!
}
}
override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
Log.d(TAG, "onActivityCreated: ${activity.componentName}")
}
override fun onActivityStarted(activity: Activity) {
Log.d(TAG, "onActivityStarted: ${activity.componentName}")
}
override fun onActivityResumed(activity: Activity) {
Log.d(TAG, "onActivityResumed: ${activity.componentName}")
onPause = false
runnable?.run {
handler?.removeCallbacks(this)
}
handler?.postDelayed(Runnable {
if (!onResume) {
onResume = true
listener?.onBecomeForeground()
}
}.also { runnable = it }, 600)
}
override fun onActivityPaused(activity: Activity) {
Log.d(TAG, "onActivityPaused: ${activity.componentName}")
onPause = true
runnable?.run {
handler?.removeCallbacks(this)
}
handler?.postDelayed(Runnable {
if (onResume && onPause) {
onResume = false
listener?.onBecomeBackground()
}
}.also { runnable = it }, 600)
}
override fun onActivityStopped(activity: Activity) {
Log.d(TAG, "onActivityStopped: ${activity.componentName}")
}
override fun onActivityDestroyed(activity: Activity) {
Log.d(TAG, "onActivityDestroyed: ${activity.componentName}")
}
override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {
Log.d(TAG, "onActivitySaveInstanceState: ${activity.componentName}")
}
}
class IApplication : Application(), Listener {
companion object {
const val TAG = "IApplication"
}
override fun onCreate() {
super.onCreate()
// 设置监听
ForegroundCallbacks.init(this).addListener(this)
}
override fun onBecomeForeground() {
Log.d(TAG, "onBecameForeground: 在前台")
}
override fun onBecomeBackground() {
Log.d(TAG, "onBecameForeground: 在后台")
}
}
