Android Lifecycles组件（生命周期感知组件）的简单使用

 

生命周期注册

public class LifecycleRegistry 
extends Lifecycle 

java.lang.Object
   ↳	androidx.lifecycle.Lifecycle
 	   ↳	androidx.lifecycle.LifecycleRegistry

该实现Lifecycle可以处理多个观察者。

片段和支持库活动使用它。如果您具有自定义的LifecycleOwner，也可以直接使用它。

摘要
公共建设者
LifecycleRegistry(LifecycleOwner provider)
为给定提供者创建一个新的LifecycleRegistry。

公开方法
void	addObserver(LifecycleObserver observer)
添加一个LifecycleObserver，当LifecycleOwner更改状态时，将通知该服务器。

Lifecycle.State	getCurrentState()
返回生命周期的当前状态。

int	getObserverCount()
观察者数量。

void	handleLifecycleEvent(Lifecycle.Event event)
设置当前状态并通知观察者。

void	markState(Lifecycle.State state)
不建议使用此方法。使用setCurrentState(State)。

void	removeObserver(LifecycleObserver observer)
从观察者列表中删除给定的观察者。

void	setCurrentState(Lifecycle.State state)
将生命周期移至给定状态，并将必要的事件分派给观察者。

继承的方法
从班级 androidx.lifecycle.Lifecycle
从班级 java.lang.Object
公共建设者
生命周期注册
公共LifecycleRegistry（LifecycleOwner提供程序）
为给定提供者创建一个新的LifecycleRegistry。

通常，您应该在LifecycleOwner类的构造函数中创建此对象，并保留相同的实例。

参量
provider	LifecycleOwner：所有者LifecycleOwner
公开方法
addObserver
public void addObserver（LifecycleObserver观察器）
添加一个LifecycleObserver，当LifecycleOwner更改状态时，将通知该服务器。

给定的观察者将进入LifecycleOwner的当前状态。例如，如果LifecycleOwner在Lifecycle.State.STARTED状态，给定的观察者会收到Lifecycle.Event.ON_CREATE，Lifecycle.Event.ON_START事件。

参量
observer	LifecycleObserver：观察者通知。
getCurrentState
公共Lifecycle.State getCurrentState（）
返回生命周期的当前状态。

退货
Lifecycle.State	生命周期的当前状态。
getObserverCount
public int getObserverCount（）
观察者数量。

退货
int	观察者数量。
handleLifecycleEvent
公共无效handleLifecycleEvent（Lifecycle.Event事件）
设置当前状态并通知观察者。

请注意，如果的currentState状态与上次对此方法的调用相同，则调用此方法无效。

参量
event	Lifecycle.Event：收到的事件
markState
公共无效markState（Lifecycle.State状态）
不建议使用此方法。
使用setCurrentState(State)。

将生命周期移至给定状态，并将必要的事件分派给观察者。

参量
state	Lifecycle.State：新状态
removeObserver
公共无效removeObserver（LifecycleObserver观察器）
从观察者列表中删除给定的观察者。

如果在调度状态更改时调用此方法，

如果给定的观察者尚未接收到该事件，它将不会接收到该事件。
如果给定的观察者使用多种方法来观察当前调度的事件，并且至少有一个接收到该事件，则所有这些人都将接收到该事件，然后将其删除。
参量
observer	LifecycleObserver：要删除的观察者。
setCurrentState
公共无效setCurrentState（Lifecycle.State状态）
将生命周期移至给定状态，并将必要的事件分派给观察者。

参量
state	Lifecycle.State：新状态

 

package com.example.myjeptdemo

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.*
import com.example.myjeptdemo.entity.requestEntity.NeiHanEntity
import com.example.myjeptdemo.entity.responResult.NeiHanResult
import com.example.myjeptdemo.viewmodel.NeiHanViewModel
import com.jiutong.base.utils.LogUtils

abstract class BaseActivity : AppCompatActivity(), LifecycleOwner {
    private lateinit var mRegistry: LifecycleRegistry
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mRegistry = LifecycleRegistry(this)
        mRegistry.currentState = Lifecycle.State.CREATED
     //通过一下方法的使用，可以同步感知activity的 生命状态
        MediaCompoment(this)//其他非activity组件使用
         lifecycle.addObserver(object : LifecycleEventObserver {
            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
            }
        })
    }

    override fun onStart() {
        super.onStart()
        mRegistry.currentState = Lifecycle.State.STARTED
        mRegistry!!.handleLifecycleEvent(Lifecycle.Event.ON_START)
        LogUtils.d(mRegistry.currentState.toString())
    }

    override fun onResume() {
        super.onResume()
        mRegistry.currentState = Lifecycle.State.RESUMED
        mRegistry!!.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
        LogUtils.d(mRegistry.currentState.toString())
    }

    override fun onPause() {
        super.onPause()
        mRegistry!!.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        LogUtils.d(mRegistry.currentState.toString())
    }

    override fun onStop() {
        super.onStop()
        mRegistry!!.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
        LogUtils.d(mRegistry.currentState.toString())
    }

    override fun onDestroy() {
        super.onDestroy()
        mRegistry.currentState = Lifecycle.State.DESTROYED
        mRegistry!!.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        LogUtils.d(mRegistry.currentState.toString())
    }

其他非activity组件使用

class MediaCompoment(mLifecycleOwner: LifecycleOwner) {
    fun onCreate() {
        Log.d(TAG, "onCreate:")
    }

    fun onStart() {
        LogUtils.d(TAG, "onStart:")
    }

    fun onResume() {
        LogUtils.d(TAG, "onResume:")
    }

    fun onPause() {
        LogUtils.d(TAG, "onPause:")
    }

    fun onStop() {
        LogUtils.d(TAG, "onStop:")
    }

    fun onDestroy() {
        LogUtils.d(TAG, "onDestroy:")
    }

    companion object {
        private const val TAG = ""
    }

    init {
        mLifecycleOwner.lifecycle
            .addObserver(LifecycleEventObserver { source: LifecycleOwner?, event: Lifecycle.Event ->
                if (event == Lifecycle.Event.ON_CREATE) {
                    onCreate()
                } else if (event == Lifecycle.Event.ON_START) {
                    onStart()
                } else if (event == Lifecycle.Event.ON_RESUME) {
                    onResume()
                } else if (event == Lifecycle.Event.ON_PAUSE) {
                    onPause()
                } else if (event == Lifecycle.Event.ON_STOP) {
                    onStop()
                } else if (event == Lifecycle.Event.ON_DESTROY) {
                    onDestroy()
                }
            })
    }
}