LiveData：

`ObserverWrapper`

    private abstract class ObserverWrapper {
        final Observer<? super T> mObserver;
        boolean mActive; //是否活动
        int mLastVersion = START_VERSION; //初始化mLastVersion为-1

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

        abstract boolean shouldBeActive();  //告诉我，应该是活动的

        boolean isAttachedTo(LifecycleOwner owner) {return false;}  //我的所有者是不是这个owner

        void detachObserver() {} //分开了，拜拜

        void activeStateChanged(boolean newActive) {   //主动的刷新
            if (newActive == mActive) {return;}
            // 设置活动状态，保证仅向活动状态所有者发送
            mActive = newActive;
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) { onActive(); }  //本来就是0而且还很积极，赶紧走起
            if (LiveData.this.mActiveCount == 0 && !mActive) { onInactive(); }//最后一个离开的时候，真的就得凉凉
            if (mActive) {dispatchingValue(this);}//活动状态，安排起来
        }
    }

这是观察者的包装类，里面加的东西我上面都写出啦。

`AlwaysActiveObserver`

再看AlwaysActiveObserver，这个永远都在的观察者吧

    private class AlwaysActiveObserver extends ObserverWrapper {

        AlwaysActiveObserver(Observer<? super T> observer) {super(observer);}

        @Override
        boolean shouldBeActive() {return true;} }

简单的不得了，除了喊一声我是活的，啥也没干。
用它来添加观察者执行observeForever

    //将给定的观察者添加到观察者列表中。但它始终是active的，并不会被自动删除
    //可以调用removeObserver(Observer)来停止
    @MainThread
    public void observeForever(@NonNull Observer<? super T> observer) {
        assertMainThread("observeForever");
        AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
       //如果存在就抛异常、退出
        if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) {... }
        if (existing != null) { return;}
        
        wrapper.activeStateChanged(true);
    }

`LifecycleBoundObserver`

    class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @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); }

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {     //皮之不在毛将焉附
                removeObserver(mObserver); return; }   //删了走人
            activeStateChanged(shouldBeActive());  //积极的刷刷刷
        }

        @Override//看看是谁，所有者是不是一个
        boolean isAttachedTo(LifecycleOwner owner) {return mOwner == owner;}

        @Override//分开了，拜拜
        void detachObserver() {mOwner.getLifecycle().removeObserver(this); }
    }

这是与生命周期相关的观察者，所以要存在owner，持有者的状态决定了观察者的状态。
LiveData会管理这些与生命周期相关的数据。
同时，这个类的对象就不是可以永远活动的对象。

举个例子：如果持有者是Fragment，如果这个Fragment销毁了自然它的观察者们也就需要删除掉。

用它来添加观察者执行observe：

    //将观察者添加到给定所有者的生命周期内的观察者列表中。
    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        //所有者生命周期状态为DESTROYED直接退出
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {  return;  }
        
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        //如果所有者已经存在，则退出。
        if (existing != null && !existing.isAttachedTo(owner)) {...}//抛异常
        if (existing != null) {  return;    }
        
        owner.getLifecycle().addObserver(wrapper);
    }

主要的操作方法

public abstract class LiveData<T> {

    final Object mDataLock = new Object();
    static final int START_VERSION = -1;
    static final Object NOT_SET = new Object();

	//存放观察者。SafeIterableMap是链表而非Map，支持在迭代过程中修改，非线程安全
    private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();

    // 有多少观察者处于活动状态
    int mActiveCount = 0;
    //自己的数据
    private volatile Object mData = NOT_SET;
    /*volatile关键字保证当数据改变后其他线程立即可见
      当调用setData时，先设置为挂起数据mPendingData，并在主线程上进行数据交换
    */
    volatile Object mPendingData = NOT_SET;
    private int mVersion = START_VERSION;

    private boolean mDispatchingValue;
    private boolean mDispatchInvalidated;

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

    //通知变更，也就是执行观察者的onChanged（）方法
    private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {return;}

        //检查调度的最新状态。有可能更新了但还没收到。
        //先检查观察者。保证为活动的事件入口。
        if (!observer.shouldBeActive()) {observer.activeStateChanged(false); 
                                         return;}
        //即使观察者成为活动状态，如果我们没有收到那个事件，就退出
        if (observer.mLastVersion >= mVersion) {return;}
        
