1.關(guān)于MediatorLiveData的addSource()方法

    /**
     * Starts to listen the given {@code source} LiveData, {@code onChanged} observer will be called
     * when {@code source} value was changed.
     * <p>
     * {@code onChanged} callback will be called only when this {@code MediatorLiveData} is active.
     * <p> If the given LiveData is already added as a source but with a different Observer,
     * {@link IllegalArgumentException} will be thrown.
     *
     * @param source    the {@code LiveData} to listen to
     * @param onChanged The observer that will receive the events
     * @param <S>       The type of data hold by {@code source} LiveData
     */
    @MainThread
    public <S> void addSource(LiveData<S> source, Observer<S> onChanged) {
        //新建一個Source并且將該Source的Observer傳進(jìn)去
        Source<S> e = new Source<>(source, onChanged);
        //檢查這個Source是否存在
        Source<?> existing = mSources.putIfAbsent(source, e);
        //如果存在且這個Source的Observer不等于新傳進(jìn)來的Observer就會報錯
        if (existing != null && existing.mObserver != onChanged) {
            throw new IllegalArgumentException(
                    "This source was already added with the different observer");
        }
        if (existing != null) {//如果存在直接return
            return;
        }
        if (hasActiveObservers()) {//不存在就插入(plug)
            e.plug();
        }
    }

    void plug() {
            mLiveData.observeForever(mObserver);//observeForever()這個方法不會自動移除，需要手動停止實際它內(nèi)部調(diào)用的是observe(ALWAYS_ON, observer);
        }

        void unplug() {
            mLiveData.removeObserver(mObserver);
        }

從注釋來看，addSource()是add一個LiveData對象作為一個source,同時add一個Observer對象來監(jiān)聽這個LiveData的值的變化，如果有變化則會在onChange()里回調(diào)。
并且僅當(dāng)這個MediatorLiveData處于active時Observer的onChange()才會回調(diào)。

  @CallSuper
    @Override
    protected void onActive() {
        for (Map.Entry<LiveData<?>, Source<?>> source : mSources) {
            source.getValue().plug();
        }
    }

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

看到這里大概就能知道，其實這個MediatorLiveData類就是個自定義LiveData，可以觀察其他LiveData對象并且回調(diào)。

注意：如果這個LiveData已經(jīng)被add作為一個source,但是這個source沒有被remove的情況下，再次調(diào)用addSource()并且傳了同一個LiveData和一個不同的Observer就會報非法數(shù)據(jù)異常。例如：

 private final MediatorLiveData<String> result = new MediatorLiveData<>();

 public void setQuery(@Nonnull String originalInput){
        result.addSource(testLive, number -> {
//            result.removeSource(result1);//如果這行注釋掉，執(zhí)行到下一行就會報錯。
               result.addSource(result1, newNumber -> result.setValue("成功咯"));
            }
        });
        testLive.setValue(3);
    }

問題一：

我在閱讀官方demo NetworkBoundResource這個類的時候有個疑惑，為啥addSource()要嵌套使用呢？像上面這段代碼一樣。最終經(jīng)過實踐找到了原因
先看Fragment中的代碼

public class TestFragment extends LifecycleFragment implements Injectable {
    
    private TestModel testModel;
    private View mView;
    
    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
                             @Nullable Bundle savedInstanceState) {
        mView = inflater.inflate(R.layout.search_fragment, null);
        return mView;
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        testModel = ViewModelProviders.of(this).get(TestModel.class);//獲取ViewModel
       
        testModel.getResult().observe(this, result -> { //注冊觀察者,注意這個必須得注冊，否則ViewModel中的MediatorLiveData就不處于onActive()狀態(tài)。
            Timber.e("result ="+result.toString());
        });
        
        mView.findViewById(R.id.input).setOnClickListener(v -> {
            testModel.setQuery("test");
        });
    }
}

再來看TestModel中的代碼

public class TestModel extends ViewModel {
    private final MediatorLiveData<String> result = new MediatorLiveData<>();

    private MutableLiveData<String> testLive = new MutableLiveData<>();

    public TestModel(){

    }

    public void setQuery(@Nonnull String originalInput){
        testLive.setValue(originalInput);
        result.addSource(testLive, str -> {
            Timber.e("addSource1執(zhí)行了");
            result.removeSource(testLive);//先移除
            if(str == null){
                Timber.e("str == null");
            } else {
                result.addSource(testLive, newNumber -> result.setValue("成功咯"));//雙層嵌套，前提是前面有removeSource
            }
        });
        testLive.setValue("test");//注意這里和remove就是使用雙層嵌套的原因
    }

    public LiveData<String> getResult(){
        return result;
    }
}

打印結(jié)果為：

Paste_Image.png

注意“addSource1執(zhí)行了”只打印了一次，而“result =成功咯”打印了2次

如果代碼改成如下:

