Jetpack之MediatorLiveData使用

2021-05-24

他是LiveData的一个子类，通过依赖"androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"可以引入。他的主要作用是可以接管多个普通的LiveData，把他们统一起来然后进行管理。

比如在一个Fragment中，我们有多个请求，我们就需要一个请求对应一个LiveData，然后在我们的Fragment中手动的对每个LiveData进行数据监测，这是比较麻烦的，我们可以通过MediatorLiveData来比较优雅的实现。

使用

MediatorLiveData一共涉及到的就三个类，MediatorLiveData，ComputableLiveData，Transformations。

对于开始举的例子，我们需要把所有的http请求结果在包裹一层，比如使用

1	data class Wrapper(val type:Int,val data:Any)

然后，对于多个的liveData

class MyVM :ViewModel(){
//对应请求1
private val v1 = MutableLiveData<Wrapper>()
//对应请求2
private val v2 = MutableLiveData<Wrapper>()

val source=MediatorLiveData<Wrapper>().apply(
    addSource(v1){
        value = it
    }    
    addSource(v2){
        value = it
    }

    )
}

//外部Fragment
class MyFragment :Fragment(){
   ...
    mVm.source.observe(this){
        //可以检测到v1和v2的变化，他们可以通过type进行区分
       }
   ...
}

可以看到MediatorLiveData是通过<S> void addSource(LiveData<S> source, Observer<? super S> onChanged)方法来添加需要管理的LiveData，让这个LiveData发生改变的时候，会调用传入的Observer。
需要注意的是我们必须调用MediatorLiveData的observe或者是observeForever才会触发上面的Observer的调用，不然传入的回调Observer是不会被调用了，即使传入的source发生了改变。当然，除了addSource，他还提供了removeSource。
这就是MediatorLiveData的基本使用，然后我们讲解下Transformtions的使用。它是LiveData功能的一个扩展类，提供了三个方法

Transformtions使用

1.<X, Y> LiveData<Y> map(LiveData<X> source,final Function<X, Y> mapFunction)，类似于RxJava的map操作符，用于把一个LiveData转换成另一个，转换过程通过mapFunction实现，例子和源码:

@MainThread
    @NonNull
    public static <X, Y> LiveData<Y> map(
            @NonNull LiveData<X> source,
            @NonNull final Function<X, Y> mapFunction) {
        //可以看到通过MediatorLiveData，把source的改变传递给了result
        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 liveData = MutableLiveData<String>()
val mapLiveData:LiveData<int> = Transformtions.map(liveData){
    it.hashCode()
}
mapLiveData.observe(this){
    //得到liveData的value的哈希值
}
liveData.value = "ahahah"

2.<X, Y> LiveData<Y> switchMap(LiveData<X> source,Function<X, LiveData<Y>> switchMapFunction)，它实现的是类型RxJava的switchMap效果，舍弃原来的LiveData，创建一个新的LiveData来接管他的变化，例子和源码

@MainThread
    @NonNull
    public static <X, Y> LiveData<Y> switchMap(
            @NonNull LiveData<X> source,
            @NonNull final Function<X, LiveData<Y>> switchMapFunction) {
        final MediatorLiveData<Y> result = new MediatorLiveData<>();
        //新建result接管source
        result.addSource(source, new Observer<X>() {
            LiveData<Y> mSource;
            @Override
            public void onChanged(@Nullable X x) {
                //根据switchMapFunction返回一个新的LiveData
                LiveData<Y> newLiveData = switchMapFunction.apply(x);
                if (mSource == newLiveData) {
                    return; //没改变则返回
                }
                if (mSource != null) {
                    //把旧的移除
                    result.removeSource(mSource);
                }
                mSource = newLiveData;
                if (mSource != null) {
                    //把这个新的LiveData加入到result中，当他改变的时候就正在改变resule。
                    result.addSource(mSource, new Observer<Y>() {
                        @Override
                        public void onChanged(@Nullable Y y) {
                            result.setValue(y);
                        }
                    });
                }
            }
        });
        return result;
    }

他的应用场景是在ViewModel中，我们直接返回了Repo的LiveData，那么Repo产生的LiveData每次都是新的，我们需要先把之前的解注册之后然后重新注册才可以观测到新数据变化。这时候，我们加入使用switchMap就可以解决需要重复注册和解注册的问题，他的作用就与RxJava的flatMap类似。

3.<X> LiveData<X> distinctUntilChanged(LiveData<X> source)，他的作用就跟名字一样，是用于去重，他只有源LiveData设置了不同于上一次的数据才会更新，源码如下

public static <X> LiveData<X> distinctUntilChanged(@NonNull LiveData<X> source) {
        final MediatorLiveData<X> outputLiveData = new MediatorLiveData<>();
        outputLiveData.addSource(source, new Observer<X>() {
            boolean mFirstTime = true; //第一次的默认可以更新
            @Override
            public void onChanged(X currentValue) {
                final X previousValue = outputLiveData.getValue();
                if (mFirstTime
                        || (previousValue == null && currentValue != null)
                        || (previousValue != null && !previousValue.equals(currentValue))) {
                    //第一次，或者是上一次为空当不为空，或者是上一次的不等于当前，那么就更新
                    mFirstTime = false;
                    outputLiveData.setValue(currentValue);
                }
            }
        });
        return outputLiveData;
    }

参考

LiveData扩展之MediatorLiveData
LiveData扩展之Transformations