上一章节讲述了LiveData的基本使用和源码
LiveData详解(上)
LiveData详解(上)_jianning-wu的博客-优快云博客
本章节继续讲解LiveData。
一.自定义LiveData类
上一章节使用LiveData时，创建LiveData对象使用的是MutableLiveData类
mLiveData = new MutableLiveData<>();那么是否可以自己定义实现LiveData类来创建LiveData对象呢。答案是可以的。
代码
Activity
package com.example.rxjava20.livedata;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.Observer;
import com.example.rxjava20.R;
public class LiveDataActivity extends AppCompatActivity {
private MyLiveData mMyLiveData;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_livedata);
initLiveData();
//模拟子线程发送消息
findViewById(R.id.activity_livedata_textview1).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new Thread(new Runnable() {
@Override
public void run() {
mMyLiveData.postValue("自定义LiveData 模拟子线程发送消息...");
}
}).start();
}
});
//模拟主线程发送消息
findViewById(R.id.activity_livedata_textview2).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mMyLiveData.setValue("自定义LiveData 模拟主线程发送消息...");
}
});
}
/**
* 初始化LiveData
*/
private void initLiveData() {
mMyLiveData = new MyLiveData();
mMyLiveData.observe(this, new Observer<String>() {
@Override
public void onChanged(String s) {
Log.d("LiveDataActivity", "自定义LiveData观察者 感知变化 s----: " + s);
}
});
}
}自定义LiveData类
package com.example.rxjava20.livedata;
import android.util.Log;
import androidx.lifecycle.LiveData;
public class MyLiveData extends LiveData<String> {
/**
* 重写postValue方法 用于子线程发送消息
*/
@Override
protected void postValue(String value) {
super.postValue(value);
}
/**
* 重写setValue方法 用于主线程发送消息
*/
@Override
protected void setValue(String value) {
super.setValue(value);
}
/**
* 重写onActive方法 用于判断被观察者(LifecycleOwner的拥有者Activity/Fragment)的活跃状态 活跃状态调用
*/
@Override
protected void onActive() {
super.onActive();
Log.d("LiveDataActivity", "自定义LiveData观察者 onActive方法执行 活跃状态...");
}
/**
* 重写onActive方法 用于判断被观察者(LifecycleOwner的拥有者Activity/Fragment)的活跃状态 非活跃状态调用
*/
@Override
protected void onInactive() {
super.onInactive();
Log.d("LiveDataActivity", "自定义LiveData观察者 onInactive方法执行 非活跃状态...");
}
}
结果
进入页面
D/LiveDataActivity: 自定义LiveData观察者 onActive方法执行 活跃状态...模拟子线程发送消息
D/LiveDataActivity: 自定义LiveData观察者 感知变化 s----: 自定义LiveData 模拟子线程发送消息...模拟主线程发送消息
D/LiveDataActivity: 自定义LiveData观察者 感知变化 s----: 自定义LiveData 模拟主线程发送消息...退出页面
D/LiveDataActivity: 自定义LiveData观察者 onInactive方法执行 非活跃状态...上述使用LiveData。常用两个类和一个接口
类：LiveData
public abstract class LiveData<T> {
...
}类：MutableLiveData
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);
}
}接口：Observer
public interface Observer<T> {
/**
* Called when the data is changed.
* @param t The new data
*/
void onChanged(T t);
}两个类和一个接口 所在的包
其实LiveData的依赖还有一个包 里面有三个类 也是很用的 下面继续讲解
二.Transformations类 变换 LiveData对象
Transformations类源码
public class Transformations {
private Transformations() {
}
/**
* Returns a {@code LiveData} mapped from the input {@code source} {@code LiveData} by applying
* {@code mapFunction} to each value set on {@code source}.
* <p>
* This method is analogous to {@link io.reactivex.Observable#map}.
* <p>
* {@code transform} will be executed on the main thread.
* <p>
* Here is an example mapping a simple {@code User} struct in a {@code LiveData} to a
* {@code LiveData} containing their full name as a {@code String}.
*
* <pre>
* LiveData<User> userLiveData = ...;
* LiveData<String> userFullNameLiveData =
* Transformations.map(
* userLiveData,
* user -> user.firstName + user.lastName);
* });
* </pre>
*
* @param source the {@code LiveData} to map from
* @param mapFunction a function to apply to each value set on {@code source} in order to set
* it
* on the output {@code LiveData}
* @param <X> the generic type parameter of {@code source}
* @param <Y> the generic type parameter of the returned {@code LiveData}
* @return a LiveData mapped from {@code source} to type {@code <Y>} by applying
* {@code mapFunction} to each value set.
*/
@MainThread
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;
}
/**
* Returns a {@code LiveData} mapped from the input {@code source} {@code LiveData} by applying
* {@code switchMapFunction} to each value set on {@code source}.
* <p>
* The returned {@code LiveData} delegates to the most recent {@code LiveData} created by
* calling {@code switchMapFunction} with the most recent value set to {@code source}, without
* changing the reference. In this way, {@code switchMapFunction} can change the 'backing'
* {@code LiveData} transparently to any observer registered to the {@code LiveData} returned
* by {@code switchMap()}.
* <p>
* Note that when the backing {@code LiveData} is switched, no further values from the older
* {@code LiveData} will be set to the output {@code LiveData}. In this way, the method is
* analogous to {@link io.reactivex.Observable#switchMap}.
* <p>
* {@code switchMapFunction} will be executed on the main thread.
* <p>
* Here is an example class that holds a typed-in name of a user
* {@code String} (such as from an {@code EditText}) in a {@link MutableLiveData} and
* returns a {@code LiveData} containing a List of {@code User} objects for users that have
* that name. It populates that {@code LiveData} by requerying a repository-pattern object
* each time the typed name changes.
* <p>
* This {@code ViewModel} would permit the observing UI to update "live" as the user ID text
* changes.
*
* <pre>
* class UserViewModel extends AndroidViewModel {
* MutableLiveData<String> nameQueryLiveData = ...
*
* LiveData<List<String>> getUsersWithNameLiveData() {
* return Transformations.switchMap(
* nameQueryLiveData,
* name -> myDataSource.getUsersWithNameLiveData(name));
* }
*
* void setNameQuery(String name) {
* this.nameQueryLiveData.setValue(name);
* }
* }
* </pre>
*
* @param source the {@code LiveData} to map from
* @param switchMapFunction a function to apply to each value set on {@code source} to create a
* new delegate {@code LiveData} for the returned one
* @param <X> the generic type parameter of {@code source}
* @param <Y> the generic type parameter of the returned {@code LiveData}
* @return a LiveData mapped from {@code source} to type {@code <Y>} by delegating
* to the LiveData returned by applying {@code switchMapFunction} to each
* value set
*/
@MainThread
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.addSource(source, new Observer<X>() {
LiveData<Y> mSource;
@Override
public void onChanged(@Nullable X x) {
LiveData<Y> newLiveData = switchMapFunction.apply(x);
if (mSource == newLiveData) {
return;
}
if (mSource != null) {
result.removeSource(mSource);
}
mSource = newLiveData;
if (mSource != null) {
result.addSource(mSource, new Observer<Y>() {
@Override
public void onChanged(@Nullable Y y) {
result.setValue(y);
}
});
}
}
});
return result;
}
}
源码可见 类中有两个方法map()方法和switchMap方法。源码可以看出两个方法都是运行在主线程 用来对LiveData对象进行操作。
1.Transformations.map方法 修改LiveData
<1> 需求
有时候可能，LiveData发送了一条数据。接收的时候需要将刚刚发送的数据修改一下，然后再发送新的数据。那么就可以用到Transformations类的map方法。
<2> 代码
package com.example.rxjava20.livedata;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;
import androidx.arch.core.util.Function;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.Observer;
import androidx.lifecycle.Transformations;
import com.example.rxjava20.R;
public class LiveDataActivity extends AppCompatActivity {
private MutableLiveData<String> mOldLiveData;//原始LiveData对象 变化前
private LiveData<String> mNewLiveData;//新LiveData对象 变化后
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_livedata);
initLiveData();
//模拟主线程发送消息
findViewById(R.id.activity_livedata_textview2).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mOldLiveData.setValue("123");
}
});
}
/**
* 初始化LiveData
*/
private void initLiveData() {
mOldLiveData = new MutableLiveData<String>();
mNewLiveData = Transformations.map(mOldLiveData, new Function<String, String>() {
@Override
public String apply(String input) {
Log.d("LiveDataActivity", "变化前数据：" + input);
return "变化后的数据：" + input;
}
});
mNewLiveData.observe(this, new Observer<String>() {
@Override
public void onChanged(String s) {
Log.d("LiveDataActivity", "onChanged：" + s);
}
});
}
}<3> 结果
D/LiveDataActivity: 变化前数据：123
D/LiveDataActivity: onChanged：变化后的数据：123<4>结论
原本oldLiveData发送的是“123”。但是通过Transformations.map将“123”修改成“变化后的数据：123”。最后接收到的就是“变化后的数据：123”。
2.Transformations.switchMap方法 切换LiveData
<1> 需求
有的时候可能，有几个LiveData对象发送不同的内容，但是接收那个LiveData对象发送的数据不固定。也就是说有的时候需要接收A对象的LiveData，有的时候需要接收B对象的LiveData。那么就可以用到Transformations类的switchMap方法。
<2> 代码
package com.example.rxjava20.livedata;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;
import androidx.arch.core.util.Function;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.Observer;
import androidx.lifecycle.Transformations;
import com.example.rxjava20.R;
public class LiveDataActivity extends AppCompatActivity {
private MutableLiveData<String> mLiveData1;//发送AAA的LiveData对象
private MutableLiveData<String> mLiveData2;//发送BBB的LiveData对象
private MutableLiveData<Boolean> mLiveData;//决定接收AAA还是BBB的LiveData对象
private LiveData<String> mNewLiveData;//新LiveData对象 变化后
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_livedata);
initLiveData();
//接收AAA
findViewById(R.id.activity_livedata_textview1).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mLiveData1.setValue("AAA");
mLiveData.setValue(true);
}
});
//接收BBB
findViewById(R.id.activity_livedata_textview2).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mLiveData2.setValue("BBB");
mLiveData.setValue(false);
}
});
}
/**
* 初始化LiveData
*/
private void initLiveData() {
//发送AAA的LiveData对象
mLiveData1 = new MutableLiveData<>();
//发送BBB的LiveData对象
mLiveData2 = new MutableLiveData<>();
//决定接收AAA还是BBB的LiveData对象
mLiveData = new MutableLiveData<>();
//切换
mNewLiveData = Transformations.switchMap(mLiveData, new Function<Boolean, LiveData<String>>() {
@Override
public LiveData<String> apply(Boolean input) {
if (input) {//切换条件 true 发送AAA的LiveData对象
return mLiveData1;
}
return mLiveData2;//发送BBB的LiveData对象
}
});
mNewLiveData.observe(this, new Observer<String>() {
@Override
public void onChanged(String s) {
Log.d("LiveDataActivity", "onChanged：" + s);
}
});
}
}<3> 结果
点击接收AAA
D/LiveDataActivity: onChanged：AAA点击接收BBB
D/LiveDataActivity: onChanged：BBB<4> 结论
如果，有多个LiveData对象时，需要动态切换接收那个LiveData对象。可以使用Transformations类的switchMap方法。
三.MediatorLiveData类 合并 LiveData对象
MediatorLiveData类源码
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package androidx.lifecycle;
import androidx.annotation.CallSuper;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.arch.core.internal.SafeIterableMap;
import java.util.Map;
/**
* {@link LiveData} subclass which may observe other {@code LiveData} objects and react on
* {@code OnChanged} events from them.
* <p>
* This class correctly propagates its active/inactive states down to source {@code LiveData}
* objects.
* <p>
* Consider the following scenario: we have 2 instances of {@code LiveData}, let's name them
* {@code liveData1} and {@code liveData2}, and we want to merge their emissions in one object:
* {@code liveDataMerger}. Then, {@code liveData1} and {@code liveData2} will become sources for
* the {@code MediatorLiveData liveDataMerger} and every time {@code onChanged} callback
* is called for either of them, we set a new value in {@code liveDataMerger}.
*
* <pre>
* LiveData<Integer> liveData1 = ...;
* LiveData<Integer> liveData2 = ...;
*
* MediatorLiveData<Integer> liveDataMerger = new MediatorLiveData<>();
* liveDataMerger.addSource(liveData1, value -> liveDataMerger.setValue(value));
* liveDataMerger.addSource(liveData2, value -> liveDataMerger.setValue(value));
* </pre>
* <p>
* Let's consider that we only want 10 values emitted by {@code liveData1}, to be
* merged in the {@code liveDataMerger}. Then, after 10 values, we can stop listening to {@code
* liveData1} and remove it as a source.
* <pre>
* liveDataMerger.addSource(liveData1, new Observer<Integer>() {
* private int count = 1;
*
* {@literal @}Override public void onChanged(@Nullable Integer s) {
* count++;
* liveDataMerger.setValue(s);
* if (count > 10) {
* liveDataMerger.removeSource(liveData1);
* }
* }
* });
* </pre>
*
* @param <T> The type of data hold by this instance
*/
@SuppressWarnings("WeakerAccess")
public class MediatorLiveData<T> extends MutableLiveData<T> {
private SafeIterableMap<LiveData<?>, Source<?>> mSources = new SafeIterableMap<>();
/**
* 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(@NonNull LiveData<S> source, @NonNull Observer<? super S> onChanged) {
Source<S> e = new Source<>(source, onChanged);
Source<?> existing = mSources.putIfAbsent(source, e);
if (existing != null && existing.mObserver != onChanged) {
throw new IllegalArgumentException(
"This source was already added with the different observer");
}
if (existing != null) {
return;
}
if (hasActiveObservers()) {
e.plug();
}
}
/**
* Stops to listen the given {@code LiveData}.
*
* @param toRemote {@code LiveData} to stop to listen
* @param <S> the type of data hold by {@code source} LiveData
*/
@MainThread
public <S> void removeSource(@NonNull LiveData<S> toRemote) {
Source<?> source = mSources.remove(toRemote);
if (source != null) {
source.unplug();
}
}
@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();
}
}
private static class Source<V> implements Observer<V> {
final LiveData<V> mLiveData;
final Observer<? super V> mObserver;
int mVersion = START_VERSION;
Source(LiveData<V> liveData, final Observer<? super V> observer) {
mLiveData = liveData;
mObserver = observer;
}
void plug() {
mLiveData.observeForever(this);
}
void unplug() {
mLiveData.removeObserver(this);
}
@Override
public void onChanged(@Nullable V v) {
if (mVersion != mLiveData.getVersion()) {
mVersion = mLiveData.getVersion();
mObserver.onChanged(v);
}
}
}
}
源码可见 该类继承MutableLiveData类 而MutableLiveData类继承LiveData类。
类中 addSource()方法可以合并LiveData对象。 而重写LiveData抽象类的onActive方法和onInactive方法，又可以在适当的时机添加删除观察者。不需开发者手动删除。
1.MediatorLiveData.addSource()方法 合并多个LiveData
<1> 需求
假定，有两个LiveData对象，可能一个是从服务器获取数据，一个是从本地获取数据。两个LiveData对象来源不同，或者响应速度也不一样。但是数据Json报文一样。这个时候可能需要两个LiveData对象，公用一个观察者，即在一个onChanged方法中返回。这样就没必要监听两个onChanged方法了。
<2> 代码
package com.example.rxjava20.livedata;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.MediatorLiveData;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.Observer;
import com.example.rxjava20.R;
public class LiveDataActivity extends AppCompatActivity {
private MutableLiveData<String> mLocalLiveData;//本地数据的LiveData对象
private MutableLiveData<String> mNetWorkLiveData;//网络数据的LiveData对象
private MediatorLiveData<String> mResultLiveData;//合并后的LiveData对象
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_livedata);
initLiveData();
//本地数据的LiveData对象 发送数据
findViewById(R.id.activity_livedata_textview1).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mLocalLiveData.setValue("本地数据的LiveData对象：发送数据：这是Json报文");
}
});
//网络数据的LiveData对象 发送数据
findViewById(R.id.activity_livedata_textview2).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mNetWorkLiveData.setValue("网络数据的LiveData对象：发送数据：这是Json报文");
}
});
}
/**
* 初始化LiveData
*/
private void initLiveData() {
//本地数据的LiveData对象
mLocalLiveData = new MutableLiveData<>();
//网络数据的LiveData对象
mNetWorkLiveData = new MutableLiveData<>();
//合并后的LiveData对象
mResultLiveData = new MediatorLiveData<>();
//添加本地数据的LiveData对象
mResultLiveData.addSource(mLocalLiveData, new Observer<String>() {
@Override
public void onChanged(String s) {
mResultLiveData.setValue(s);//将 本地数据的LiveData对象发送的数据 添加到 合并后的LiveData对象
}
});
//添加网络数据的LiveData对象
mResultLiveData.addSource(mNetWorkLiveData, new Observer<String>() {
@Override
public void onChanged(String s) {
mResultLiveData.setValue(s);//将 网络数据的LiveData对象发送的数据 添加到 合并后的LiveData对象
}
});
//监听合并后的LiveData对象的变化
mResultLiveData.observe(this, new Observer<String>() {
@Override
public void onChanged(String s) {
Log.d("LiveDataActivity", "监听合并后的LiveData对象的变化 onChanged方法 s----:" + s);
}
});
}
}<3> 结果
发送本地数据
D/LiveDataActivity: 监听合并后的LiveData对象的变化 onChanged方法 s----:本地数据的LiveData对象：发送数据：这是Json报文发送网络数据
D/LiveDataActivity: 监听合并后的LiveData对象的变化 onChanged方法 s----:网络数据的LiveData对象：发送数据：这是Json报文<4> 结论
MediatorLiveData类的addSource方法，可以合并多个相关的LiveData对象。然后使用一个监听onChanged方法即可。
扫一扫
611
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