        observer.mLastVersion = mVersion;        
        observer.mObserver.onChanged((T) mData);
    }

    //调度值变更，当LiveData数据发生改变时，通过此方法遍历观察者以执行其onChanged（）方法
    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;
    }
    @MainThread
    public void removeObserver(@NonNull final Observer<? super T> observer) {
        assertMainThread("removeObserver");
        ObserverWrapper removed = mObservers.remove(observer);
        if (removed == null) { return;  }
        removed.detachObserver();
        removed.activeStateChanged(false);
    }
    @MainThread
    public void removeObservers(@NonNull final LifecycleOwner owner) {
        assertMainThread("removeObservers");
        for (Map.Entry<Observer<? super T>, ObserverWrapper> entry : mObservers) {
            if (entry.getValue().isAttachedTo(owner)) { removeObserver(entry.getKey());  } } }

    //向主线程发更新数据
    protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }

    //在主线程更新数据
    @MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

    //返回值，但后台线程上可能返回不了最新值
    @Nullable
    public T getValue() {
        Object data = mData;
        if (data != NOT_SET) {
            //noinspection unchecked
            return (T) data;
        }
        return null;
    }

    int getVersion() {  return mVersion;  }
    //当活动观察者的数量从0变为1时触发
    protected void onActive() { }

    //当活动观察者的数量从1变为0时触发，但可能还存在观察者（状态不是STARTED、RESUMED）
    //可以通过hasObservers()查看是否还有观察者
    protected void onInactive() {  }
    public boolean hasObservers() {  return mObservers.size() > 0;  }
    public boolean hasActiveObservers() {return mActiveCount > 0; }//是否还有活动的观察者

    private static void assertMainThread(String methodName) {if (!ArchTaskExecutor.getInstance().isMainThread()) {...}}//抛异常    
}

这便是整个LiveData了，通过一个链表保存一串观察者，当数据发生变化的时候通知他们更新。观察者分为与生命周期持有者相关的以及永远活动状态的。

MediatorLiveData：

MediatorLiveData是 LiveData的子类，它可以观察到其他LiveData对象，并对OnChanged事件作出反应。
该类正确地将其活动/非活动状态反馈到源LiveData对象。

考虑以下场景:
我们有两个LiveData实例，我们将它们命名为liveData1和liveData2，
我们希望将它们合并到一个对象中:liveDataMerger
然后，liveData1和liveData2将成为MediatorLiveData liveDataMerger的源
每次为它们中的任何一个调用onChanged时，都会在liveDataMerger中设置一个新值。

说了这一堆，我们先来看看Source：

    private static class Source<V> implements Observer<V> {
        final LiveData<V> mLiveData;            //被观察的数据
        final Observer<? super V> mObserver;    //观察者
        int mVersion = START_VERSION;

        Source(LiveData<V> liveData, final Observer<? super V> observer) {
            mLiveData = liveData;
            mObserver = observer;
        }

        void plug() {mLiveData.observeForever(this);}     //在被观察者上增加观察者，注意这里使用的observeForever。也就是这个加入后是永远都活动的

        void unplug() {mLiveData.removeObserver(this);}   //在被观察者上，删除观察者

        @Override
        public void onChanged(@Nullable V v) {
            if (mVersion != mLiveData.getVersion()) {
                mVersion = mLiveData.getVersion();        //更新版本
                mObserver.onChanged(v);                   //刷新一下保持数据同步
            }}}

这个Source指定了观察者与被观察者，并且可以将观察者在被观察者上执行加入或分离操作。
再看其他的成员：

public class MediatorLiveData<T> extends MutableLiveData<T> {
    private SafeIterableMap<LiveData<?>, Source<?>> mSources = new SafeIterableMap<>();

    // 开始监听被观察者， onChanged会在source值发生变化时被调用。onChanged回调只在MediatorLiveData活动时调用。
    @MainThread
    public <S> void addSource(@NonNull LiveData<S> source, @NonNull Observer<? super S> onChanged) {
        Source<S> e = new Source<>(source, onChanged);
        Source<?> existing = mSources.putIfAbsent(source, e);
        //如果给定的LiveData已经作为一个源添加，但是使用不同的观察者，抛异常，并返回
        if (existing != null && existing.mObserver != onChanged) {...}
        if (existing != null) {return;}
        if (hasActiveObservers()) {e.plug();}   //只要有活动的观察者，就可以加入
    }

    //停止监听被观察者
    @MainThread
    public <S> void removeSource(@NonNull LiveData<S> toRemote) {
        Source<?> source = mSources.remove(toRemote);   //从链表中删除
        if (source != null) {source.unplug();}}         //如果返回自己，则意味着删除成功，执行分离观察者的操作

    @Override
    protected void onActive() {              //进入活跃状态
        for (Map.Entry<LiveData<?>, Source<?>> source : mSources) {
            source.getValue().plug();}}

    @Override
    protected void onInactive() {             //进入休眠
        for (Map.Entry<LiveData<?>, Source<?>> source : mSources) {
            source.getValue().unplug(); }}
}

这个类还是非常简单的，就是实现了连接、分离持续观察者与被观察者的功能。

MutableLiveData

这个类主要是开放了两个LiveData里protected方法

public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

AAC学习笔记LiveData（二）

文章目录