LiveData源码深入理解

一，问题导向 q1: LiveData为啥连续postValue两次，第一次的值会丢失

a1: 原因1是 mPendingData 是全局待分发的值在mPostValueRunnable中分发，第二次调用会把 mPendingData 覆盖， 原因2是 第二次调用 这里 postTask变量 直接为 false 导致returen导致 只回调第一次给外部，第二次调用postValue不会回调外部。

protected void postValue(T value) {
    boolean postTask;
    synchronized (mDataLock) {
        postTask = mPendingData == NOT_SET;
        mPendingData = value;
    }
    if (!postTask) {
        return;
    }
    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

ref blog.csdn.net/c10WTiybQ1Y… 「知识点」LiveData为啥连续postValue两次，第一次的值会丢失？

q2: 粘性事件问题是什么，且为什么liveData会有粘性问题？

a2:粘性事件 sticky, 场景是 Livedata给注册的 Observer发送了事件，Observer已经收到通知，这个时候又 注册新的 observer，该 Observer会马上收到通知。

原因： 1,observe 注册观察者，实现生命周期监听 LifecycleBoundObserver implements GenericLifecycleObserver，触发生命周期事件回调，回调中触发LiveData通知观察者，关键方法 dispatchingValue(ObserverWrapper initiator)。

ObserverWrapper 内部 mLastVersion 记录了每个观察者持有的 数据的 最新版本。

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    assertMainThread("observe");
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        // ignore
        return;
    }
    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;
    }
    owner.getLifecycle().addObserver(wrapper);
}

private abstract class ObserverWrapper {
    final Observer<? super T> mObserver;
    boolean mActive;
    int mLastVersion = START_VERSION;
  }

2，发送接口， LiveData的 mVersion ++

@MainThread

protected void setValue(T value) {

    *assertMainThread*("setValue");

    mVersion++;

    mData = value;

    dispatchingValue(null);

}

3，最终发送关键逻辑: dispatchingValue()这里参数非常重要，一个是 不为null，这个是 LifecycleBoundObserver 收到生命周期事件改变触发事件分发。 另外一个是 外部调用接口 setValue()来触发事件分发参数传的 null。

最后都调到 considerNotify 方法完成具体分发工作，最关键的地方是 observer.mLastVersion = mVersion; 这个地方 去判断 观察者持有的数据版本和 LiveData中的 mVersion是否一致，不一致就要 通知观察者并更新它的版本号。

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;
    //noinspection unchecked
    observer.mObserver.onChanged((T) mData);
}

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