Jetpack之LiveData订阅与数据分发(一)

使用：

public class LiveDataActivity extends AppCompatActivity {

    MutableLiveData liveData= new MutableLiveData<String>();

    void liveDataTest(){
        //  任何线程都可以发送数据
        liveData.postValue("postValue");
        // 只有主线程可以发送数据
        // liveData.setValue("setValue")
    }

    void observeTest(){
        //订阅
        liveData.observe(this, new Observer<String>() {
            @Override
            public void onChanged(String data) {
                //收到数据data
            }
        });
        //可以有多个订阅
        liveData.observe(this, new Observer<String>() {
            @Override
            public void onChanged(String data) {
                //收到数据data
            }
        });
    }
}

阶段一：

postValue:

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

1. 将用户发送的数据给到一个 mPendingData 的变量；
2. 切换到主线程
3. 执行了一个mPostValueRunnable；

mPostValueRunnable：

    volatile Object mPendingData = NOT_SET;
    private int mVersion;

    private final Runnable mPostValueRunnable = new Runnable() {
        @SuppressWarnings("unchecked")
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            setValue((T) newValue);
        }
    };

1. 在mPostValueRunnable中将mPendingData给到了新的临时变量newValue；
2. mPendingData的值置为空；
3. 调用setValue(newValue);

setValue：

    private volatile Object mData;

    private int mVersion;    

    @MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

1. 将数据版本mVersion +1；
2. 将发送的数据给到了mData;
3. 调用分发数据dispatchingValue；

看到这里发现，数据其实最后存到了mData中；若想发送订阅消息，肯定得添加订阅者；

阶段二：

添加订阅者，observe()：

        //用户使用：
        //liveData.observe(this@LiveDataActivity,{
        //    
        //})

    private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();
    

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        //如果被观察者的生命周期是DESTROYED，就不添加订阅者
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
       
        ...

        owner.getLifecycle().addObserver(wrapper);
    }

1. 将有生命周期的Activity和订阅者Observer传了进来；
2. 判断Activity的生命周期；
3. 将Activity和Observer封装为一个LifecycleBoundObserver对象；
4. 将LifecycleBoundObserver放到了mObservers这个Map集合中；
5. map的key为观察者，value为封装了activity和观察者Observer的对象LifecycleBoundObserver；

LifecycleBoundObserver及它的父类ObserverWrapper：

  
    class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @NonNull
        final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
            super(observer);
            mOwner = owner;
        }

        ...

        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
            Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
            if (currentState == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            Lifecycle.State prevState = null;
            while (prevState != currentState) {
                prevState = currentState;
                activeStateChanged(shouldBeActive());
                currentState = mOwner.getLifecycle().getCurrentState();
            }
        }

        ...

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }




    //ObserverWrapper

    private abstract class ObserverWrapper {
        //传进来的观察者放这里了
        final Observer<? super T> mObserver;

        boolean mActive;
        int mLastVersion = START_VERSION;

        ObserverWrapper(Observer<? super T> observer) {
            mObserver = observer;
        }
        
        ...

        void activeStateChanged(boolean newActive) {
            if (newActive == mActive) {
                return;
            }

            mActive = newActive;
            changeActiveCounter(mActive ? 1 : -1);
            if (mActive) {
                dispatchingValue(this);
            }
        }
   }

1. 将有生命周期的Activity给到了LifecycleBoundObserver的mOwner；
2. 将观察者给到了LifecycleBoundObserver的父类ObserverWrapper的mObserver；
3. 其实LifecycleBoundObserver就可以获取到Activity和mObserver；
4. 上一步，看到将封装后的LifecycleBoundObserver放到了mObservers这个map中；
5. map的key为观察者，value为封装了activity和观察者Observer的对象LifecycleBoundObserver；

阶段三：

分发：

在阶段一setValue()时，调用了dispatchingValue(null);

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




    private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {
            return;
        }
        ...

        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        observer.mObserver.onChanged((T) mData);
    }

1. 当为null时，走到了for循环
2. 循环取出map中的value,而value就是LifecycleBoundObserver；
3. LifecycleBoundObserver中有mObserver，mObserver就是用户传的观察者；
4. mObserver.onChanged((T) mData);
5. 完成了“主动”分发；

未完--------下篇有时间将分析生命周期改变时分发、粘性事件、LiveDataBus原理；