JetPack——Lifecycle

Lifecycle是什么？

Lifecycle 是一个类，用于存储有关组件（如 activity 或 fragment）的生命周期状态的信息，并允许其他对象观测此状态

Lifeclcle解决什么问题？

class GPS(private val context: Context,private val callback: (GpsSTATE) -> Unit
) {private val TAG = "GPS"private var gpsState = GpsSTATE.CLOSEenum class GpsSTATE {CLOSE, OPEN}private fun prepareGps(): Boolean {Thread.sleep(3000)return true}fun start() {Thread {if (prepareGps()) {if (gpsState === GpsSTATE.CLOSE) {Log.d(TAG, "start: 开启gps")gpsState = GpsSTATE.OPENstateChange()}}}.start()}fun stop() {Thread {if (gpsState === GpsSTATE.OPEN) {gpsState = GpsSTATE.CLOSELog.d(TAG, "stop: 关闭gps")stateChange()}}.start()}private fun stateChange() {(context as Activity).runOnUiThread {callback.invoke(gpsState)}}
}

对于如上的GPS类，需要在onStart()时开启、onStop()时关闭

class MainActivity : AppCompatActivity() {private val TAG = "MainActivity"private lateinit var mGPS: GPSprivate var tv: TextView? = nulloverride fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_main)tv = findViewById<TextView>(R.id.tv)mGPS = GPS(this) {when (it) {GPS.GpsSTATE.CLOSE -> {Log.d(TAG, "UI change: GPS close")tv!!.text = "GPS close"}GPS.GpsSTATE.OPEN -> {Log.d(TAG, "UI change: GPS open")tv!!.text = "GPS open"}}}}public override fun onStart() {super.onStart()Log.d(TAG, "onStart: ")mGPS.start()}public override fun onStop() {super.onStop()Log.d(TAG, "onStop: ")mGPS.stop()}override fun onDestroy() {super.onDestroy()Log.d(TAG, "onDestroy: ")tv = null}
}

但在实际中，GPS类会在多个Activity/Fragment中使用从而产生大量样板代码，且上述代码在start()进行了耗时操作，在其完成前按返回键退出Activity，会错误的开启GPS且通过回调修改已经置空的UI导致报错

Lifecycle实现

本文使用的版本如下，版本不一样需要更新AS及Gradle

修改GPS类

• 实现DefaultLifecycleObserver，监听Activity的onStart()和onStop()处理业务
• 在状态至少为started的时候才开启GPS并回调更新UI

class GPS(private val context: Context,private val lifecycle: Lifecycle,private val callback: (GpsSTATE) -> Unit
) : DefaultLifecycleObserver {private val TAG = "GPS"private var gpsState = GpsSTATE.CLOSEenum class GpsSTATE {CLOSE, OPEN}private fun prepareGps(): Boolean {Thread.sleep(3000)return true}override fun onStart(owner: LifecycleOwner) {Thread {if (prepareGps()) {if (gpsState === GpsSTATE.CLOSE && lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {Log.d(TAG, "start: 开启gps")gpsState = GpsSTATE.OPENstateChange()}}}.start()}override fun onStop(owner: LifecycleOwner) {Thread {if (gpsState === GpsSTATE.OPEN) {gpsState = GpsSTATE.CLOSELog.d(TAG, "stop: 关闭gps")stateChange()}}.start()}private fun stateChange() {(context as Activity).runOnUiThread {callback.invoke(gpsState)}}
}

修改MainActivity，传入lifecycle和回调，注册监听，修改后的代码可以实现相同功能并解决问题，减少重复代码

class MainActivity : AppCompatActivity() {private val TAG = "MainActivity"private lateinit var mGPS: GPSprivate var tv: TextView? = nulloverride fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_main)tv = findViewById<TextView>(R.id.tv)mGPS = GPS(this, lifecycle) {when (it) {GPS.GpsSTATE.CLOSE -> {Log.d(TAG, "UI change: GPS close")tv!!.text = "GPS close"}GPS.GpsSTATE.OPEN -> {Log.d(TAG, "UI change: GPS open")tv!!.text = "GPS open"}}}lifecycle.addObserver(mGPS)}public override fun onStart() {super.onStart()Log.d(TAG, "onStart: ")}public override fun onStop() {super.onStop()Log.d(TAG, "onStop: ")}override fun onDestroy() {super.onDestroy()Log.d(TAG, "onDestroy: ")tv = null}
}

Lifecyclcle源码解析

LifecycleOwner

LifecycleOwner维护自身生命周期的Lifecycle变量

public interface LifecycleOwner {public val lifecycle: Lifecycle
}

Lifecycle

可向LifecycleOwner注册/取消监听LifecycleObserver（需在主线程）

通过Event和State来描述LifecycleOwner的生命周期变化（关系如下图），其中Any匹配所有Event，isAtLeast()判断当前状态是否大于指定状态

