最近研究了一下Architecture Components，尝试用这个架构写了一个小demo，发现了一些问题，也有了一些心得，想分享给大家。
以下关于LiveData的基础使用摘自：[译] Architecture Components 之 LiveData
LiveData
LiveData 是一个数据持有者类，它持有一个值并允许观察该值。不同于普通的可观察者，LiveData 遵守应用程序组件的生命周期，以便 Observer 可以指定一个其应该遵守的 Lifecycle。
LiveData主要方法
- onActive()
当 LiveData 有一个处于活动状态的观察者时该方法被调用，这意味着需要开始从设备观察位置更新。
- onInactive()
当 LiveData 没有任何处于活动状态的观察者时该方法被调用。由于没有观察者在监听，所以没有理由保持与 LocationManager 的连接。这是非常重要的，因为保持连接会显著消耗电量并且没有任何好处。
- setValue()
调用该方法更新 LiveData 实例的值，并将此变更通知给处于活动状态的观察者。
可以通过addObserver添加数据的观察者来更新界面，展示新的数据。
liveData.addObserver(this, location -> {
// 更新 UI
});
请注意，addObserver() 方法将 LifecycleOwner 作为第一个参数传递（即Activity或者Fragment）。这样做表示该观察者应该绑定到 Lifecycle，意思是：
LiveData 有以下优点：
-
没有内存泄漏：因为 Observer 被绑定到它们自己的 Lifecycle 对象上，所以，当它们的 Lifecycle 被销毁时，它们能自动的被清理。
-
不会因为 activity 停止而崩溃：如果 Observer 的 Lifecycle 处于闲置状态（例如：activity 在后台时），它们不会收到变更事件。
-
始终保持数据最新：如果 Lifecycle 重新启动（例如：activity 从后台返回到启动状态）将会收到最新的位置数据（除非还没有）。
-
正确处理配置更改：如果 activity 或 fragment 由于配置更改（如：设备旋转）重新创建，将会立即收到最新的有效位置数据。
-
资源共享：可以只保留一个 MyLocationListener 实例，只连接系统服务一次，并且能够正确的支持应用程序中的所有观察者。
-
不再手动管理生命周期你可能已经注意到，fragment 只是在需要的时候观察数据，不用担心被停止或者在停止之后启动观察。由于 fragment 在观察数据时提供了其 Lifecycle，所以 LiveData 会自动管理这一切。
问题
看了以上的介绍，发现LiveData还是非常好用的，等同于以前用rxLifecycle来管理生命周期，但是在实际使用的时候就发现问题了，LiveData只能传递一个值，之前我们用Retrofit+OkHttp+rxJava等构建MVP模式的应用时，网络数据请求经常会有多种结果：（1）正常返回数据，（2）接口返回，错误结果（3）网络请求失败 （4）列表无更多数据（5）接口正常返回，无数据 。。。等等情况，之前我们会在Presenter层通过回调获得这些发生在Model层的情况，然后调用View层改变界面的方法展示给用户，但是使用LiveData时View层可以直接通过ViewModel获得Model提供的LiveData，有数据时可以正常显示，但是异常时就显得力不从心了，我们只能传递一个值：有值或者null，无法判断复杂的具体的情况。
final-architecture.png
上图是官方提供的Architecture Components架构示意图，其中的依赖关系应该是单向的（隐藏的观察、被观察的关系不算），即Activity/Fragment持有ViewModel的引用，ViewModel持有Repository，提供LiveData。。。官方也提到ViewModel仅仅是一个LiveData的容器，不应该持有Activity/Fragment的引用。
基于以上这种情况下如何根据不同的情况改变界面那？例如：弹出吐司，对话框，显示网络异常等等那？？？啰嗦了这么半天，终于引出今天的话题——扩展LiveData 以满足需求。
扩展
先来分析一下LiveData，当添加了观察者，一旦调用setValue方法，观察者的onChanged方法就会接受到新的值。传递的值是通过LiveData<T>泛型定义。
既然是要区分类型，一开始的思路是将泛型定义成自定义的ActionEntity<T>，有点类似网络接口返回，id区分类型，extra附带额外数据，original是原始的value数据，即将真实数据包装一层，通过id来区分不同的情况：
public class ActionEntity<T> {
public static final int ACTION = 0x1;
public static final int VALUE = 0x2;
public int type;
public int id;
public Object[] extra;
public T original;
public ActionEntity(T original) {
this.original = original;
type = VALUE;
}
public ActionEntity(int id, Object[] extra) {
this.id = id;
this.extra = extra;
type = ACTION;
}
}
接下来就是修改LiveData的setValue方法实现自动装包，让使用时感知不到包装的存在
import android.arch.lifecycle.LifecycleOwner;
import android.arch.lifecycle.MediatorLiveData;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
/**
* Created by hubert
* <p>
* Created on 2017/12/7.
*/
public class ActionLiveData2<T> extends MediatorLiveData<ActionEntity<T>> implements ActionCreator {
@Override
public void setAction(int id, Object... args) {
super.setValue(new ActionEntity<T>(id, args));
}
public void setValue_(T value) {
super.setValue(new ActionEntity<T>(value));
}
public void postValue_(T value) {
super.postValue(new ActionEntity<T>(value));
}
public void observe_(@NonNull LifecycleOwner owner, @NonNull ActionObserver2<T> observer) {
super.observe(owner, observer);
}
public void observeForever_(@NonNull ActionObserver2<T> observer) {
super.observeForever(observer);
}
public void removeObserver_(@NonNull ActionObserver2<T> observer) {
super.removeObserver(observer);
}
@Nullable
public T getValue_() {
ActionEntity<T> entity = super.getValue();
return entity == null ? null : entity.original;
}
}
修改Observer的onChanged方法实现自动拆包
import android.arch.lifecycle.Observer;
import android.support.annotation.Nullable;
/**
* Created by hubert
* <p>
* Created on 2017/12/7.
*/
public abstract class ActionObserver2<T> implements Observer<ActionEntity<T>>, ActionHandler {
@Override
public final void onChanged(@Nullable ActionEntity<T> entity) {
if (entity != null) {
if (entity.type == ActionEntity.VALUE) {
onChanged_(entity.original);
} else {
onAction(entity.id, entity.extra);
}
}
}
public abstract void onChanged_(T entity);
}
不知道你有没有注意到很多方法最后都有_，这是由于对T泛型的数据做了改变，新包装的方法无法使用原方法名，只能通过添加下划线来区别原方法。
这样修改的话直接使用的话是能达到我的目的，但是通常情况下LiveData会通过Transformations进行转换，这时候泛型将很难定义，而且无法申明我们定义的类，因为Transformations的switchMap方法返回的必须是LiveData<T>，泛型只能定义成LiveData<ActionEntity<T>>，虽然我的定义的ActionLiveData2<T>也是继承自LiveData<ActionEntity<T>>，但是并不相等啊！！！
于是自己都写不下去了😂 并且这样的命名也非常的让我不爽，于是废弃了这种方式。
接着我又有了一个想法🤔，直接让LiveData传递Action，就像传递Value一样地传递：通过setAction设置事件，并且在Observer中onAction方法中接受事件作出处理。这个可以有！仿照value是怎么传递的不就行了嘛！😎
然后我仔细分析了LiveData的源码，了解了其中是如何传递Value的，但是其中处理value的方法基本都是private的，子类无法使用。因此，我只能按照同样的逻辑来实现Action的传递：
import android.arch.lifecycle.LifecycleOwner;
import android.arch.lifecycle.LiveData;
import android.arch.lifecycle.MediatorLiveData;
import android.arch.lifecycle.Observer;
import android.os.Handler;
import android.os.Looper;
import android.support.annotation.NonNull;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* Created by hubert on 2017/12/6.
* <p>
*/
public class ActionLiveData<T> extends MutableLiveData<T> implements ActionCreator {
private Set<ActionObserver<T>> actionObservers = new HashSet<>();
private boolean active;//父类中有这个属性，但是也是private
private ActionEntity actionEntity;
private Handler handler;
private Runnable actionRun = new Runnable() {
@Override
public void run() {
dispatchAction();
}
};
private void dispatchAction() {
if (active) {
for (ActionObserver<T> actionObserver : actionObservers) {
actionObserver.onAction(actionEntity.id, actionEntity.extra);
}
}
}
@Override
protected void onActive() {
super.onActive();
active = true;
}
@Override
protected void onInactive() {
super.onInactive();
active = false;
}
@Override
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
super.observe(owner, observer);
if (observer instanceof ActionObserver) {
actionObservers.add((ActionObserver<T>) observer);
}
}
@Override
public void removeObserver(@NonNull Observer<T> observer) {
super.removeObserver(observer);
if (observer instanceof ActionObserver) {
actionObservers.remove(observer);
}
}
/**
* 设置事件
* @param id 事件id
* @param args 可选的参数
*/
@Override
public void setAction(int id, Object... args) {
actionEntity = new ActionEntity(id, args);
if (isMainThread()) {
dispatchAction();
} else {
if (handler == null) {
handler = new Handler(Looper.getMainLooper());
}
handler.post(actionRun);
}
}
public boolean isMainThread() {
return Thread.currentThread() == Looper.getMainLooper().getThread();
}
Action相关接口的声明：
public interface ActionCreator {
void setAction(int id, Object... args);
}
public interface ActionHandler {
void onAction(int id, Object... args);
}
public interface ActionObserver<T> extends Observer<T>, ActionHandler {
}
使用时传入ActionObserver复写onAction(int id, Object... args)接收Action事件
actionLiveData.observe(this, new ActionObserver<Integer>() {
@Override
public void onAction(int id, Object... args) {
if (id == 1) {
//do something
}
}
@Override
public void onChanged(@Nullable Integer integer) {
//the original value
}
});
完美！马上把demo中的LiveData换成ActionLiveData跑上~ 没有反应😱，怎么可能，我的逻辑...应该完美！😭 各种断点找原因，到底为什么没有传递过来。。。
最终被我发现了！
class MyViewModel extends ViewModel {
private final PostalCodeRepository repository;
private final MutableLiveData<String> addressInput = new MutableLiveData();
public final LiveData<String> postalCode =
Transformations.switchMap(addressInput, (address) -> {
return repository.getPostCode(address);
});
public MyViewModel(PostalCodeRepository repository) {
this.repository = repository
}
private void setInput(String address) {
addressInput.setValue(address);
}
}
我的LiveData是通过Transformations.switchMap进行转换，或者说传递，即让一个LiveData（view层中获得的那个，我们简称小v）观察另一个LiveData（M层生成的小m），请求数据只会改变小m的value，switchMap方法内部其实就是给小m设置一个Observer，当小m的value改变时会调用该Observer的onChanged方法，在该方法中调用小v的setValue，这样View层的Observer的onChanged方法就可以改变界面。
其中只处理了value的传递，并且返回的对象是方法内部new的这个final MediatorLiveData<Y> result = new MediatorLiveData<>();，我们自己新添加的action当然不会被传递啦。
🙄既然这样，那我们就自己传递吧。还是仿照MediatorLiveData中传递方式，新增一个ActionSource类：
/**
* Created by hubert on 2017/12/6.
* <p>
* LiveData本身只能有一种泛型的数据，在（接口）数据返回时只能设置有值或者null来判断，
* 无法传递其他信息，如需要提示网络，数据错误等情况，为每一种情况定义一个LiveData又太过于繁琐。
* 基于以上考虑对LiveData进行扩展，使其支持传递自定义Action，
* 通过调用{@code setAction(int id, Object... args)}发送事件。
* 并在observe方法中传入{@link ActionObserver}用于接收action事件作出处理。
* <pre>
* actionLiveData.observe(this, new ActionObserver<Integer>() {
* {@literal @}Override
* public void onAction(int id, Object... args) {
* if (id == 1) {
* //do something
* }
* }
*
* {@literal @}Override
* public void onChanged(@Nullable Integer integer) {
* //the original value
* }
* });
* </pre>
*/
public class ActionLiveData<T> extends MediatorLiveData<T> implements ActionCreator {
private Set<ActionObserver<T>> actionObservers = new HashSet<>();
private boolean active;
private ActionEntity actionEntity;
private Handler handler;
private Runnable actionRun = new Runnable() {
@Override
public void run() {
dispatchAction();
}
};
/**
* 通知Observer更新事件
*/
private void dispatchAction() {
if (active) {
for (ActionObserver<T> actionObserver : actionObservers) {
actionObserver.onAction(actionEntity.id, actionEntity.extra);
}
}
}
@Override
protected void onActive() {
super.onActive();
active = true;
for (Map.Entry<ActionLiveData<?>, ActionSource<?>> entry : mHandlers.entrySet()) {
entry.getValue().plug();
}
}
@Override
protected void onInactive() {
super.onInactive();
active = false;
for (Map.Entry<ActionLiveData<?>, ActionSource<?>> entry : mHandlers.entrySet()) {
entry.getValue().unplug();
}
}
@Override
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
super.observe(owner, observer);
if (observer instanceof ActionObserver) {
actionObservers.add((ActionObserver<T>) observer);
}
}
@Override
public void removeObserver(@NonNull Observer<T> observer) {
super.removeObserver(observer);
if (observer instanceof ActionObserver) {
actionObservers.remove(observer);
}
}
/**
* 设置事件
* @param id 事件id
* @param args 可选的参数
*/
@Override
public void setAction(int id, Object... args) {
actionEntity = new ActionEntity(id, args);
if (isMainThread()) {
dispatchAction();
} else {
if (handler == null) {
handler = new Handler(Looper.getMainLooper());
}
handler.post(actionRun);
}
}
public boolean isMainThread() {
return Thread.currentThread() == Looper.getMainLooper().getThread();
}
/****支持Transformations的转换***/
private Map<ActionLiveData<?>, ActionSource<?>> mHandlers = new HashMap<>();
@Override
public <S> void addSource(@NonNull LiveData<S> source, @NonNull Observer<S> onChanged) {
super.addSource(source, onChanged);
if (source instanceof ActionLiveData && onChanged instanceof ActionObserver) {
addActionObserver((ActionLiveData<S>) source, (ActionObserver<S>) onChanged);
}
}
protected <S> void addActionObserver(ActionLiveData<S> source, ActionObserver<S> actionObserver) {
ActionSource<S> actionSource = new ActionSource<>(source, actionObserver);
ActionSource<?> existing = mHandlers.put(source, actionSource);
if (existing != null) {
return;
}
if (hasActiveObservers()) {
actionSource.plug();
}
}
@Override
public <S> void removeSource(@NonNull LiveData<S> toRemote) {
super.removeSource(toRemote);
if (toRemote instanceof ActionLiveData) {
removeActionSource(toRemote);
}
}
protected <S> void removeActionSource(@NonNull LiveData<S> toRemote) {
ActionSource<?> source = mHandlers.remove(toRemote);
if (source != null) {
source.unplug();
}
}
public static class ActionSource<T> implements ActionHandler {
ActionLiveData<T> actionLiveData;
ActionObserver<T> actionObserver;
public ActionSource(ActionLiveData<T> actionLiveData, ActionObserver<T> actionObserver) {
this.actionLiveData = actionLiveData;
this.actionObserver = actionObserver;
}
void plug() {
actionLiveData.observeForever(actionObserver);
}
void unplug() {
actionLiveData.removeObserver(actionObserver);
}
@Override
public void onAction(int id, Object... args) {
actionObserver.onAction(id, args);
}
}
}
定义ActionTransformations修改Transformations的逻辑，以实现action事件的传递：
import android.arch.core.util.Function;
import android.arch.lifecycle.LiveData;
import android.arch.lifecycle.Observer;
import android.support.annotation.MainThread;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
/**
* Created by hubert on 2017/12/7.
* <p>
* 用于ActionLiveData的转换，实现Action的传递
*/
public class ActionTransformations {
@MainThread
public static <X, Y> ActionLiveData<Y> map(@NonNull ActionLiveData<X> source,
@NonNull final Function<X, Y> func) {
final ActionLiveData<Y> result = new ActionLiveData<>();
result.addSource(source, new ActionObserver<X>() {
@Override
public void onChanged(@Nullable X x) {
result.setValue(func.apply(x));
}
@Override
public void onAction(int id, Object... args) {
result.setAction(id, args);
}
});
return result;
}
@MainThread
public static <X, Y> ActionLiveData<Y> switchMap(@NonNull LiveData<X> trigger,
@NonNull final Function<X, ActionLiveData<Y>> func) {
final ActionLiveData<Y> result = new ActionLiveData<>();
result.addSource(trigger, new Observer<X>() {
ActionLiveData<Y> mSource;
@Override
public void onChanged(@Nullable X x) {
ActionLiveData<Y> newLiveData = func.apply(x);
if (mSource == newLiveData) {
return;
}
if (mSource != null) {
result.removeSource(mSource);
}
mSource = newLiveData;
if (mSource != null) {
result.addSource(mSource, new ActionObserver<Y>() {
@Override
public void onAction(int id, Object... args) {
result.setAction(id, args);
}
@Override
public void onChanged(@Nullable Y y) {
result.setValue(y);
}
});
}
}
});
return result;
}
}
使用时也没有多大的改变，只要把LiveData替换成ActionLiveData即可。开始尽情的传递事件吧~ 😉
这个扩展是本人根据需求独创的，如果觉得好不要吝惜你的“喜欢”哦。 当然由于水平有限，如果入不了你的眼，那肯定是比我厉害的大牛，有更好的建议或者思路可以提点我一下😍，让我也学习学习~
网友评论