理解Jetpack--Lifecycle

时亚东
417 阅读4分钟

Lifecycle是什么

Lifecycle也是Jetpack家族中的一员。它能监听到Activity/Fragment生命周期的变化，简化开发者实现生命周期感知型组件的复杂度。

如何使用

Lifecycle是观察者模式实现，我们需要定义观察者类，并注册观察者，这样我们就能在我们自己定义的观察者中监听到被观察者的生命周期的变化。

实现观察者的方式有三种，DefaultLifecycleObserver，LifecycleEventObserver，LifecycleObserver+@OnLifecycleEvent，官方推荐前两种方式，第三种是由反射实现的，对性能有一定的影响。我们下面分别看看三种方式。

  1. 继承DefaultLifecycleObserver
class MyDefaultLifecycleObserver:DefaultLifecycleObserver {
    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        Log.d(TAG, "onCreate: ")
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        Log.d(TAG, "onStop: ")
    }

    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        Log.d(TAG, "onStart: ")
    }

    override fun onResume(owner: LifecycleOwner) {
        super.onResume(owner)
        Log.d(TAG, "onResume: ")
    }

    override fun onPause(owner: LifecycleOwner) {
        super.onPause(owner)
        Log.d(TAG, "onPause: ")
    }

    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        Log.d(TAG, "onDestroy: ")
    }

    companion object{const val TAG="MyDefaultLifecycleObserver"}
}
  1. 实现LifecycleEventObserver接口
class MyLifecycleEventObserver :LifecycleEventObserver{
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when(event){
            Lifecycle.Event.ON_CREATE->{}
            Lifecycle.Event.ON_START->{}
            Lifecycle.Event.ON_RESUME->{}
            Lifecycle.Event.ON_PAUSE->{}
            Lifecycle.Event.ON_STOP->{}
            Lifecycle.Event.ON_DESTROY->{}
            else->throw IllegalStateException()
        }
    }
}
  1. 实现LifecycleObserver接口+事件注解
class MyLifecycleObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
    }
}

上面我们定义好了生命周期的观察者，接下来就是把我们定义的观察者与被观察者绑定，调用Lifecycle的addObserver(observer LifecycleObserver)方法绑定，这样我们就能监听到Activity生命周期的变化。代码如下：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        lifecycle.addObserver(MyDefaultLifecycleObserver())
    }

}

源码分析

我们定义的Activity的父类，实现了LifecycleOwner接口，该接口的getLifecycle()方法返回一个Lifecycle，该接口的定义如下：

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    public val lifecycle: Lifecycle
}

看一下父类ComponentActivity的实现，返回了LifecycleRegistry。代码如下：

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner{
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    
    ...
}

其实我们使用的不是ComponentActivity类中定义的LifecycleRegistry，而是FragmnetActivity重写getLifecycle()方法返回的LifecycleRegistry。代码如下:

public class FragmentActivity extends ComponentActivity implements
        ActivityCompat.OnRequestPermissionsResultCallback,
        ActivityCompat.RequestPermissionsRequestCodeValidator {

    ...
    final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);
 
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        // Instead of directly using the Activity's Lifecycle, we
        // use a LifecycleRegistry that is nested exactly outside of
        // when Fragments get their lifecycle changed
        // TODO(b/127528777) Drive Fragment Lifecycle with LifecycleObserver
        return mFragmentLifecycleRegistry;
    }
}

我们在绑定观察者与被观察者时，会调用LifecycleRegistry的addObserver(observer: LifecycleObserver)方法，具体代码如下：

