当前为 2.3.1 版本
本文分析 LiveData 更新原理，涉及 LifecycleBoundObserver 绑定 Lifecycle 对生命周期变化进行监听。
首先看 LiveData.ovserve() 方法
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// 此处 return，了解到 Glide 在 onDestroy() 后加载图片抛出异常处理
return;
}
//1. LifecycleBoundObserver 为 LifecycleObserver
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
//2. owner 获取 Lifecycle 并跟 wrap 绑定，使得 wrapper 监听生命周期
owner.getLifecycle().addObserver(wrapper);
}
接下来看 LifecycleBoundObserver
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@NonNull
final LifecycleOwner mOwner;
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
@Override
boolean shouldBeActive() {
//对应 onStart、onPause、onResume 状态，可以查看 Lifecycle.getTargetState() 方法 对应生命周期 state 赋值情况
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
//Activity\Fragment 生命周期变化会回调此方法。
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
if (currentState == DESTROYED) {
//DESTROYED 移除监听
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
//1.1 查看 shouldBeActive() 方法，如果是 onStart onResume onPause 状态则判定活动状态，可更新值
//1.2 回到 ObserverWrapper.activeStateChanged() 方法
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
//移除监听
mOwner.getLifecycle().removeObserver(this);
}
}
ObserverWrapper.activeStateChanged 方法
private abstract class ObserverWrapper {
boolean mActive;
//保存当前的监听值的版本，用于跟 LiveData 的版本比较，小于 LiveData 值的版本则需要更新。
int mLastVersion = START_VERSION;
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
mActive = newActive;
changeActiveCounter(mActive ? 1 : -1);
//isAtLeast(STARTED)为true，mActive 为 true，则继续分发 value
if (mActive) {
//1.3 回到 LiveData 的 dispatchingValue 方法。
dispatchingValue(this);
}
}
}
Livecycle state 赋值和活动状态判断如下
public abstract class Lifecycle {
@NonNull
public State getTargetState() {
switch (this) {
case ON_CREATE:
case ON_STOP:
return State.CREATED;
case ON_START:
case ON_PAUSE:
//STARTED 对应 onStart、onPause 生命周期
return State.STARTED;
case ON_RESUME:
//RESUMED 对应 onResume 生命周期
return State.RESUMED;
case ON_DESTROY:
return State.DESTROYED;
case ON_ANY:
break;
}
}
//对应 State 类型
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
// isAtLeast(STARTED) 最小为 STARTED、RESUMED 状态，对应生命周期如上
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
回到 LiveData.dispatchingValue()
void dispatchingValue(@Nullable ObserverWrapper initiator) {
...
do {
if (initiator != null) {
//1.4
considerNotify(initiator);
initiator = null;
} else {
...
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return;
}
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
//重要！！！，observer 跟 LiveData 分别保存数据的 version 值，没修改一次 value，则版本号 +1
//当 LiveData 的版本号 大于 observer 的版本号，则说明需要监听的值修改，则回调监听
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
//1.5 回调监听，即完成监听
observer.mObserver.onChanged((T) mData);
}
以上流程分析了调用 observe 方法时，LiveData 内部创建 LifecycleBoundObserver 对象，该对象实现 LifecycleObserver 接口并注册 Livecycle 实现对生命周期变化监听。
当生命周期变化时候，在 LifecycleBoundObserver 中判断是否在活动状态，即 onStart、onResume、onPause 状态，如果是，则依次调用 dispatchingValue () -> considerNotify() 方法，当值的 version 未改变则 return，当判定 version 已经改变了，则回调 Observer.onChanged 完成监听。
下面来看主动调用 LiveData.setValue() 监听
protected void setValue(T value) {
assertMainThread("setValue");
//版本++
mVersion++;
mData = value;
//继续分发，回到上面的流程
dispatchingValue(null);
}
postValue 是通过 Handler 发送 Runnable 到主线程继续执行 setValue 的过程。
注意：
数据倒灌问题：如果先执行 LiveData.setValue() 再调用 observe 监听，此时 LiveData mVersion 已经改变为0，ObserverWrapper 的 mLastVersion 还是为 -1，所以订阅时仍会收到 onChanged 回调。可以使用 SingleLiveEvent 避免。
