Livedata 是一个数据源的包装类，他可以有效的取代请求信息时用到callback接口，还可以配合Lifecycle感知程序组件生命周期。
正常我们请求网络数据时的代码为：
public class ListActivity extends AppCompatActivity {
private TextView userNameTv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
userNameTv = findViewbyId(R.id.user_name);
NetModel.getUserName().callback(new Callback(){
@Override
public void onSuccess(String userName){
userNameTv.setText(userName);
}
});
}
}
同样的功能使用LiveData可以写为：
public class ListActivity extends AppCompatActivity {
private TextView userNameTv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
userNameTv = findViewbyId(R.id.user_name);
LiveData<String> userName = NetModel.getUserName();
userName.observe(this, new Observer<String>() {
@Override
public void onChanged(@Nullable String name) {
userNameTv.setText(name);
}
});
}
}
使用时看上去并没有简化多少，但是相比之前的原始代码，如果原始代码中不对setText()方法添加生命周期的判断，当activity销毁后可能会引发空指针异常。
而在LiveData的observe方法中需要传入一个LifecycleOwner对象，所以LiveData可以感知宿主的生命周期，从而不用担心此类问题。
创建Livedata对象
Livedata 属于包装类，所以需要先创建一个Livedata对象，然后在为其填充数据。
Livedata 是一个一个抽象类，不能直接实例化，Android 默认提供了一个它的子类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);
}
}
有没有一脸懵逼的感觉？其实这么写的原因是因为Livedata类添加数据的setValue()和postValue()方法的权限不是公开的，而MutableLiveData只是将这两个方法权限公开而已。
为什么要这样做呢？主要是考虑到架构模型的问题，在数据源请求处使用MutableLiveData对象添加数据，而在UI操作的地方使用LiveData对象就只能使用数据无法改变其数据，这样的话就做到了数据只能在一个地方发生改变提升系统稳定性。当然如果你希望在任何地方都可以改变数据源，直接全部使用MutableLiveData对象即可。
至于设置数据的两个方法：
-
setValue()，在UI线程设置数据。 -
postValue()，在worker线程设置数据。
具体使用方法：
final MutableLiveData<String> data = new MutableLiveData<>();
data.setValue("test");
// in Worker Thread used
data.postValue("test");
感知生命周期
当我们调用LiveData的observe(LifecycleOwner owner,Observer<T> observer)时，LiveData会在LifecycleOwner中添加一个监听生命周期的观察者，
- 当生命周期处于
STARTED或RESUMED这种活动状态时才会通知Observer数据更新 - 当生命周期处于非活动状态时
Observer不会接收到数据更新的通知 - 当生命周期处于
DESTROYED时会将监听生命周期的观察者删除
扩展使用
在上面生命周期的三种情况中，LiveData 除了内部的逻辑操作外，还提供了跟生命周期状态有关的两个回调方法：
onActive()，当生命周期观察者处于活动状态后调用。onInactive()，当生命周期观察者处于非活动状态后调用。
基于此，我们可以继承 LiveData进行扩展实现定制化，下面举一个定位的例子：
public class LocationLiveData extends LiveData<Position> {
// 定位管理器
private LocationManager mLocationManager;
public LocationLiveData() {
mLocationManager = new LocationManager(new LocationCallback() {
@Override
public void onUpdate(Position position) {
// 当位置信息更新时重置livedata数据
setValue(position);
}
});
}
@Override
protected void onActive() {
// 生命周期处于活动状态时开启定位
mLocationManager.startLocation();
}
@Override
protected void onInactive() {
//生命周期处于非活动状态时关闭定位
mLocationManager.stopLocation();
}
}
上面的代码将定位功能封装到了Livedata中，隐藏细节的同时并具备了感知生命周期的能力，在实际使用中只需要像标准的LiveData使用一样即可：
public class LocationFragment extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
LiveData<Position> position = new LocationLiveData();
position.observe(this,new Observer(){
@Override
public void onChanged(Position position) {
// 更新UI
}
});
}
}
不仅如此，我们知道 LiveData 中的observe()方法需要传入一个LifecycleOwner对象用来感知生命周期，但是它并不是唯一值，也就是说我们能够通过observe()方法同时为一个liveData对象设置两个Activity/Fragment的生命周期宿主，也就是LifecycleOwner，基于这个特性，我们可以将LiveData设置成单例模式从而实现多个组件间共享数据。
public class LocationLiveData extends LiveData<Position> {
private LocationManager mLocationManager;
private LocationLiveData instance;
public static LocationLiveData get(){
if (instance == null) {
instance = new LocationLiveData();
}
return instance;
}
private LocationLiveData() {
mLocationManager = new LocationManager(new LocationCallback() {
@Override
public void onUpdate(Position position) {
setValue(position);
}
});
}
@Override
protected void onActive() {
mLocationManager.startLocation();
}
@Override
protected void onInactive() {
mLocationManager.stopLocation();
}
}
在不同的组件中调用：
public class Fragment1 extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
LocationLiveData.get().observe(this,new Observer(){
@Override
public void onChanged(Position position) {
// 更新UI
}
});
}
}
public class Fragment2 extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
LocationLiveData.get().observe(this,new Observer(){
@Override
public void onChanged(Position position) {
// 更新UI
}
});
}
}
变换
这个功能跟RxJava的变换很像，说白了就是抄的RxJava的功能，实现变换功能的是Transformations类，它提供了两个变化的方法。
map() 方法
假设我们要实现一个获取所有用户的用户名功能，但是我们只有获取所有用户的接口：
public class Fragment1 extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
NetModel.getAllUser().observe(this, new Observer<List<user>>() {
@Override
public void onChanged(@Nullable List<User> users) {
// 获取到所有用户在去拿用户名
List<String> allUserName = new ArrayList<>();
for (User user : users) {
allUserName.add(user.getUserName());
}
// 更新UI
}
});
}
}
使用 map() 方法效果如下：
public class Fragment1 extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
LiveData<List<String>> data = Transformations.map(NetModel.getAllUser(), new Function<List<User>, List<String>>() {
@Override
public List<String> apply(List<User> input) {
List<String> allUserName = new ArrayList<>();
for (User user : users) {
allUserName.add(user.getUserName());
}
return allUserName;
}
});
data.observe(this, new Observer<List<String>>() {
@Override
public void onChanged(@Nullable List<String> strings) {
// 更新UI
}
});
}
}
这样做的好处除了转变操作也能感知生命周期外，更重要的是业务逻辑分离，onChanged()方法中只做更新UI的操作，代码更加健壮。
switchMap() 方法
这两种方法唯一不同的地方就是map()的变换是从一个数据源变成另外一个数据源，而switchMap()是从一个数据源变成另外一个LiveData对象，具体有什么用呢？
举一个例子，我们想实现一个获取用户所有信息的功能，但是我们需要先获取用户的id，才能通过id获取信息：
public class Fragment1 extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
NetModel.getUserId().observe(this,new Observer<String>(){
@Override
public void onChanged(String id){
NetModel.getUserInfo(id).observe(Fragment1.this,new Observer<User>(){
@Override
public void onChanged(User user){
// 更新UI
}
})
}
});
}
}
很明显，看着就不爽，用switchMap() 实现效果如下：
public class Fragment1 extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
LiveData<User> user = Transformations.switchMap(NetModel.getUserId(), new Function<String, LiveData<User>() {
@Override
public LiveData<User> apply(String id) {
return Model.getUserInfo(id);
}
});
user.observe(this, new Observer<User>() {
@Override
public void onChanged(@Nullable List<User> users) {
// 更新UI
}
});
}
}
同样的道理，这么做不光方便管理，代码更加健壮。
合并多个LiveData
假设我们有一个获取用户信息的功能，用户信息既可以在网络获取也可以在本地缓存中获取，需要怎么实现呢？
public class Fragment1 extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
LocalModel.getUserInfo().observe(this, new Observer<User>() {
@Override
public void onChanged(@Nullable List<User> users) {
// 更新UI
}
});
NetModel.getUserInfo().observe(this, new Observer<User>() {
@Override
public void onChanged(@Nullable List<User> users) {
// 更新UI
}
});
}
}
上面代码有一个严重的缺陷，那就是两个observer中更新UI代码其实是一样的，这是冗余代码很垃圾，那应该怎么做呢？Android提供了一个可以将多个LiveData 对象合并成一个Livedata的功能类：MediatorLiveData，使用方法如下：
public class Fragment1 extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
MediatorLiveData<User> data = new MediatorLiveData();
data.addSource(LocalModel.getUserInfo(), new Observer<User>() {
@Override
public void onChanged(@Nullable User user) {
data.setValue(user);
}
});
data.addSource(NetModel.getUserInfo(), new Observer<User>() {
@Override
public void onChanged(@Nullable User user) {
data.setValue(user);
}
});
data.observe(this,new Observer<User>() {
@Override
public void onChanged(@Nullable User user) {
// 更新UI
}
});
}
}
MediatorLiveData 通过addSource()方法可以观察多个Livedata对象的数据变化。
