Android-LiveData 解析

当前为 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 避免。