override fun addObserver(observer: LifecycleObserver) {
    enforceMainThreadIfNeeded("addObserver")
    val initialState = if (state == State.DESTROYED) State.DESTROYED else State.INITIALIZED
    //把定义的观察者包装成ObserverWithState
    val statefulObserver = ObserverWithState(observer, initialState)
    //把包装后的ObserverWithState缓存在observerMap中
    val previous = observerMap.putIfAbsent(observer, statefulObserver)
    if (previous != null) {
        return
    }
    val lifecycleOwner = lifecycleOwner.get()
        ?: // it is null we should be destroyed. Fallback quickly
        return
    val isReentrance = addingObserverCounter != 0 || handlingEvent
    var 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 recalculate
        targetState = calculateTargetState(observer)
    }
    if (!isReentrance) {
        // we do sync only on the top level.
        sync()
    }
    addingObserverCounter--
}

这里把我们定义的LifecycleObserver包装成ObserverWithState，并把包装后的对象缓存在observerMap中，方便后面分发。关于observerMap我就不详细说明了，它其实就是一个Map,有兴趣的可以自行查看。这里还会进行状态对齐(产生粘性状态的原因)，这里和后面要讲的状态向前对应完全一样，我们后面分析状态对齐时再详细了解。下面我们看一下ObserverWithState的实现：

internal class ObserverWithState(observer: LifecycleObserver?, initialState: State) {
    var state: State
    var lifecycleObserver: LifecycleEventObserver

    init {
        //把我们定义的LifecycleObserver统一成LifecycleEventObserver
        lifecycleObserver = Lifecycling.lifecycleEventObserver(observer!!)
        state = initialState
    }

    fun dispatchEvent(owner: LifecycleOwner?, event: Event) {
        val newState = event.targetState
        state = min(state, newState)
        lifecycleObserver.onStateChanged(owner!!, event)
        state = newState
    }
}

ObserverWithState把我们定义的LifecycleObserver统一成LifecycleEventObserver。如何统一的这里不展开说明了，有兴趣的可以看Lifecycling.lifecycleEventObserver(observer!!)这段代码的实现。其内部对我们实现LifecycleObserver的三种方式分别做了转换，这三种方式在上面的章节有介绍，其中第三种注解方式是通过反射实现，对性能有一定影响，这大概是官方不推荐使用这种的原因吧。

ObserverWithState 还有一个dispatchEvent(...)方法，dispatchEvent(...)方法在被观察者生命周期发生变化，会被调用。那如何监听到Activity生命周期变化的呢？实现监听的方式和早期版本的Glide实现生命周期监听的方式一样，在Activity中一个没有界面的Fragment，通过监听Fragment生命周期变化，从而间接的监听到Activity生命周期变化。下面的代码在ComponentActivity的onCreate（）方法中添加了一个无界面ReportFragment。

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
   ...
    ReportFragment.injectIfNeededIn(this);
    ...
}

我们看看ReportFragment如何实现的？重点看看injectIfNeededIn(...)方法

