Jetpack--生命周期Lifecycle笔记

  Jetpack中的Lifecycle可以让我们感知Activity或Fragment生命周期的变化，进而可以让业务代码在组件的生命周期内执行。

  Lifecycle用于存储有关组件（Activity或Fragment）的生命周期状态的信息，并允许其他对象观察此状态。Lifecycle允许其他对象观察查询当前状态（通过isAtLeast方法）。

  LifecycleOwner是单一方法接口，表示类具有Lifecycle，它只有一个方法getLifecycle.LifecycleObserver可以注册到Lifecycle中，以观察其生命周期的变化。若使用自定义LifecycleOwner，可以使用LifecycleRegistry，然后将事件转发到LifecycleRegistry。LifecycleRegistry实现了Lifecycle。

  可以从官方给的图中看出生命周期状态的变化，它是一种升级和降级的状态变化，状态从小到大为DESTROYED，INITIALIZED，CREATED，STARTED，RESUMED。在Fragment或Activity创建后，其处于INITIALIZED状态，在发送ON_CREATE事件（onCreate方法被调用）后，Fragment的生命状态变为CREATED，在发送ON_START事件（onStart方法被调用）后，变为STARTED状态，以此类推。

  借由上图介绍一下Lifecycle.Event类中的几个方法：

  downFrom(State state)方法，此方法返回使“state”降一级的事件。例如，若state为RESUMED，则方法的返回值为ON_PAUSE事件，因为ON_PAUSE事件可以使状态RESUMED降为STARTED

  downTo(State state)方法，返回使状态将到state需要的事件。例如，若state为STARTED，则方法返回ON_PAUSE事件。

  upFrom(State state)方法，返回使状态“state”升一级的事件。例如，若state为STARTED，则方法返回ON_RESUME事件，因为ON_RESUME事件可以使状态STARTED升级为RESUMED。

  upTo(State state)方法，返回升级到状态“state”需要的事件。例如，若state为RESUMED，则方法返回ON_RESUME。

  getTargetState(Event event)，返回事件event发生后组件的状态。例如，若event为ON_START或ON_PAUSE，则方法返回STARTED，因为ON_START事件及ON_PAUSE事件发生后，组件的状态都会变为STARTED（区别为一个是升级为STARTED，一个是降级为STARTED）。

  接下来，以一个使用例子来从代码角度介绍Lifecycle的原理。

Lifecycle生命周期代码分析

  在这里，先给出一个例子，然后借由此例子介绍Lifecycle的实现原理。在Fragment中，可能会持有LiveData变量，并在LiveData中的数据发生改变时，进行一些操作。代码如下：

class MyFragment :Fragment(){
    var testLiveData:LiveData<String>  = MutableLiveData("value")
    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        return super.onCreateView(inflater, container, savedInstanceState)
        testLiveData.observe(viewLifecycleOwner, Observer {
          //省略逻辑操作
        })
    }
}

  在上面的代码中，testLiveData会在viewLifecycle的生命周期改变时，收到通知。若数据发生改变则会通知观察者，去做进一步处理。其实现逻辑是，将Observer对象封装到了LifecycleObserver对象中，以实现在view生命周期变化时，通知Observer的目的。在此，主要介绍Lifecycle，关于LiveData部分将在下一节介绍。先给出Lifecycle的类图：

  从图中可以看出，viewLifecyclerOwner的类型为FragmentViewLifecyclerOwner，其内部持有Lifecycle对象，即LifecycleRegistry，而LifecycleRegistry是Lifecycle的实现类，其内部持有一个LifecycleOwner的弱引用，和一组LifecycleObserver对象（生命周期的观察者）。这样在生命周期发生改变时，可以通过LifecycleRegistry的handleLifecycleEvent方法通知内部的观察者，被观察者的生命周期发生变化。

  Lifecycle中的观察者类为LifecyclerObserver，但是在Lifecycle体系中，通常还会创建一个类ObserverWithState来同时保存观察者和状态，这与LiveData有关联，LiveData的特性是只给处于活跃状态（STARTED或RESUMED）的观察者发送更新通知，因此，需要给观察者设置一个state，以表示观察者的状态。例如，在LifecycleRegistry中使用FastSafeIterableMap，以key--value的形式保存观察者及生命状态，其中key是LifecycleObserver，value就是ObserverWithState。ObserverWithState中保存了生命状态和观察者，其代码如下：

