Android Jetpack 之 Lifecycle

这是我参与更文挑战的第18天，活动详情查看：更文挑战

源码分析

生命周期注册者 (LifecycleRegistry)

我们再回到LifecycleRegistry

前面已经说过LifecycleRegistry是Lifecycle的直接子类

/**
 * An implementation of {@link Lifecycle} that can handle multiple observers.
 * <p>
 * It is used by Fragments and Support Library Activities. You can also directly use it if you have
 * a custom LifecycleOwner.
 */
public class LifecycleRegistry extends Lifecycle {
    //添加一个生命周期观察者(下文简称观察者),当生命周期所有者状态改变时将会进行通知.
    public void addObserver(@NonNull LifecycleObserver observer) {}
    //获取生命周期的当前状态.
    public State getCurrentState() {}
    //返回观察者的个数.
    public int getObserverCount() {} 
 
    //设置当前状态并通知观察者.
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {...}
    //从观察者列表中移除指定的观察者.
    public void removeObserver(@NonNull LifecycleObserver observer) {...}
}
复制代码

看注释知道LifecycleRegistry 本身就是一个成熟的 Lifecycle 实现类，它被实例化在Activity和Fragment中使用，如果我们需要自定义LifecycleOwner 并实现接口需要返回一个Lifecycle实例，完全可以直接在自定义LifecycleOwner中new一个LifecycleRegistry成员并返回它（简而言之就是：直接拿来用即可，上文分析普通Activity中如何实现时，就是直接用的，各位可以回头看下）。

我们先看下关于事件和状态的几个方法

public class LifecycleRegistry extends Lifecycle {
	static State getStateAfter(Event event) {
        //这个方法定义了Lifecycle.Event和这个方法定义了Lifecycle.State状态间的转化关系：
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }
    
    private static Event downEvent(State state) {
        switch (state) {
            case INITIALIZED:
                throw new IllegalArgumentException();
            case CREATED:
                return ON_DESTROY;
            case STARTED:
                return ON_STOP;
            case RESUMED:
                return ON_PAUSE;
            case DESTROYED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

    private static Event upEvent(State state) {
        switch (state) {
            case INITIALIZED:
            case DESTROYED:
                return ON_CREATE;
            case CREATED:
                return ON_START;
            case STARTED:
                return ON_RESUME;
            case RESUMED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }
    
}
复制代码

官方说请将 State 想象成一个图（graph）的节点（node），而 Event 就是这些节点之间的边（edge）。

状态之间的比较是根据Enum类的ordinal()值，即变量的声明顺序。值按照声明顺序递增。上图所示，左侧的INITIALIZED状态值为1，DESTROYED为0（因为这两个状态属于起始和结束时的状态，可以看作平级）；右侧RESUMED状态值为4。

由左向右状态改变为状态提升，即upEvent；由右向左状态改变为状态下降，即downEvent。通过事件传递来改变状态，从而调用生命周期回调，完成了对生命周期的控制。

接下来看下前面遗留的最关键点 handleLifecycleEvent()方法

handleLifecycleEvent()

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
}
复制代码

private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
    		// 当我们在 LifecycleRegistry 回调 LifecycleObserver 的时候触发状态变化时，
        	// mHandlingEvent 为 true；
        	// 添加 observer 的时候，也可能会执行回调方法，这时候如果触发了状态变化，
        	// 则 mAddingObserverCounter != 0
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            // 正在处理事件中或者正在处理添加 Observer 中
            mNewEventOccurred = true;
            // 不需要执行 sync。
            // 执行到这里的情况是：sync() -> LifecycleObserver -> moveToState()
            // 这里直接返回后，还是会回到 sync()，然后继续同步状态给 observer
            // we will figure out what to do on upper level.
            return;
        }
   		// 标记正在处理事件
        mHandlingEvent = true;
    	// sync() 会把状态的变化转化为生命周期事件，然后转发给 LifecycleObserver
        sync();
        mHandlingEvent = false;
    }
复制代码

	/**
     * Custom list that keeps observers and can handle removals / additions during traversal.
     * Invariant: at any moment of time for observer1 & observer2:
     * if addition_order(observer1) < addition_order(observer2), then
     * state(observer1) >= state(observer2),
     *
     * Invariant的规定：无论何时，先加入的observer的state值要大于后加入的observer的状态值
     * 这个规定影响了sync的实现
     */
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();

	private void sync() {
    	// 使用弱应用持有 LifecycleOwner，也是为了防止 Activity/Fragment 内存泄漏
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try 									dispatch new events from it.");
            return;
        }
        while (!isSynced()) {
            // mNewEventOccurred 是为了在 observer 触发状态变化时让 				backwardPass/forwardPass()
            // 提前返回用的。我们刚准备调他们，这里设置为 false 即可。
            mNewEventOccurred = false;
            
             //参照上文Invariant的规定，先加入的observer的state值一定要大于或等于后加入的observer的state值
            //那么在mObserverMap中，eldest(即队头)的state最大，newest(即队尾)的state最小。如果当前mState小于eldest的state值，说明mObserverMap中的值需要更新
            // 为了维持 mObserverMap 的 Invariant，这里我们需要从队尾往前更新元素的状态
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                 // 最先添加的 observer 的状态大于当前状态，回退
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
             // 如果 mNewEventOccurred，说明在上面调用 backwardPass() 时，客户触发了状态修改
             // 有新的事件发生，则放弃这次同步，延迟到下一次
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                // 最新添加的 observer 如果状态一致，则可以乐观地表示在它之前添加的 observer 状态也是一致的
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }
复制代码

 // 如果所有的 observer 的状态都已经同步完，则返回 true
