1. Livedata特性
LiveData 是一种可观察的数据存储器类。并且具有生命周期感知能力，能遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。
1.1 只有当它关联的应用组件处于生命周期活跃状态时，才会通知对应观察者。
1.2 当关联的应用组件的状态变为 DESTROYED 时，便可移除此观察者，避免内存泄露。
1.3 LiveData 仅在数据发生更改时才发送更新，并且仅发送给活跃观察者。此行为的一种例外情况是，观察者从非活跃状态更改为活跃状态时也会收到更新。此外，如果观察者第二次从非活跃状态更改为活跃状态，则只有在自上次变为活跃状态以来，值发生了更改时，它才会收到更新。
2. 原理介绍
2.1 Livedata.observe方法
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
//如当前LifecycleOwner的状态的是DESTROYED，就不绑定
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
//创建一个LifecycleBoundObserver（生命周期限制的观察者）
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
//将观察者添加到mObservers map
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
//如果已经存在并且观察者对应的LifecycleOwner不是之前绑定的LifecycleOwner报错
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
//如果存在直接返回
if (existing != null) {
return;
}
//将观察者生命周期和LifecycleOwner对应的Lifecycle绑定
//当LifecycleOwner的生命周期发生变化时，回调LifecycleBoundObserver中的 onStateChanged
owner.getLifecycle().addObserver(wrapper);
}
1，observe方法先判断LifecycleOwner是否已经处于DESTROYED的状态，如果是就不绑定；
2，然后将创建一个LifecycleBoundObserver，并且将observer和LifecycleBoundObserver添加到观察者map中；
3，最后将LifecycleBoundObserver和LifecycleOwner的生命周期绑定。
2.2 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() {Å
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
// 当LifecycleOwner生命周期发生变化时，调用这个函数
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
//LifecycleOwner生命周期改变时，如果LifecycleOwner生命周期处于活跃状态，更新数据
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
1，当LifecycleOwner的生命周期变化是会调用LifecycleBoundObserver的onStateChanged方法；
2，判断LifecycleOwner如果处于DESTROYED，移除观察者；
3，否则如果当前是活跃状态，就将最新值通知给所有观察者。
2.3 ObserverWrapper
private abstract class ObserverWrapper {
final Observer<? super T> mObserver;
boolean mActive;
int mLastVersion = START_VERSION;
ObserverWrapper(Observer<? super T> observer) {
mObserver = observer;
}
abstract boolean shouldBeActive();
boolean isAttachedTo(LifecycleOwner owner) {
return false;
}
void detachObserver() {
}
void activeStateChanged(boolean newActive) {
//判断和上次生命周期是否发生变化，没变化直接返回
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
mActive = newActive;
changeActiveCounter(mActive ? 1 : -1);
//有变化，且是活跃状态，更新数据
if (mActive) {
dispatchingValue(this);
}
}
}
2.4 Livedata.dispatchingValue
void dispatchingValue(@Nullable ObserverWrapper initiator) {
//如果正在刷新数据，mDispatchInvalidated置为true，表示之前的刷新无效
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
//如果ObserverWrapper不为null，则只刷新传入的ObserverWrapper
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;
}
1，如果传入观察者，则只刷新当前观察者，用于LifecycleOwner生命周期改变时，因为所有的观察者都绑定了LifecycleOwner的生命周期，所以这里还是刷新所有观察者；
2，如果没有传入观察者，遍历观察者map，刷新所有观察者，用于Livedata持有数据改变时；
3，如果刷新的时候，此方法被再次调用，会放弃当前刷新，重新再开始下一轮刷新。
2.5 Livedata.considerNotify
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.
/ 如果当前LifecycleOwner的生命周期是非活跃，不回调onChanged
//并在LifecycleBoundObserver 中记录状态，当生命周期变为活跃，去更新数据
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
//调用观察者的onChanged
observer.mObserver.onChanged((T) mData);
}
2.5 Livedata.setValue
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
setValue也是调用了dispatchingValue方法，传的参数时null，更新所有观察者。
总结：
Livedata通知观察者分为两种情况
1，LifecycleOwner生命周期从非活跃变成活跃状态时：
Livedata添加一个观察者时，会关联一个LifecycleOwner，然后把这个观察者包装成一个LifecycleBoundObserver，和LifecycleOwner的Lifecycle关联，当LifecycleOwner的生命周期变化时，会调用LifecycleBoundObserver的onStateChanged方法，在这个方法中判断当前生命周期和上次的生命周期是否是同一类型（要么活跃要么非活跃），如果是，就直接返回，避免重复通知（start通知了，resume就不需要通知了），如果不是同一类型，并且当前生命周期是活跃状态，就调用dispatchingValue方法通知观察者，判断LifecycleOwner是否时活跃状态，如果是，将Livedata中持有的最新更新给观察者。
2，Livedata中的值改变时：
同样是调用dispatchingValue，判断LifecycleOwner是否时活跃状态，如果是，就遍历通知所有观察者。
3，livedata粘性事件：第一次添加观察者会收到数据，原因是，LifecycleOwner向观察者刷新生命周期事件，解决方法：自定义一个类实现livedata，定义一个atomicboolean变量，初始值为false，setvalue设置为true，在这个类发消息给观察者前，将这个变量从ture转成false。
3. 参考
1，https://blog.csdn.net/xx326664162/article/details/90756817
2，https://developer.android.com/topic/libraries/architecture/livedata?hl=zh-cn