public abstract class Lifecycle {@MainThreadpublic abstract fun addObserver(observer: LifecycleObserver)@MainThreadpublic abstract fun removeObserver(observer: LifecycleObserver)@get:MainThreadpublic abstract val currentState: Statepublic enum class Event {ON_CREATE,ON_START,ON_RESUME,ON_PAUSE,ON_STOP,ON_DESTROY,ON_ANY;public val targetState: Stateget() {when (this) {ON_CREATE, ON_STOP -> return State.CREATEDON_START, ON_PAUSE -> return State.STARTEDON_RESUME -> return State.RESUMEDON_DESTROY -> return State.DESTROYEDON_ANY -> {}}throw IllegalArgumentException("$this has no target state")}public companion object {@JvmStaticpublic fun downFrom(state: State): Event? {return when (state) {State.CREATED -> ON_DESTROYState.STARTED -> ON_STOPState.RESUMED -> ON_PAUSEelse -> null}}@JvmStaticpublic fun downTo(state: State): Event? {return when (state) {State.DESTROYED -> ON_DESTROYState.CREATED -> ON_STOPState.STARTED -> ON_PAUSEelse -> null}}@JvmStaticpublic fun upFrom(state: State): Event? {return when (state) {State.INITIALIZED -> ON_CREATEState.CREATED -> ON_STARTState.STARTED -> ON_RESUMEelse -> null}}@JvmStaticpublic fun upTo(state: State): Event? {return when (state) {State.CREATED -> ON_CREATEState.STARTED -> ON_STARTState.RESUMED -> ON_RESUMEelse -> null}}}}public enum class State {DESTROYED,INITIALIZED,CREATED,STARTED,RESUMED;public fun isAtLeast(state: State): Boolean {return compareTo(state) >= 0}}
}

LifecycleRegistry

Lifecycle是抽象类，其实现类是LifecycleRegistry

• 通过Map存储LifecycleObserver和ObserverWithState
• 当currentState变化或调用handleLifecycleEvent()时，调用moveToState()、sync()、forwardPass()/backwardPass()、ObserverWithState中LifecycleEventObserver的dispatchEvent()、onStateChanged()

