带你了解lifecycle

前言

Lifecycle是用来管理Activity、Fragment、Application的生命周期变化，它是LiveData、ViewModel的基础。在深入了解lifecycle前我们先思考以下几个问题。

• Lifecycle有几种创建方式？推荐使用哪种？
• Lifycycle是如何实现生命周期的管理的？
• ObserverWithState 是如何统一接口的？
• Lifycycle是粘性的吗？
• 什么是嵌套事件？Lifecycle是怎么解决的？

源码

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    enforceMainThreadIfNeeded("addObserver");
    /***
     *  1.如果是在onDestroy注册，mstate==DESTROY,事件不再分发。如果是在其他生命周期注册，mState都
     * 赋值为 INITIALIZED,保证观察者定义的所有生命周期不会缺失，保证功能的完成性。   
     */
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
   
     /***
      * mObserverMap 是一个双链表，能保证注册的observer的顺序。 
     * 
     */
    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;
    }

    //  isReentrance 用于处理事件嵌套的标记位
    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    // 也是用于解决嵌套使用的
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;

    //通过循环把新观察者的状态连续地同步到最新状态的mState，
    //如果观察者在较晚的生命周期添加，也会把之前的事件分发(upFrom)给观察者，
    //即Lifecycle是粘性的。
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        final Event event = Event.upFrom(statefulObserver.mState);

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

接下来我们来看一下Lifecycle是如何同步Observe状态，并分发事件的

private void sync() {
    //  mState和activity的生命周期相关 
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();

    while (!isSynced()) {
        mNewEventOccurred = false;
        //  如果当前观察者的状态大于当前状态值，需要通知观察者减小状态值
        //  直至两者相等
        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;
}

// 向前传递事件
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();
        }
    }
}

自定义Lifecycle方式不一样，回调方法也不相同。但为什么事件分发的实现类ObserverWithState都是调用onStateChange()去做处理的，它是如何做到统一的呢？

static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

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

答案就是使用适配器模式，将不同的接口适配成 LifecycleEventObserver。

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) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }

        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }

        final Class<?> klass = object.getClass();
        //关键代码
        int type = getObserverConstructorType(klass);
        if (type == GENERATED_CALLBACK) {
            List<Constructor<? extends GeneratedAdapter>> constructors =
                    sClassToAdapters.get(klass);
            if (constructors.size() == 1) {
                GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                        constructors.get(0), object);
                return new SingleGeneratedAdapterObserver(generatedAdapter);
            }
            GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
            for (int i = 0; i < constructors.size(); i++) {
                adapters[i] = createGeneratedAdapter(constructors.get(i), object);
            }
            return new CompositeGeneratedAdaptersObserver(adapters);
        }
        return new ReflectiveGenericLifecycleObserver(object);
    }

从上述代码可以看出，推荐使用 LifecycleEventObserver和 DefaultLifecycleObserver（继承了FullLifecycleObserver）使用Lifecycle，其他方式使用了Apt和反射降低了运行和编译的效率。