一、前言
生命周期，对于Android开发者来说一定不会陌生，它用于描述Activity/Fragment所处状态。通过各种生命周期回调，让开发者能够方便的执行各种数据初始化、逻辑控制以及资源的释放等操作。正是由于这样，在最初的Android开发过程中，大量的逻辑代码被写入Activity/Fragment，导致其代码量剧增、耦合严重、项目变得难以阅读和维护。
这时候便引入MVP、MVVM等架构分层思想，将逻辑代码从Activity/Fragment中脱离开来。可是分层带来的难题在于逻辑层（Presenter、ViewModel）难以感知视图层的生命周期，容易造成空指针异常和内存泄漏。那如何让视图层自动通知逻辑层生命周期的改变？
- 方案1：逻辑层声明各种生命周期方法，再让视图层在自身生命周期回调中主动调用对应的方法。
- 方案2：Jetpack的Lifecycle框架。
这里就不比较两种方案的优缺点了，毕竟前言只是为了引出Lifecycle框架出现的背景：
让组件能够感知到视图的生命周期。
这里我们以LifecycleRegistry为例，讲解addObserver的一系列操作，因为ComponentActivity、Fragment的getLifecycle()方法，都返回的是LifecycleRegistry对象。
注意： 注意回调是异步的，如果onStop占用太多耗时，导致onDestroy先于onStop执行，lifeCycle可以避免这个状况
接下来看LifecycleRegistry的addObserver方法
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
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;
}
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
首先observer的初始状态，如果宿主的状态mState不是DESTROYED，则设置其为INITIALIZED，此时我们发现，observer对象状态和owner状态并不同步，所以可想而知，后续代码极有可能是将observer状态和owner状态进行同步。每次同步也将会通知到observer。
然后将observer和initialState包装成ObserverWithState，并将其添加到mObserverMap中，如果mObserverMap中已存在observer对象，返回值previous将不为null，后续将不再执行，然后判断lifecycleOwner是否已经被释放，如果被释放，也直接返回。 调用calculateTargetState方法计算observer接下来需要迁移的状态。通过while循环，通过dispatchEvent不断去分发upEvent返回的状态。
private State calculateTargetState(LifecycleObserver observer) {
Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);
State siblingState = previous != null ? previous.getValue().mState : null;
State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1) : null;
return min(min(mState, siblingState), parentState);
}
private static Event upEvent(State state) {
switch (state) {
case INITIALIZED:
case DESTROYED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
case RESUMED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
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;
}
}
static State getStateAfter(Event event) {
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException("Unexpected event value " + event);
}
最终调用到mLifecycleObserver.onStateChanged(owner, event)，这里mLifecycleObserver即LiveData中传入的LifecycleBoundObserver
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
......
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
}
LifecycleBoundObserver在事件在分发过程中，会去检查宿主的生命周期状态，如果处于DESTROYED，调用removeObserver，移除掉自身监听。否则调用父类ObserverWrapper的activeStateChanged方法。shouldBeActive()方法，只有宿主状态大于STARTED，才表示宿主活跃。
private abstract class ObserverWrapper {
......
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
mActive = newActive;
boolean wasInactive = LiveData.this.mActiveCount == 0;
LiveData.this.mActiveCount += mActive ? 1 : -1;
if (wasInactive && mActive) {
onActive();
}
if (LiveData.this.mActiveCount == 0 && !mActive) {
onInactive();
}
if (mActive) {
dispatchingValue(this);
}
}
}
先判断LiveData中有多少个活跃的观察者对象，当LiveData首次注册一个观察者时，调用onActivity方法。当最后一个观察者被移除的时候，调用onInactive分发。如果mActive为true的话，会调用dispatchingValue方法。
@SuppressWarnings("WeakerAccess") /* synthetic access */
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {
considerNotify(initiator);
initiator = null;
} else {
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
其中调用considerNotify
@SuppressWarnings("unchecked")
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return;
}
// Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
//
// we still first check observer.active to keep it as the entrance for events. So even if
// the observer moved to an active state, if we've not received that event, we better not
// notify for a more predictable notification order.
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}
先判断宿主是否处于活跃状态，不是则调用observer.activeStateChanged(false);，否则，判断mVersion，最后调用到onChanged方法。
另一方法observeForever，在宿主被销毁时，并不会移除掉自身，必须用户手动移除，并且当其被添加到宿主时，就一直处于活跃状态。
@MainThread
public void observeForever(@NonNull Observer<? super T> observer) {
assertMainThread("observeForever");
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing instanceof LiveData.LifecycleBoundObserver) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
wrapper.activeStateChanged(true);
}
setValue则用于主线程更新value
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
这里调用dispatchingValue，并传递null，该方法传入null时，会遍历mObservers，并对每一个observer调用considerNotify。
postValue用于子线程更新value。
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