private boolean isSynced() {
        if (mObserverMap.size() == 0) {
            return true;
        }
        // eldest 最先添加的，newest 最新添加的
        State eldestObserverState = mObserverMap.eldest().getValue().mState;
        State newestObserverState = mObserverMap.newest().getValue().mState;
    	// 因为我们保证队头的 state >= 后面的元素的 state，所以只要判断头尾就够了   
    	return eldestObserverState == newestObserverState && mState == newestObserverState;
    }
复制代码

sync() 的主要作用就是把 mObserverMap 里所有元素的状态都同步为 mState。

这里分为两种情况，一种是需要回退状态（backward），另外一种则是需要前进（forward），其中 backward 代码如下：

 private void backwardPass(LifecycleOwner lifecycleOwner) {
        // 使用 eldest(start) 判断是否需要回退 
        // 降序迭代，end -> start
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            // mNewEventOccurred 判断是否有新事件分发
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                // 回退
           		// 举个例子：observer.state 为 RESUMED
            	// mState 为 CREATED
            	// downEvent(observer.state) 为 ON_PAUSE
                Event event = downEvent(observer.mState);
                // getStateAfter(event) 为 STARTED
            	// 最终：RESUMED -> STARTED，在下一次同步中再同步为 CREATED
            	// pushParentState 和 popParentState 则是将 state 暂存在 List 中
                // 这个作用我们会在 addObserver 中讲
                pushParentState(getStateAfter(event));
                 // 分发事件
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }
复制代码

在看这个方法时，可以参考上面的状态图。比方说，假设当前队列里的元素都处于 CREATED。接着收到了一个 ON_START 事件，从图里面可以看出，接下来应该是要到 STARTED 状态。由于 STARTED 大于 CREATED，所以会执行 forwardPass()。forwardPass() 里面调用 upEvent(observer.mState)，返回从 CREATED 往上到 STARTED 需要发送的事件，也就是 ON_START，于是 ON_START 事件发送给了客户。

还有注意下 backwardPass() 的逻辑是将较大的状态逐步回退。为什么说是逐步呢？比如 observer.state 是 RESUMED，当前状态是 CREATED，那这里会分两次回退，分别为：RESUMED -> STARTED 和 STARTED -> CREATED

forwardPass() 逻辑类似，则不分析了。

上图可以看到，通过 mObserverMap 最终获取到一个 ObserverWithState 类型的 observer 对象，并调用它的dispatchEvent进行事件分发

继续看ObserverWithState 它是 LifecycleRegistry 的一个静态内部类。

static class ObserverWithState {
        State mState;
        GenericLifecycleObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            //getCallback就是用来转换LifecycleObserver的 详细分析见上文
            mLifecycleObserver = Lifecycling.getCallback(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
复制代码

从名称上就能看出，该类封装了 Observer 对象和 State 对象（具体就是 State 和 GenericLifecycleObserver，GenericLifecycleObserver 是个接口，继承自 LifecycleObserver），在其 dispatchEvent 方法中，最终会回调 mLifecycleObserver 的 onStateChanged(...)方法。

追踪到这里，我们知道了，Lifecycle在监听到生命周期变化之后，最终会回调 GenericLifecycleObserver# onStateChanged() 方法。

到这里我们先梳理一遍流程（以Fragment为例），

Fragment实现LifecycleOwner接口，提供一个LifecycleRegistry实例
在Fragment的各个生命周期内，调用LifecycleRegistry.handleLifecycleEvent(event)方法分发生命周期event
LifecycleRegistry.handleLifecycleEvent(event)会从mObserverMap取出ObserverWithState进行各种同步操作，在同步过程中，会调用ObserverWithState#dispatchEvent方法将生命周期event分发出去
handleLifecycleEvent方法会通过 getStateAfter 获取当前应处的状态的下一状态，然后通过moveToState方法修改当前状态值，然后调用sync方法通知了生命周期观察者,也就是我们实现了LifecycleObserver接口的类

在sync方法中,通过对比当前状态和上一状态来完成当前State的状态更新,在forwardPass和backwardPass方法中会从mObserverMap取出ObserverWithState 元素，一个一个的同步，同步中就可以看到事件派发方法了,ObserverWithState内部类的dispatchEvent方法。

现在就剩一个问题了，mObserverMap中的元素是怎么存进去的，我有查看下mObserverMap的调用之处，发现只有一个地方，那就是addObserver方法中

@Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        // ...
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
		// ...
    }
复制代码

而这个方法正好就是我们在Fragment中调用的