jetpack系列文章：livedata源码分析

Databinding：单双向数据绑定

Databinding：动态数据更新

Lifecycle讲解

livedata源码分析

ViewModel源码+最终组合使用

前言

官方给我们提供了两个livadata实现类，一个是MutableLiveData，另一个是MediatorLiveData，两者相比起来都比较简单：MutableLiveData里面只有两个方法，一个是setValue当前线程，另一个是postValue主线程。MediatorLiveData里面主要是实现observeForever方法。
我们通过MutableLiveData举例，看一段实例代码：

MutableLiveData<String> mElapsedTime = new MutableLiveData<>();（1）//新建
mElapsedTime.observe(this, new Observer<String>() {（2）//添加观察者
    @Override
    public void onChanged(String string) {
        
    }
});
mElapsedTime.setValue(""); （3）//发布消息

（1）新建

通过handler发送到主线程，本质还是调用了setValue(value);

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

（2）添加观察者

1. 添加观察者有两种方式，observe和observeForever，两个的区别是observeForever需要手动移除观察者，不然可能造成内存泄露。
2. livedata中包含了lifecycle，也就是监听了activity以及fragment的生命周期的状态，当lifecycle的state处于pause或者stop或者destroy的时候，不分发消息。

（2-1）通过observe()方法添加

这里分三步骤

1. 判断生命周期状态决定是否分发，
2. 将观察者包装成一个LifecycleBoundObserver，
3. 将这个包装类添加到缓存以及lifecycle中去

public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    assertMainThread("observe");
//如果state状态是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)) {
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        return;
    }
    //这里将观察者添加到lifecycle中去，结合上节分析，我们要是在observe中添加@onLifecycleEvent注释，其实也可以根据生命周期触发消息了
    owner.getLifecycle().addObserver(wrapper);
}

observer方法中将观察者包装成了LifecycleBoundObserver，这个类中有一个onStateChanged实现类，

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
    @NonNull
    final LifecycleOwner mOwner;
    LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
        super(observer);
        mOwner = owner;
    }
    //Lifecycle的state中比STARTED大的只有RESUME
    @Override
    boolean shouldBeActive() {
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }
    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
    //这里可以看到如果当前状态是DESTROYED，那么就移除，然后返回，这里也就是为啥使用observer不需要我们自己手动移除的原因
        if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
            removeObserver(mObserver);
            return;
        }
        //最后通过activeStateChanged分发消息
        activeStateChanged(shouldBeActive());
    }
    @Override
    boolean isAttachedTo(LifecycleOwner owner) {
        return mOwner == owner;
    }
    @Override
    void detachObserver() {
        mOwner.getLifecycle().removeObserver(this);
    }
}

（2-2）通过observeForever()方法添加

这个方法中将observer包装成了AlwaysActiveObserver类，这个类只继承了ObserverWrapper ，
敲黑板划重点：也就是没有onStateChanged方法，也就不能通过生命周期的变化做任何操作。因此也不能自动在生命周期结束的时候移除观察者，因此需要手动移除。

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) {
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        return;
    }
    wrapper.activeStateChanged(true);
}
private class AlwaysActiveObserver extends ObserverWrapper {
    AlwaysActiveObserver(Observer<? super T> observer) {
        super(observer);
    }
    @Override
    boolean shouldBeActive() {
        return true;
    }
}

（3）发布消息

发布消息有两种，一种是set

  super.postValue(value);  //抛到主线程，最后还是调用的setValue(value)；
  super.setValue(value);   //当前线程

所以我们看setValue(value)方法；

1. 版本号+1
2. 然后分发消息

protected void setValue(T value) {
    assertMainThread("setValue"); //判断线程
    mVersion++;  //这里版本号+1：防止重复分发消息
    mData = value; //赋值给mData
    dispatchingValue(null); //分发消息，传入null表示发给所有
}
//如果入参不为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;
}

最后看真正分发的considerNotify方法。可以看到如果不活跃直接返回，最后调用自定义的onChanged方法。

private void considerNotify(ObserverWrapper observer) {
    if (!observer.mActive) {
        return;
    }
    //如果使用observeForever，shouldBeActive返回的永远为true。
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false);
        return;
    }
    //版本号防止重复发送
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    observer.mObserver.onChanged((T) mData);//最后调用onChanged方法。
}