open class ReportFragment() : android.app.Fragment() {
   ...
    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        ...
        dispatch(Lifecycle.Event.ON_CREATE)
    }

    override fun onStart() {
        super.onStart()
        ...
        dispatch(Lifecycle.Event.ON_START)
    }

    override fun onResume() {
        super.onResume()
       ...
        dispatch(Lifecycle.Event.ON_RESUME)
    }

    override fun onPause() {
        super.onPause()
        dispatch(Lifecycle.Event.ON_PAUSE)
    }

    override fun onStop() {
        super.onStop()
        dispatch(Lifecycle.Event.ON_STOP)
    }

    override fun onDestroy() {
        super.onDestroy()
        dispatch(Lifecycle.Event.ON_DESTROY)
        // just want to be sure that we won't leak reference to an activity
        processListener = null
    }

    private fun dispatch(event: Lifecycle.Event) {
        if (Build.VERSION.SDK_INT < 29) {
            // Only dispatch events from ReportFragment on API levels prior
            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
            // added in ReportFragment.injectIfNeededIn
            dispatch(activity, event)
        }
    }

    @RequiresApi(29)
    internal class LifecycleCallbacks : Application.ActivityLifecycleCallbacks {
        ...

        companion object {
            @JvmStatic
            fun registerIn(activity: Activity) {
                activity.registerActivityLifecycleCallbacks(LifecycleCallbacks())
            }
        }
    }

    companion object {
        private const val REPORT_FRAGMENT_TAG =
            "androidx.lifecycle.LifecycleDispatcher.report_fragment_tag"

        @JvmStatic
        fun injectIfNeededIn(activity: Activity) {
            if (Build.VERSION.SDK_INT >= 29) {
                // On API 29+, we can register for the correct Lifecycle callbacks directly
                LifecycleCallbacks.registerIn(activity)
            }
            // Prior to API 29 and to maintain compatibility with older versions of
            // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
            // need to support activities that don't extend from FragmentActivity from support lib),
            // use a framework fragment to get the correct timing of Lifecycle events
            val manager = activity.fragmentManager
            if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
                manager.beginTransaction().add(ReportFragment(), REPORT_FRAGMENT_TAG).commit()
                // Hopefully, we are the first to make a transaction.
                manager.executePendingTransactions()
            }
        }

        @JvmStatic
        internal fun dispatch(activity: Activity, event: Lifecycle.Event) {
            if (activity is LifecycleRegistryOwner) {
                activity.lifecycle.handleLifecycleEvent(event)
                return
            }
            if (activity is LifecycleOwner) {
                val lifecycle = (activity as LifecycleOwner).lifecycle
                if (lifecycle is LifecycleRegistry) {
                    lifecycle.handleLifecycleEvent(event)
                }
            }
        }

      
    }
}

injectIfNeededIn(...)方法，在API29及以上版本使用Application.ActivityLifecycleCallbacks监听生命周期，29以下使用Fragment生命周期方法监听生命周期变化，最终都会调用dispatch(activity: Activity, event: Lifecycle.Event)方法。由于我们Activity实现了LifecycleOwner，最终会调用LifecycleRegistry的handleLifecycleEvent(event: Event) 方法。

在我们看handleLifecycleEvent(event: Event) 方法的具体实现前，我们需要了解Lifecycle的Event和State。代码如下：

 public enum class Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY;
    }

    /**
     * Lifecycle states. You can consider the states as the nodes in a graph and
     * [Event]s as the edges between these nodes.
     */
    public enum class State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        public fun isAtLeast(state: State): Boolean {
            return compareTo(state) >= 0
        }
    }
}

Event的变化如何驱动State的变化呢？这个地方必须理解，否则很难明白后面的状态是如何对齐的，关系如下图：

sequenceDiagram
INITIALIZED->>CREATED: ON_CREATE
CREATED->>STARTED:ON_START
STARTED->>RESUMED:ON_RESUME
RESUMED->>STARTED:ON_PAUSE
STARTED->>CREATED:ON_STOP
CREATED->>DESTROYED:ON_DESTROY

我们再来看handleLifecycleEvent(event: Event) 方法的具体实现

open fun handleLifecycleEvent(event: Event) {
    //event.targetState是事件对应的状态。
    //再把状态移到对应的状态上
    moveToState(event.targetState)
}
  1. 这里先通过Event计算出该事件对应的目标状态，代码如下：
public val targetState: State
    get() {
        when (this) {
            ON_CREATE, ON_STOP -> return State.CREATED
            ON_START, ON_PAUSE -> return State.STARTED
            ON_RESUME -> return State.RESUMED
            ON_DESTROY -> return State.DESTROYED
            ON_ANY -> {}
        }
        throw IllegalArgumentException("$this has no target state")
    }
  1. 判断当前状态是否已经是目标状态，如果是就不处理了，反之更新当前状态为目标状态。代码如下：
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 = next
    if (handlingEvent || addingObserverCounter != 0) {
        newEventOccurred = true
        // we will figure out what to do on upper level.
        return
    }
    handlingEvent = true
    //同步状态，状态对齐。
    sync()
    handlingEvent = false
    if (state == State.DESTROYED) {
        observerMap = FastSafeIterableMap()
    }
}
  1. 状态对齐，把我们创建的观察者的状态与当前状态对齐。代码如下：
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 = false
        //向后对齐
        if (state < observerMap.eldest()!!.value.state) {
            backwardPass(lifecycleOwner)
        }
        //向前对齐
        val newest = observerMap.newest()
        if (!newEventOccurred && newest != null && state > newest.value.state) {
            forwardPass(lifecycleOwner)
        }
    }
    newEventOccurred = false
}

