JetPack系列（二）LiveData

如遇图片无法查看请点击此链接

LiveData 简介

LiveData是一个可观察的数据持有者类，与常规的Observable不同，LiveData可感知Activity、Fragment、Service的生命周期，确保LiveData仅更新处于活动生命周期状态的组件观察者。如果应用程序组件观察者处于started或者resumed，则LiveData认为该组件处于活跃状态，该组件会收到LiveData的数据更新，而其他注册的组件观察者将不会收到任何数据更新。

主要方法

observe(LifecycleOwner owner, Observer observer)//注册和宿主生命周期关联的观察者
observeForever(Observer observer)//注册观察者，不会反注册，需自行维护
setValue(T data)//发送数据，没有活跃的观察者时不分发，只能在主线程使用
postValue(T data)//和setValue一样,不受线程环境限制
onActive//当且仅当有一个活跃的观察者时触发
inActive//不存在活跃的观察者时会触发

MutableLiveData

MutableLiveData是LiveData的实现类，其主要功能是将setValue和postValue两个方法变成public以供外部调用，这样做的好处是防止拿到LiveData即可以发消息又可以收消息，开闭原则。

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

MutableLiveData使用比较简单，只要设置宿主和观察者。调用postValue和setValue就可以发送消息

class LiveDataTestActivity : AppCompatActivity(){

    private val TAG = "LiveDataTestActivity";

    val mutableLiveData : MutableLiveData<String> = MutableLiveData()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.frament_test)
        mutableLiveData.observe(this, Observer {
            Log.e(TAG, "onCreate$it")
        })
        mutableLiveData3.value = "liveDataMap";
    }
}

MediatorLiveData

MediatorLiveData可以观察多个LiveData，允许多个LiveData合并发射到同一个对象中。
通过addSource将多个LiveData合并到一起，在LiveData数据发生改变后通过MediatorLiveData#setValue()或MediatorLiveData#postValue()将所有数据发送到MediatorLiveData上

class LiveDataTestActivity : AppCompatActivity(){
    private val TAG = "LiveDataTestActivity";
    val mutableLiveData1 : MutableLiveData<String> = MutableLiveData()
    val mutableLiveData2 : MutableLiveData<String> = MutableLiveData()
    //观察多个观察者
    val mediatorLiveData : MediatorLiveData<String> = MediatorLiveData()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.frament_test)
        mediatorLiveData.addSource(mutableLiveData1, Observer {
            //数据源1有变换通知观察者更新
            Log.e(TAG, "mutableLiveData1${System.currentTimeMillis()}")
            mediatorLiveData.value = it
        })
        mediatorLiveData.addSource(mutableLiveData2, Observer {
            //数据源2有变换通知观察者更新
            Log.e(TAG, "mutableLiveData2${System.currentTimeMillis()}")
            mediatorLiveData.value = it
        })

        mediatorLiveData.observe(this, Observer {
            Log.e(TAG, "mediatorLiveData${System.currentTimeMillis()}")
            Log.e(TAG, "$it---${Thread.currentThread()}")
        })
    }
}

Transformations.map

Transformations.map可以将LiveData发送过来的数据进行转换
从源码中看到Transformations.map创建了一个MediatorLiveData，并将原先的LiveData通过addSource放入，在数据发生改变时调用result.setValue(mapFunction.apply(x));将数据转换并发送（由于转换时在onChanged方法上调用所以转换发生在主线程上）

@MainThread
@NonNull
public static <X, Y> LiveData<Y> map(
        @NonNull LiveData<X> source,
        @NonNull final Function<X, Y> mapFunction) {
    final MediatorLiveData<Y> result = new MediatorLiveData<>();
    result.addSource(source, new Observer<X>() {
        @Override
        public void onChanged(@Nullable X x) {
            result.setValue(mapFunction.apply(x));
        }
    });
    return result;
}

val liveDataMap :LiveData<Int> = Transformations.map(mutableLiveData3
) {
    Log.d(TAG, Thread.currentThread().name)
    1
}
liveDataMap.observe(this, Observer {
    Log.d("", "");
})
mutableLiveData3.postValue("3")

源码分析以及黏性事件

