1.關於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傳進去
Source<S> e = new Source<>(source, onChanged);
//檢查這個Source是否存在
Source<?> existing = mSources.putIfAbsent(source, e);
//如果存在且這個Source的Observer不等於新傳進來的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();
}
}
內部類 Source
void plug() {
mLiveData.observeForever(mObserver);//observeForever()這個方法不會自動移除,需要手動停止實際它內部調用的是observe(ALWAYS_ON, observer);
}
void unplug() {
mLiveData.removeObserver(mObserver);
}
從註釋來看,addSource()是add一個LiveData對象作爲一個source, 同時add一個Observer對象來監聽這個LiveData的值的變化,如果有變化則會在onChange()裏回調。並且僅當這個MediatorLiveData處於active時Observer的onChange()纔會回調。
@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對象並且回調。
ReportFragment#onStart() -> ReportFragment#dispatch() -> ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event) -> LifecycleRegistry#moveToState() -> LifecycleRegistry#sync() -> LifecycleRegistry#forwardPass(lifecycleOwner) -> ObserverWithState#observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState)) -> LiveData#onStateChanged() -> LiveData#activeStateChanged() -> LiveData#onActive()
所以代碼裏編寫了
testModel.getResult().observe(this, result -> { // ...... });
就會執行上面的onActive()方法,此時的mSources的大小爲0.
注意:如果這個LiveData已經被add作爲一個source, 但是這個source沒有被remove的情況下,再次調用addSource()並且傳了同一個LiveData和一個不同的Observer就會報非法數據異常。例如:
private final MediatorLiveData<String> result = new MediatorLiveData<>();
public void setQuery(@Nonnull String originalInput){
result.addSource(testLive, number -> {
// result.removeSource(result1);//如果這行註釋掉,執行到下一行就會報錯。
result.addSource(result1, newNumber -> result.setValue("成功咯"));
}
});
testLive.setValue(3);
}
問題一:
我在閱讀官方demo NetworkBoundResource這個類的時候有個疑惑,爲啥addSource()要嵌套使用呢?像上面這段代碼一樣。最終經過實踐找到了原因
先看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()狀態。
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執行了");
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;
}
}
打印結果爲:
注意“addSource1執行了”只打印了一次,而“result =成功咯”打印了2次
此時 void plug() { mLiveData.observeForever(this); } 的執行流程如下:
1⃣️、LiveData#observeForever() -> ObserverWrapper#activeStateChanged() -> ObserverWrapper#dispatchingValue() -> ObserverWrapper#considerNotify() -> observer.mObserver.onChanged((T) mData) 也就是此處MediatorLiveData$Source#onChanged() 打印了addSource1執行了,
2⃣️、接着執行result.removeSource() -> Source#unplug() 移除MediatorLiveData,
3⃣️、接着又執行了result.addSource()又把上面1⃣️的流程走了一遍打印result = 成功咯
4⃣️、最後執行testLive.setValue("test"); LiveData#setValue() -> LiveData#dispatchingValue() -> LiveData#considerNotify() -> MediatorLiveData$Source#onChanged() 打印result = 成功咯
如果代碼改成如下:
public void setQuery(@Nonnull String originalInput){
testLive.setValue(originalInput);
result.addSource(testLive, str -> {
Timber.e("addSource1執行了");
result.removeSource(testLive);//先移除
if(str == null){
Timber.e("str == null");
} else {
// result.addSource(testLive, newNumber -> result.setValue("成功咯"));//雙層嵌套,前提是前面有removeSource
result.setValue("成功咯");
}
});
testLive.setValue("test");//注意這裏和remove就是使用雙層嵌套的原因
}
打印結果爲:
注意“result = 成功咯”只打印了一次, 因爲result.removeSource()後testLive沒有被TestFragment觀察了,所以沒有打印輸出。
如果不remove並且不嵌套addSource,如下代碼:
public void setQuery(@Nonnull String originalInput){
testLive.setValue(originalInput);
result.addSource(testLive, str -> {
Timber.e("addSource1執行了");
// result.removeSource(testLive);//先移除
if(str == null){
Timber.e("str == null");
} else {
// result.addSource(testLive, newNumber -> result.setValue("成功咯"));//雙層嵌套,前提是前面有removeSource
result.setValue("成功咯");
}
});
testLive.setValue("test");//注意這裏和remove就是使用雙層嵌套的原因
}
打印結果如下:
注意“addSource1執行了”和“result =成功咯”各執行2次
經過手動幾次測試終於理解了這樣做的用意了,首先確保構造方法中的addSource()只接收一次狀態改變的回調,就是從本地數據庫查詢到結果後會回調一次,loadFromDb()查詢到結果之後,在第一個addSource()中回調,然後removeSource(),如果不需要聯網更新數據的話,就直接再addSource(), 這樣做的目的有2個,第一:之前的loadFromDb()的結果還是會在這個addSource()中回調一次(注意:就算之前dbSource()多次被setValue(),這個addSource也只會回調一次,且是最後一次setValue的結果,這樣做是保證數據是最新的),第二:保證之後數據庫每次loadFromDb()後,addSource()中的監聽都能收到回調取到數據(且如果2次或多次setValue時間相隔很近的話,addSource中只會回調最後一次)。
如下爲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 href="https://developer.android.com/arch">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)); // 觀察者(LifecycleOwner)會接收到回調
LiveData<ResultType> dbSource = loadFromDb(); // dbSource內部setValue()修改mVersion的值,後面的addSource時就會跳過 LiveData#considerNotify()的語句if (observer.mLastVersion >= mVersion) { return; }
result.addSource(dbSource, data -> { // 監聽方法只會在dbSource.setValue()後調用,data和下面的newData的值都是上面dbSource.setValue()賦的值
result.removeSource(dbSource); // 能夠執行onChanged()說明dbSource最近執行了setValue()了
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))); // 先顯示本地數據,newData就是dbSource最近setValue()的值
result.addSource(apiResponse, response -> { // response是aipResponse最近一次setValue的值
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))); // 這裏的newData就是loadFromDb()這個liveData.setValue()的值
);
});
} else {
onFetchFailed();
result.addSource(dbSource,
newData -> result.setValue(Resource.error(response.errorMessage, newData))); // addSource()的目的是可以服用dbSource的setValue()的值 ???
}
});
}
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();
}