【Jetpack Architecture Components 之 Lifecycle】

Jetpack Architecture Components 之 Lifecycle

在本系列文章中，我们准备分析Jetpack 架构组件。首先我们从最基础的组件开始： Lifecycle， 可以说Jetpack 大部分架构组件都是基于Lifecycle 建立的，此也为Jetpack 架构组件的基础。

关于此此组件的介绍和简单使用方法，这里就不做过多介绍了，不清楚的可以直接看官方文档 ：传送门

我们这里主要通过代码结构来分析下组件设计和结构，先来看下Lifecycle的主要类关系图：
以上类图基本阐释了Lifecycle组件之间的关系，也是Lifecycle这个组件的本质的设计原理。从结构设计来看，这个设计主要就是基于观察者模式，比较简洁明了，相信大部分有设计模式经验的人看图就了解了Lifecycle的设计意图和结构。 那么，设计思想和结构有了，我们接下来就来看看在Android 中 是如何实现的。

Lifecycle 之 LifecycleRegistry

我们知道观察者模式的三个主要步骤：添加观察者，删除观察者，变更状态通知观察者。

由图一看出LifecycleRegistry类实现了Lifecycle 接口，那接下来我们就来看看LifecycleRegistry的实现。
我们想要观察一个Lifecycle,应该是调用Lifecycle的addObserver方法，那我们就到LifecycleResgistry中看看addObserver方法是如何实现的：

添加观察者

（下面我们看主要流程，其他细节先忽略，主要流程添加中文注释）

    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
   
        enforceMainThreadIfNeeded("addObserver");
    //初始化state
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    //1.  new 一个ObserverWithState对象，包含传入的Observer和初始状态state
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    //把刚才new出来的对象放入OberverMap中
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

	//如果Observer已经加入过了， 直接返回
        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;
    //2.  计算目标状态，计算规则后面看
        State targetState = calculateTargetState(observer);
    //记录当天处于addingObersver状态
        mAddingObserverCounter++;
    //当加入的Oberver的状态小于本Lifecycle的状态时
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
   
    //把当前状态作为parent状态入栈（如果在adding的时候，lifecycle的状态更新了， 或者反之， 计算目标状态的时候使用）
            pushParentState(statefulObserver.mState);
   	//获取当前状态的up Event
            final Event event = Event.upFrom(statefulObserver.mState);
            if (event == null) {
   
                throw new IllegalStateException("no event up from " + statefulObserver.mState);
            }
     //3.  dispatch Event
            statefulObserver.dispatchEvent(lifecycleOwner, event);
     //出栈Parent状态
            popParentState();
            // mState / subling may have been changed recalculate
    //重新计算目标状态
            targetState = calculateTargetState(observer);
        }
	//如果不是重入，则同步
        if (!isReentrance) {
   
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }

好，那我么再来看看1处的OberverWithState是个什么东东：

    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 = event.getTargetState();
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

嗯， 这里就是对LifecycleObserver 和 其当状态的一个封装。这里有一个很特别的类Lifecycling, 它其实就是把我们用各种方式实现的LifecycleObserver进行统一的封装管理，都封装成LifecycleEventObserver类型，以便下面dispatchEvent统一调用。
好，我们继续来看dispatchEvent。
dispatchEvent很简单，就是根据Event找到对应的状态，然后设置为当前Observer的状态，然后分发事件给Observer的实现类，然后再结合addObserver（2， 3 处）时的循环计算目前状态然后分发，就可以实现Observer事件的有序性，就是不会一上来就只分发个最终状态，所以Observer接受的事件一定是有序的，如官方文档的图：

状态和事件只能是沿着箭头方向顺序的进行，不能跳过。

至于parentState的作用，可以参考大佬分析 ： 传送门

删除观察者

删除就很简单了，这里就不跟踪了。

状态变更通知

再回过头来看下LifecycleRegistery类， 涉及到状态变更的public方法只有makeState， setCurrentState, 和handleLifecycleEvent三个，而且这三个类都是调用moveToState方法改变状态的，那我们就来看看moveToState