observe方法解析

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    //observe必须在主线程时调用
    assertMainThread("observe");
    //如果在宿主生命周期为DESTROYED时调用则忽略这个观察者
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        // ignore
        return;
    }
    //将观察者包装成LifecycleBoundObserver
    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中
    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;
    }

    //检测宿主是否处于活跃状态,在STARTED之后的状态为活跃状态
    @Override
    boolean shouldBeActive() {
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }
    //当宿主的生命周期发生变化时调用此方法
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source,
            @NonNull Lifecycle.Event event) {
        Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
        //如果宿主的生命周期进入DESTROYED则移除这个观察者
        if (currentState == DESTROYED) {
            removeObserver(mObserver);
            return;
        }
        //同步观察者到宿主的生命周期状态
        Lifecycle.State prevState = null;
        while (prevState != currentState) {
            prevState = currentState;
            activeStateChanged(shouldBeActive());
            currentState = mOwner.getLifecycle().getCurrentState();
        }
    }

    @Override
    boolean isAttachedTo(LifecycleOwner owner) {
        return mOwner == owner;
    }

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

    abstract boolean shouldBeActive();

    boolean isAttachedTo(LifecycleOwner owner) {
        return false;
    }

    void detachObserver() {
    }
    //宿主的生命周期变化将会调用次方法
    void activeStateChanged(boolean newActive) {
        //如果从活跃状态到活跃状态则直接返回
        //只有从活跃状态变为不活跃，或不活跃变为活跃状态才会走下面的代码
        if (newActive == mActive) {
            return;
        }
        // immediately set active state, so we'd never dispatch anything to inactive
        // owner
        mActive = newActive;
        //记录观察者的数量，如果活跃状态，观察者+1，如果不活跃，观察者-1
        changeActiveCounter(mActive ? 1 : -1);
        //如果是活跃状态，分发消息
        if (mActive) {
            dispatchingValue(this);
        }
    }
}

changeActiveCounter 方法解析

@MainThread
void changeActiveCounter(int change) {
    //记录当前的观察者数量
    int previousActiveCount = mActiveCount;
    //生命周期变化后的观察者数量
    mActiveCount += change;
    //记录修改状态，进入该方法mChangingActiveState为true，结束该方法mChangingActiveState为false
    if (mChangingActiveState) {
        return;
    }
    mChangingActiveState = true;
    try {
        while (previousActiveCount != mActiveCount) {
            //当前的观察者数量为0，且更新后观察者数量大于0，表示第一个观察者活跃起来
            boolean needToCallActive = previousActiveCount == 0 && mActiveCount > 0;
            //当前观察者数量大约0，且宿主生命周期变化后观察者数量等于0表示所有观察者都将不活跃
            boolean needToCallInactive = previousActiveCount > 0 && mActiveCount == 0;
            previousActiveCount = mActiveCount;
            if (needToCallActive) {
                //第一个观察者活跃起来调用方法
                onActive();
            } else if (needToCallInactive) {
                //没有活跃的观察者调用该方法
                onInactive();
            }
        }
    } finally {
        mChangingActiveState = false;
    }
}

dispatchingValue方法解析

//当调用setValue或postValue的时候initiator为空，生命周期变化导致进入该方法initiator不为空
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方法解析

@SuppressWarnings("unchecked")
private void considerNotify(ObserverWrapper observer) {
    //观察者不活跃直接退出
    if (!observer.mActive) {
        return;
    }
      
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false);
        return;
    }
    //最后一个消息版本和现在的消息版本一致则推出
    //因为生命周期改变或者添加新的观察者也会进入到该方法，所以需要增加判断
    //这行代码也是黏性事件的原因，当观察者刚注册进来，mLastVersion为0，此时如果LiveData发送过消息
    //则mVersion不为0，此时会把最后一条消息分发出去
    //如果观察者在不活跃状态变为活跃状态，也只能收到最后一条消息
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    //将观察者版本同步到LiveData版本，防止消息重复发送
    observer.mLastVersion = mVersion;
    //分发消息
    observer.mObserver.onChanged((T) mData);
}

setValue

@MainThread
protected void setValue(T value) {
    assertMainThread("setValue");
    //消息版本+1
    mVersion++;
    mData = value;
    分发消息
    dispatchingValue(null);
}

postValue

protected void postValue(T value) {
    boolean postTask;
    synchronized (mDataLock) {
        postTask = mPendingData == NOT_SET;
        mPendingData = value;
    }
    if (!postTask) {
        return;
    }
    //将发送操作放到Handler上发送到主线程
    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

observeForever解析

@MainThread
public void observeForever(@NonNull Observer<? super T> observer) {
    assertMainThread("observeForever");
    AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    if (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;
    }
}

static void assertMainThread(String methodName) {
    if (!ArchTaskExecutor.getInstance().isMainThread()) {
        throw new IllegalStateException("Cannot invoke " + methodName + " on a background"
                + " thread");
    }
}