public void setQuery(@Nonnull String originalInput){
        testLive.setValue(originalInput);
        result.addSource(testLive, str -> {
            Timber.e("addSource1執(zhí)行了");
            result.removeSource(testLive);//先移除
            if(str == null){
                Timber.e("str == null");
            } else {
//                result.addSource(testLive, newNumber -> result.setValue("成功咯"));//雙層嵌套，前提是前面有removeSource
                result.setValue("成功咯");
            }
        });
        testLive.setValue("test");//注意這里和remove就是使用雙層嵌套的原因
    }

打印結(jié)果為：

Paste_Image.png

注意“result = 成功咯”只打印了一次

如果不remove并且不嵌套addSource,如下代碼：

 public void setQuery(@Nonnull String originalInput){
        testLive.setValue(originalInput);
        result.addSource(testLive, str -> {
            Timber.e("addSource1執(zhí)行了");
//            result.removeSource(testLive);//先移除
            if(str == null){
                Timber.e("str == null");
            } else {
//                result.addSource(testLive, newNumber -> result.setValue("成功咯"));//雙層嵌套，前提是前面有removeSource
                result.setValue("成功咯");
            }
        });
        testLive.setValue("test");//注意這里和remove就是使用雙層嵌套的原因
    }

打印結(jié)果如下：

Paste_Image.png

注意“addSource1執(zhí)行了”和“result =成功咯”各執(zhí)行2次

經(jīng)過手動幾次測試終于理解了這樣做的用意了，首先確保構(gòu)造方法中的addSource()只接收一次狀態(tài)改變的回調(diào)，就是從本地數(shù)據(jù)庫查詢到結(jié)果后會回調(diào)一次，loadFromDb()查詢到結(jié)果之后，在第一個addSource()中回調(diào)，然后removeSource()，如果不需要聯(lián)網(wǎng)更新數(shù)據(jù)的話，就直接再addSource(),這樣做的目的有2個，第一：之前的loadFromDb()的結(jié)果還是會在這個addSource()中回調(diào)一次(注意：就算之前dbSource()多次被setValue(),這個addSource也只會回調(diào)一次，且是最后一次setValue的結(jié)果，這樣做是保證數(shù)據(jù)是最新的)，第二：保證之后數(shù)據(jù)庫每次loadFromDb()后，addSource()中都能獲取到數(shù)據(jù)（且如果2次或多次setValue時間相隔很近的話，addSource中只會回調(diào)最后一次）。

如下為NetworkBoundResource類的代碼：

/**
 * A generic class that can provide a resource backed by both the sqlite database and the network.
 * <p>
 * You can read more about it in the <a >Architecture
 * Guide</a>.
 * @param <ResultType>
 * @param <RequestType>
 */
public abstract class NetworkBoundResource<ResultType, RequestType> {
    private final AppExecutors appExecutors;

    private final MediatorLiveData<Resource<ResultType>> result = new MediatorLiveData<>();

    @MainThread
    NetworkBoundResource(AppExecutors appExecutors) {
        this.appExecutors = appExecutors;
        result.setValue(Resource.loading(null));
        LiveData<ResultType> dbSource = loadFromDb();
        result.addSource(dbSource, data -> {
            result.removeSource(dbSource);
            if (shouldFetch(data)) {
                fetchFromNetwork(dbSource);
            } else {
                result.addSource(dbSource, newData -> result.setValue(Resource.success(newData)));
            }
        });
    }

    private void fetchFromNetwork(final LiveData<ResultType> dbSource) {
        LiveData<ApiResponse<RequestType>> apiResponse = createCall();
        // we re-attach dbSource as a new source, it will dispatch its latest value quickly
        result.addSource(dbSource, newData -> result.setValue(Resource.loading(newData)));
        result.addSource(apiResponse, response -> {
            result.removeSource(apiResponse);
            result.removeSource(dbSource);
            //noinspection ConstantConditions
            if (response.isSuccessful()) {
                appExecutors.diskIO().execute(() -> {
                    saveCallResult(processResponse(response));
                    appExecutors.mainThread().execute(() ->
                            // we specially request a new live data,
                            // otherwise we will get immediately last cached value,
                            // which may not be updated with latest results received from network.
                            result.addSource(loadFromDb(),
                                    newData -> result.setValue(Resource.success(newData)))
                    );
                });
            } else {
                onFetchFailed();
                result.addSource(dbSource,
                        newData -> result.setValue(Resource.error(response.errorMessage, newData)));
            }
        });
    }

    protected void onFetchFailed() {
    }

    public LiveData<Resource<ResultType>> asLiveData() {
        return result;
    }

    @WorkerThread
    protected RequestType processResponse(ApiResponse<RequestType> response) {
        return response.body;
    }

    @WorkerThread
    protected abstract void saveCallResult(@NonNull RequestType item);

    @MainThread
    protected abstract boolean shouldFetch(@Nullable ResultType data);

    @NonNull
    @MainThread
    protected abstract LiveData<ResultType> loadFromDb();

    @NonNull
    @MainThread
    protected abstract LiveData<ApiResponse<RequestType>> createCall();
}