Android Jetpack(1)--Lifecycle源码解析

介绍

Lifecycle 是一个生命周期感知组件，一般用来响应Activity、Fragment等组件的生命周期变化，并将变化通知到已注册的观察者。能够帮助你生成更易于维护的、更有组织的、更轻量级的代码。同时，LiveData 与 ViewModel 的 lifecycle 也依赖于 Lifecycle 框架。

基本使用

实现LifecycleObserver 接口，使用@OnLifecycleEvent注解在方法上，表示该方法对应生命周期的哪个函数

class MyLifecycleObserver() : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create() {
        Log.d("MyLifecycleObserver", "create")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun start() {
        Log.d("MyLifecycleObserver", "start")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun resume() {
        Log.d("MyLifecycleObserver", "resume")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun pause() {
        Log.d("MyLifecycleObserver", "pause")
    }
}

然后将LifecycleObserver添加到Lifecycle的观察者列表

class BlankFragment : Fragment() {
	override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Log.d("BlankFragment", "onCreate")
        lifecycle.addObserver(MyLifecycleObserver())
    }
}

Fragment 使用的是androidx.fragment.app包下的 Fragment, 默认实现了LifecycleOwner接口。

输出日志如下：

2021-01-24 18:21:53.664 1446-1446/cn.com.jack.fragmentwithlivedata D/BlankFragment: onCreate 
2021-01-24 18:21:53.666 1446-1446/cn.com.jack.fragmentwithlivedata D/MyLifecycleObserver: create
2021-01-24 18:21:53.712 1446-1446/cn.com.jack.fragmentwithlivedata D/BlankFragment: onStart 
2021-01-24 18:21:53.712 1446-1446/cn.com.jack.fragmentwithlivedata D/MyLifecycleObserver: start
2021-01-24 18:21:53.716 1446-1446/cn.com.jack.fragmentwithlivedata D/BlankFragment: onResume 
2021-01-24 18:21:53.717 1446-1446/cn.com.jack.fragmentwithlivedata D/MyLifecycleObserver: resume

源码分析

类图

可以看到Fragment实现了LifecycleOwner接口，并且持有实现了Lifecycle的LifecycleRegistry对象。LifecycleRegistry中聚合了LifecycleObserver，当生命周期改变时通知LifecycleObserver中相应的方法。

如何实现生命周期感知的

通过类图的分析，我们知道Fragment实现了LifecycleOwner接口，因此我们可以通过getLifecycle()方法获取生命周期对象Lifecycle。上源码，省略无关代码

public class Fragment implements xxx, LifecycleOwner{
    
    LifecycleRegistry mLifecycleRegistry;
    
	@Override
    @NonNull
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    
    private void initLifecycle() {
        // 可以看到，getLifecycle()返回的实际上是 LifecycleRegistry 对象
        mLifecycleRegistry = new LifecycleRegistry(this);
        ...
    }
}

那么Fragemnt持有LifecycleRegistry干什么用呢？

我们接着看Fragemnt的performXXX()方法们，这些方法是Fragemnt生命周期要改变时首先调用的方法

void performCreate(Bundle savedInstanceState) {
    ...
    // 先调用 Fragment 生命周期 onCreate() 方法
    onCreate(savedInstanceState);
    ...
    // 然后进行生命周期事件分发
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}

void performStart() {
    ...
    onStart();
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);    
}

void performResume() {
    ...
    onResume();
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);    
}

void performPause() {
    ...
    // 这里反过来了，先分发生命周期事件
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    ...
    // 然后再调用 Fragment 的生命周期方法
    onPause();    
}

void performStop() {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    ...
    onStop();
}

void performDestroy() {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
    ...
    onDestroy();    
}

注意：Fragment中performCreate()、performStart()、performResume()会先调用自身的onXXX()方法，然后再调用LifecycleRegistry的handleLifecycleEvent()方法；而在performPause()、performStop()、performDestroy()中会先LifecycleRegistry的handleLifecycleEvent()方法 ，然后调用自身的onXXX()方法。

现在我们知道是如何进行生命周期感知的了，一切都和performXXX()方法有关。现在生命周期事件传递到了LifecycleRegistry的handleLifecycleEvent()方法，下面我们分析它是如何通知 observer 的。

LifecycleRegistry 详解

LifecycleRegistry中重要的方法其实只有两个：addObserver()和handleLifecycleEvent()

addObserver()方法是当我们向其中添加观察者的时候需要调用的

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

    if (previous != null) {
        return;
    }
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        // it is null we should be destroyed. Fallback quickly
        return;
    }

    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
    // 这里是 while 循环，新添加的LifecycleObserver ，会不断更新自己的生命周期到指定的 targetState
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        popParentState();
        // mState / subling may have been changed recalculate
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        // we do sync only on the top level.
        sync();
    }
    mAddingObserverCounter--;
}

handleLifecycleEvent()方法用来处理生命周期事件

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    // 根据 event 得到状态
    State next = getStateAfter(event);
    moveToState(next);
}

getStateAfter()方法会按照下图根据Event返回对应的State

下面看moveToState()方法

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    mState = next;
    // mHandlingEvent 表示正在处理事件，所以不需要再次调用
    // mAddingObserverCounter != 0 表示正在添加observer（在函数addObserver），满足此条件，最后会调用sync()，所以这里不需再次调用
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        // we will figure out what to do on upper level.
        return;
    }
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
}

下面看sync()方法

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                + "garbage collected. It is too late to change lifecycle state.");
    }
    while (!isSynced()) {
        mNewEventOccurred = false;
        // no need to check eldest for nullability, because isSynced does it for us.
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

该方法通过比较当前状态和mObserverMap中的状态来决定如何分发事件。由于mObserverMap里元素是按状态的大到小排序的，所以这里只需要拿第一位和最后一位元素的状态与当前状态比较，如果mObserverMap里最大状态比当前状态大，那就需要调用backwardPass()分发降级事件，反之，如果mObserverMap里最小状态比当前状态小，就调用forwardPass()分发升级事件。

private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            pushParentState(observer.mState);
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
            popParentState();
        }
    }
}

private void backwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            Event event = downEvent(observer.mState);
            pushParentState(getStateAfter(event));
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

forwardPass()和backwardPass()类似，分别是以升序和降序的方式遍历mObserverMap中的observer，再以while循环方式通过upEvent()和downEvent()获取下一步的Event事件，并通过observer.dispatchEvent()分发事件和同步状态。直到mObserverMap中的每一个observer的状态都与当前状态一致为止。

至此我们知道Lifecycle如何使用，以及如何感知Fragment、Activity的生命周期，并分析了LifecycleRegistry的源码。

官方文档

Android官方架构组件:Lifecycle详解&原理分析

Lifecycle 使用与源码分析——彻底搞懂Lifecycle原理