Android ProcessLifecycleOwner 观察进程生命周期

简介

ProcessLifecycleOwner 直译，就是，进程生命周期所有者。
通过 DOC 注释了解到：

1. Lifecycle.Event.ON_CREATE 事件 在进程启动后，会收到一次；
2. Lifecycle.Event.ON_DESTROY 事件，永远不会收到；
3. 首个 activity 的 onStart , onResume 后，owner 会收到 同类型的事件 Lifecycle.Event.ON_START, Lifecycle.Event.ON_RESUME；
4. 最后的 Activity 的 onPause、onStop 后， owner 会收到 同类型事件Lifecycle.Event.ON_PAUSE, Lifecycle.Event.ON_STOP (系统保证了收到的事件是正常的，不会在配置更改而销毁和重新创建活动时发送这样的事件)

用于判断进程前后台很方便

其本身是个单例实现，源码:

@NonNull
public static LifecycleOwner get() {
    
    
    return sInstance;
}

---

使用

依赖

api "androidx.lifecycle:lifecycle-process:2.5.1"

用法1，结合 LiveData

数据变化的观察，将依赖于 进程的活动事件

liveData.observe(ProcessLifecycleOwner.get(), Observer {
    
    
    when (ProcessLifecycleOwner.get().lifecycle.currentState) {
    
    
    	Log.i("ProcessLifecycleOwner", "state: ${
      
      ProcessLifecycleOwner.get().lifecycle.currentState}")
        Lifecycle.State.STARTED, Lifecycle.State.RESUMED -> {
    
    
           ...
        }
        else -> {
    
    }
    }
})

要注意的是，Lifecycle.State 和 Lifecycle.Event 内的常量不是一一对应的
通过测试发现，当应用从后台回到前台时，日志会打印出 “state: STARTED” ；当应用在前台，再改变 liveData 的 value，日志会打印出 “state: RESUMED”

用法2，获取 owner的 lifecycle 实例，并对 lifecycle 添加观察者

ProcessLifecycleOwner.get().lifecycle.addObserver(LifecycleObserver observer) 

查看 LifecycleObserver 的 DOC 注释，建议不要直接使用该类；而是使用其子类 DefaultLifecycleObserver 或 LifecycleEventObserver

示例(可用于判断进程前后台)：

ProcessLifecycleOwner.get().lifecycle.addObserver(object: DefaultLifecycleObserver {
    
    
    override fun onCreate(owner: LifecycleOwner) {
    
    
        super.onCreate(owner)
    }

    override fun onStart(owner: LifecycleOwner) {
    
    
        super.onStart(owner)
    }

    override fun onResume(owner: LifecycleOwner) {
    
     // 应用前台
        super.onResume(owner)
    }

    override fun onPause(owner: LifecycleOwner) {
    
     // 应用后台
        super.onPause(owner)
    }

    override fun onStop(owner: LifecycleOwner) {
    
    
        super.onStop(owner)
    }

    override fun onDestroy(owner: LifecycleOwner) {
    
    
        super.onDestroy(owner)
    }
})

ProcessLifecycleOwner.get().lifecycle.addObserver(object: LifecycleEventObserver {
    
    
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
    
    
        when (event) {
    
    
        	Lifecycle.Event.ON_CREATE -> {
    
    
        		Log.e("ProcessLifecycleOwner", "ON_CREATE")
        	}
            Lifecycle.Event.ON_START -> {
    
    
                Log.e("ProcessLifecycleOwner", "ON_START")
            }
            Lifecycle.Event.ON_RESUME -> {
    
     // 应用前台
                Log.e("ProcessLifecycleOwner", "ON_RESUME")
            }
            Lifecycle.Event.ON_PAUSE -> {
    
     // 应用后台
                Log.e("ProcessLifecycleOwner", "ON_PAUSE")
            }
            Lifecycle.Event.ON_STOP -> {
    
    
                Log.e("ProcessLifecycleOwner", "ON_STOP")
            }
            else -> {
    
    }
        }
    }
})