static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

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

        void dispatchEvent(LifecycleOwner owner, Event event) {
            //获取事件event对应的状态
            State newState = event.getTargetState();
            mState = min(mState, newState);
            //通知观察者，生命状态发生变化
            mLifecycleObserver.onStateChanged(owner, event);
            //根据事件event，更新状态
            mState = newState;
        }
    }

  当我们在使用自定义的lifecycle对象时，可以通过handleLifecycleEvent方法或markState方法来通知观察者生命状态发生改变。这2个方法的代码如下：

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent");
        moveToState(event.getTargetState());
    }

    public void markState(@NonNull State state) {
        enforceMainThreadIfNeeded("markState");
        setCurrentState(state);
    }
    public void setCurrentState(@NonNull State state) {
        enforceMainThreadIfNeeded("setCurrentState");
        //最终都调用此方法
        moveToState(state);
    }

  可以看到，这2个方法最终都会调用moveToState方法，moveToState方法代码如下：

    private void moveToState(State next) {
        //状态未发生变化，不需要处理
        if (mState == next) {
            return;
        }
        mState = next;
        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);
            }
            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                //有的观察者的状态低于当前状态，通知他们升级
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

  首先，调用isSynced检查是否需要让观察者同步状态，此方法会检查所注册观察者的状态是否与当前状态一致，若不一致（返回false），则需要通知观察者同步状态。接下来，从2个方面同步观察者的状态，1）、若存在状态等级高于当前状态的观察者，则调用backwardPass方法通知观察者让状态降级；2）、若存在状态等级低于当前状态的观察者，则调用forwardPasst方法通知观察者让状态升级。

  backwardPass方法的代码如下：

    private void backwardPass(LifecycleOwner lifecycleOwner) {
        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()))) {
                //根据观察者的当前状态，获取一个可以使当前状态降一级的事件
                Event event = Event.downFrom(observer.mState);
                if (event == null) {
                    throw new IllegalStateException("no event down from " + observer.mState);
                }
                pushParentState(event.getTargetState());
                //通知观察者生命周期状态发生改变，观察者会降低其状态。
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

  此方法会遍历所有注册的观察者，然后，针对每一个观察者，循环检查其状态是否高于当前状态，若高于当前状态，则先调用downFrom方法，获取一个可以使状态降一级的事件；再调用observer.dispatchEvent告知观察者生命周期发生变化，并使其生命状态降一级。

  forwardPass方法的代码如下：

    private void forwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            //循环升高观察者的状态，直至与当前状态相同
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                //根据观察者的状态，获取一个可以升高状态的事件
                final Event event = Event.upFrom(observer.mState);
                if (event == null) {
                    throw new IllegalStateException("no event up from " + observer.mState);
                } 
                //通知观察者 生命周期发生变化,并升级观察者中保存的状态
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

  forwardPass方法的逻辑与backwardPass方法相反，在此不再详细解释。

  Lifecycle除了在生命周期变化时通知观察者，也会在观察者刚刚注册时，给观察者发送通知，注册观察者的代码如下：

public void addObserver(@NonNull LifecycleObserver observer) {
        enforceMainThreadIfNeeded("addObserver");
        //设置观察者的初始状态，一般为INITIALIZED
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        //将观察者保存到mObserverMap中
        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 ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            //根据观察者的状态，获取一个升级状态的事件
            final Event event = Event.upFrom(statefulObserver.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " + statefulObserver.mState);
            }
            //通知观察者状态变化，并更新观察者的状态，在fragment中，通常在onCreateView中注册
            //观察者，这时候组件的生命状态为CREATED,所以会进入到此while循环，以通知观察者更新状态
            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--;
    }

  总结：在Lifecyle体系中，当组件的生命周期变化时会通知观察者，同时在观察者注册时，也会通知观察者。而观察者中通常也保存了生命状态（ObserverWithState）。在使用时，通常用LifecycleRegistry存储生命周期信息和观察者，从而发挥生命组件的作用。