状态对齐分为向前对齐和向后对齐。

3.1 向前对齐。当前状态大于观察者中的状态时，出现向前对齐。我们前面讲绑定观察者时也会进行状态对齐，那里的对齐方式就是向前对齐。

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()
        }
    }
}

下面是先前对齐时，状态转换成事件的方法。

@JvmStatic
public fun upFrom(state: State): Event? {
    return when (state) {
        State.INITIALIZED -> ON_CREATE
        State.CREATED -> ON_START
        State.STARTED -> ON_RESUME
        else -> null
    }
}

这里会遍历所有的观察者，通过Event.upFrom方法把状态State转换成事件Event，然后调用dispatchEvent分发，我们的观察者就能监听到生命周期的变化了。细心的您可能会发现，这里有两层while循环，第一层是遍历所有的观察者，第二层是因为状态可能多个，状态对齐需要一步步完成，不能跨状态。

3.2 向后对齐，当前状态小于观察者中的状态，出现向后对齐。

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()
        }
    }
}

下面是向后对齐时，状态转换成事件的代码。

@JvmStatic
public fun downFrom(state: State): Event? {
    return when (state) {
        State.CREATED -> ON_DESTROY
        State.STARTED -> ON_STOP
        State.RESUMED -> ON_PAUSE
        else -> null
    }
}

向后对齐与先前对齐相似，这里就不详细说明了。

思考

我们学习完了Lifecycle，那在Activity不同的生命周期函数中使用lifecycle.addObserver(...)，观察者调用的方法有什么区别呢？

在onCreate中添加

override fun onCreate(savedInstanceState: Bundle?) {
    ...
    lifecycle.addObserver(MyDefaultLifecycleObserver())
}

结果：

create.png

在onStart中添加

override fun onStart() {
    super.onStart()
    lifecycle.addObserver(MyDefaultLifecycleObserver())
}

结果：

start.png

在onResume中添加

override fun onResume() {
    ...
    lifecycle.addObserver(MyDefaultLifecycleObserver())
}

结果：

resume.png

在onPause中添加

override fun onPause() {
    ...
    lifecycle.addObserver(MyDefaultLifecycleObserver())
}

结果：

pause.png

在onStop中添加

override fun onStop() {
    ...
    lifecycle.addObserver(MyDefaultLifecycleObserver())
}

结果：

stop.png

在onDestroy中添加

override fun onDestroy() {
    ...
    lifecycle.addObserver(MyDefaultLifecycleObserver())
}

结果：什么都没有调用。

为什么在不同的地方调用会出现不同的结果呢？下面我们对onPause添加产生的原因简单分析一下：

我们在源码分析时说过，LifecycleObserver会被包装成ObserverWithState，状态被初始化成State.INITIALIZED，我们在onPause调用后当前state=State.STARTED。ObserverWithState的state小于当前state，会进行状态先前对齐。下面是对齐（粘性状态）过程：

sequenceDiagram
INITIALIZED->>CREATED: ON_CREATE
CREATED->>STARTED:ON_START

生命周期发生变化，再进行的状态对齐过程：

sequenceDiagram
STARTED->>CREATED:ON_STOP
CREATED->>DESTROYED:ON_DESTROY

所以在LifecycleObserver会调用onCreate()->onStart()->onStop()->onDestroy()

那在Activity其它的生命周期函数中使用lifecycle.addObserver(...)，出现的情况是不是也了解了呢？，自己分析吧。

avatar
文章
阅读
粉丝