open class LifecycleRegistry private constructor(provider: LifecycleOwner,private val enforceMainThread: Boolean
) : Lifecycle() {private var observerMap = FastSafeIterableMap<LifecycleObserver, ObserverWithState>()private var state: State = State.INITIALIZEDoverride var currentState: Stateget() = stateset(state) {enforceMainThreadIfNeeded("setCurrentState")moveToState(state)}open fun handleLifecycleEvent(event: Event) {enforceMainThreadIfNeeded("handleLifecycleEvent")moveToState(event.targetState)}private fun moveToState(next: State) {if (state == next) {return}check(!(state == State.INITIALIZED && next == State.DESTROYED)) {"no event down from $state in component ${lifecycleOwner.get()}"}state = nextif (handlingEvent || addingObserverCounter != 0) {newEventOccurred = true// we will figure out what to do on upper level.return}handlingEvent = truesync()handlingEvent = falseif (state == State.DESTROYED) {observerMap = FastSafeIterableMap()}}override fun addObserver(observer: LifecycleObserver) {enforceMainThreadIfNeeded("addObserver")val initialState = if (state == State.DESTROYED) State.DESTROYED else State.INITIALIZEDval statefulObserver = ObserverWithState(observer, initialState)val previous = observerMap.putIfAbsent(observer, statefulObserver)if (previous != null) {return}val lifecycleOwner = lifecycleOwner.get()?: // it is null we should be destroyed. Fallback quicklyreturnval isReentrance = addingObserverCounter != 0 || handlingEventvar targetState = calculateTargetState(observer)addingObserverCounter++while (statefulObserver.state < targetState && observerMap.contains(observer)) {pushParentState(statefulObserver.state)val event = Event.upFrom(statefulObserver.state)?: throw IllegalStateException("no event up from ${statefulObserver.state}")statefulObserver.dispatchEvent(lifecycleOwner, event)popParentState()// mState / subling may have been changed recalculatetargetState = calculateTargetState(observer)}if (!isReentrance) {// we do sync only on the top level.sync()}addingObserverCounter--}override fun removeObserver(observer: LifecycleObserver) {enforceMainThreadIfNeeded("removeObserver")observerMap.remove(observer)}private fun forwardPass(lifecycleOwner: LifecycleOwner) {@Suppress()val ascendingIterator: Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> =observerMap.iteratorWithAdditions()while (ascendingIterator.hasNext() && !newEventOccurred) {val (key, observer) = ascendingIterator.next()while (observer.state < state && !newEventOccurred && observerMap.contains(key)) {pushParentState(observer.state)val event = Event.upFrom(observer.state)?: throw IllegalStateException("no event up from ${observer.state}")observer.dispatchEvent(lifecycleOwner, event)popParentState()}}}private fun backwardPass(lifecycleOwner: LifecycleOwner) {val descendingIterator = observerMap.descendingIterator()while (descendingIterator.hasNext() && !newEventOccurred) {val (key, observer) = descendingIterator.next()while (observer.state > state && !newEventOccurred && observerMap.contains(key)) {val event = Event.downFrom(observer.state)?: throw IllegalStateException("no event down from ${observer.state}")pushParentState(event.targetState)observer.dispatchEvent(lifecycleOwner, event)popParentState()}}}private fun sync() {val lifecycleOwner = lifecycleOwner.get()?: throw IllegalStateException("LifecycleOwner of this LifecycleRegistry is already " +"garbage collected. It is too late to change lifecycle state.")while (!isSynced) {newEventOccurred = falseif (state < observerMap.eldest()!!.value.state) {backwardPass(lifecycleOwner)}val newest = observerMap.newest()if (!newEventOccurred && newest != null && state > newest.value.state) {forwardPass(lifecycleOwner)}}newEventOccurred = false}@SuppressLint("RestrictedApi")private fun enforceMainThreadIfNeeded(methodName: String) {if (enforceMainThread) {check(ArchTaskExecutor.getInstance().isMainThread) {("Method $methodName must be called on the main thread")}}}internal class ObserverWithState(observer: LifecycleObserver?, initialState: State) {var state: Statevar lifecycleObserver: LifecycleEventObserverinit {lifecycleObserver = Lifecycling.lifecycleEventObserver(observer!!)state = initialState}fun dispatchEvent(owner: LifecycleOwner?, event: Event) {val newState = event.targetStatestate = min(state, newState)lifecycleObserver.onStateChanged(owner!!, event)state = newState}}
}

在ObserverWithState中为了兼容，需要通过Lifecycling.lifecycleEventObserver()判断是LifecycleEventObserver还是DefaultLifecycleObserver

public fun lifecycleEventObserver(`object`: Any): LifecycleEventObserver {val isLifecycleEventObserver = `object` is LifecycleEventObserverval isDefaultLifecycleObserver = `object` is DefaultLifecycleObserverif (isLifecycleEventObserver && isDefaultLifecycleObserver) {return DefaultLifecycleObserverAdapter(`object` as DefaultLifecycleObserver,`object` as LifecycleEventObserver)}if (isDefaultLifecycleObserver) {return DefaultLifecycleObserverAdapter(`object` as DefaultLifecycleObserver, null)}if (isLifecycleEventObserver) {return `object` as LifecycleEventObserver}......}

若是LifecycleEventObserver直接返回，若是DefaultLifecycleObserver则需要创建DefaultLifecycleObserverAdapter适配

internal class DefaultLifecycleObserverAdapter(private val defaultLifecycleObserver: DefaultLifecycleObserver,private val lifecycleEventObserver: LifecycleEventObserver?
) : LifecycleEventObserver {override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {when (event) {Lifecycle.Event.ON_CREATE -> defaultLifecycleObserver.onCreate(source)Lifecycle.Event.ON_START -> defaultLifecycleObserver.onStart(source)Lifecycle.Event.ON_RESUME -> defaultLifecycleObserver.onResume(source)Lifecycle.Event.ON_PAUSE -> defaultLifecycleObserver.onPause(source)Lifecycle.Event.ON_STOP -> defaultLifecycleObserver.onStop(source)Lifecycle.Event.ON_DESTROY -> defaultLifecycleObserver.onDestroy(source)Lifecycle.Event.ON_ANY ->throw IllegalArgumentException("ON_ANY must not been send by anybody")}lifecycleEventObserver?.onStateChanged(source, event)}
}

LifecycleObserver

LifecycleObserver只是一个接口，其实现类有LifecycleEventObserver和DefaultLifecycleObserver

public interface LifecycleObserver

LifecycleEventObserver

重写onStateChanged()，得到LifecycleOwner和Lifecycle.Event，判断当前所在生命周期

public fun interface LifecycleEventObserver : LifecycleObserver {public fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event)
}

DefaultLifecycleObserver

重写相关方法可直接监听生命周期

public interface DefaultLifecycleObserver : LifecycleObserver {public fun onCreate(owner: LifecycleOwner) {}public fun onStart(owner: LifecycleOwner) {}public fun onResume(owner: LifecycleOwner) {}public fun onPause(owner: LifecycleOwner) {}public fun onStop(owner: LifecycleOwner) {}public fun onDestroy(owner: LifecycleOwner) {}
}

FragmentActivity

自定义Activity继承AppCompatActivity，再继承FragmentActivity，创建LifecycleRegistry并在对应生命周期方法调用handleLifecycleEvent()

public class FragmentActivity extends ComponentActivity implementsActivityCompat.OnRequestPermissionsResultCallback,ActivityCompat.RequestPermissionsRequestCodeValidator {final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) {super.onCreate(savedInstanceState);mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);mFragments.dispatchCreate();}@Overrideprotected void onDestroy() {super.onDestroy();mFragments.dispatchDestroy();mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);}@Overrideprotected void onPause() {super.onPause();mResumed = false;mFragments.dispatchPause();mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);}@Overrideprotected void onPostResume() {super.onPostResume();onResumeFragments();}protected void onResumeFragments() {mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);mFragments.dispatchResume();}@Overrideprotected void onStart() {mFragments.noteStateNotSaved();super.onStart();......mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);mFragments.dispatchStart();}@Overrideprotected void onStop() {super.onStop();mStopped = true;markFragmentsCreated();mFragments.dispatchStop();mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);}

Fragment

同上，不再赘述