一文搞懂Android-JetPack组件原理之Lifecycle、LiveData、ViewModel与源码分析技巧

LifecycRegistry

public class LifecycleRegistry extends Lifecycle {
/**

• 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),
  */
  private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();
  private State mState;
  private final WeakReference mLifecycleOwner;

public LifecycleRegistry(@NonNull LifecycleOwner provider) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
}

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

private void moveToState(State next) {
if (mState == next) {
return;
}
mState = next;
…
sync();
…
}
…
}

跟着源码可以定位到Lifecycle的实现类LifecycRegistry中，它主要是封装了对Lifecycle.Event的操作，包括了Lifecycle.Event与Lifecycle.State的同步，以及Lifecycle.State变化后通知观察者。

先来看handleLifecycleEnvent的实现，通过传进来的event获取一个state枚举值，具体的实现代码如下：

static State getStateAfter(Event event) {
switch(event) {
case ON_CREATE:
case ON_STOP:
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:
default:
throw new IllegalArgumentException("Unexpected event value " + event);
}
}

官网中有一张图用来解释Event和State的对应关系

getStateAfter()方法既是获取Event事件之后的状态，可以从图中的箭头方向可知具体的状态值，比如ON_START和ON_PAUSE的箭头都指向了STARTED状态，也就是这俩个事件后Lifecycle处于STARTED状态。

回到handleLifecycleEvent()方法，获取新状态后，就调用了moveToState()方法，该方法主要是判断新状态与当前状态相比是否发生改变，如果已改变，则调用sync()同步方法继续处理。

在进一步跟踪方法调用前，不妨先看看LifecycleRegistry有哪些属性，除了上面提到的mState来表示当前Lifecycle的状态外，还有一个比较特殊和重要的属性是mObserverMap。

/**

• 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),
  */
  private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();

该属性可看作是一个自定义的Map，是一个可遍历的集合，也就是说其中的元素是有序的，封装了监听者LifecycleObserver和监听者的封装ObserverWithState之间的映射关系，根据注释可以知道，在遍历操作其中的监听者时，会保证其中监听者的状态是从大到小排序的。

监听者的封装ObserverWithState则是维护了每一个监听者和其状态，该状态主要是为了给调用事件分发前的判断，另外，在分发Event事件后会同步更新自己的状态。

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;
}
}

接下来继续跟踪方法调用，来看看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);
  }
  Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
  if (!mNewEventOccurred && newest != null
  && mState.compareTo(newest.getValue().mState) > 0) {
  forwardPass(lifecycleOwner);
  }
  }
  mNewEventOccurred = false;
  }

该方法通过比较当前状态和mObserverMap元素的枚举值来确定是否分发事件，由于mObserverMap里元素是按状态的大到小排序的，所以这里只需要拿第一位和最后一位元素的状态与当前状态比较，就可以判断是否需要分发事件，以及是分发降级事件，还是分发升级事件。再具体一点说，如果mObserverMap里最大状态比当前状态大，那就需要调用backwardPass()，遍历mObserverMap，同步其中每一个observer状态的同时，分发降级事件，反之，如果mObserverMap里最小状态比当前状态小，就调用forwardPass()分发升级事件。

private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
Event event = downEvent(observer.mState);
pushParentState(getStateAfter(event));
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}

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
&am