State 与 Event

lifecycle 的核心思路是 在 activity 中填加一 ReportFragment，由 fragment 中生命周期函数触发 lifecycle 的回调。

每调用一次生命周期相关函数时，lifecycle 会将该函数的调用转换成 event 传递给 lifecycle 库

// ReportFragment

public void onResume() {  
    super.onResume();  
    dispatchResume(mProcessListener);  
    // 将调用到的方法封装成 event 
    // 最终该 event 会传递给 LifecycleRegistry::handleLifecycleEvent 中
    // 这个函数中会将 event 转换成 state 
    dispatch(Lifecycle.Event.ON_RESUME);  
}

而 event 与 state 的转换函数是 Event 枚举中定义的 getTargetState() 函数：

// 当某个生命周期执行完时，应该处于什么状态
public State getTargetState() {  
    switch (this) {// this 是 Event 对象，可以理解为 onCreate 等生命周期函数  
        case ON_CREATE:  // 执行完 onCreate 以后，state 就会前进到 CREATED 状态
        case ON_STOP:  // 执行完 onStop 后，会回退至 CREATED 状态
            return State.CREATED;  
        case ON_START:  
        case ON_PAUSE:  
            return State.STARTED;  
        case ON_RESUME:  
            return State.RESUMED;  
        case ON_DESTROY:  
            return State.DESTROYED;  
        case ON_ANY:  
            break;  
    }  
    throw new IllegalArgumentException(this + " has no target state");  
}

Observer 的处理

lifecycle 接收的 Observer 是 LifecycleObserver 对象，该对象分为两种：

1. LifecycleEventObserver：只接收 event 事件
2. FullLifecycleObserver：将事件自动转换成 onCreate() 等生命周期方法

重合周期的回调始于 ReportFragment 中的各种生命周期函数，经过 LifeRegistery::sync() 函数

// LifeRegistery
private void sync() {  
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();   
    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) {  
            // 这里就会从 mObserverMap 取值并调用它的 dispatchEvent() 函数 
            backwardPass(lifecycleOwner);  
        }  
        ...
    }  
    mNewEventOccurred = false;  
}

private void backwardPass(LifecycleOwner lifecycleOwner) {  
    // 遍历 mObserverMap
    Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator = mObserverMap.descendingIterator();  
    while (descendingIterator.hasNext() && !mNewEventOccurred) {  
        Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();  
        ObserverWithState observer = entry.getValue();  
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred  
        && mObserverMap.contains(entry.getKey()))) {  
            // 由 state 又还原成 event
            Event event = Event.downFrom(observer.mState);  
            // ...
            observer.dispatchEvent(lifecycleOwner, event);  
            // ...
        }  
    }  
}

// 添加的各种生命周期观察者最终都由 addObserver 完成添加
public void addObserver(@NonNull LifecycleObserver observer) {  
    enforceMainThreadIfNeeded("addObserver");  
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED; 
    // 对 observer 进行包装
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);  
    // 保存至 mObserverMap 字段中，而上面的 sync 会从该字段中取值处理
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
}

经过上面的注册及分发逻辑，可以发现最终调用的是 ObserverWithState::dispatchEvent() 函数

static class ObserverWithState {  
    State mState;  
    LifecycleEventObserver mLifecycleObserver;  

    ObserverWithState(LifecycleObserver observer, State initialState) {
        // 参数 observer 是我们传入的 observer
        // 这里会进行包装
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);  
        mState = initialState;  
    }  

    void dispatchEvent(LifecycleOwner owner, Event event) {  
        // ...
        mLifecycleObserver.onStateChanged(owner, event);  
        // ...
    }  
}

对原始 observer 的包装如下：

    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
        if (isFullLifecycleObserver) {
            // 如果接收的是 onCreate() 待生命周期方法，包装一层
            // 这一层包装也很简单，就是根据 event 调用不同的生命周期方法
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }

        if (isLifecycleEventObserver) {
            // 如果接收 Event 事件，不需要处理
            return (LifecycleEventObserver) object;
        }

        // ...
    }