Jetpack 架构组件库 -LiveData 实战与应用 - 总有适合你的方案
[](
)SingleLiveEvent 代码如下：
/**
A lifecycle-aware observable that sends only new updates after subscription, used for events like
navigation and Snackbar messages.
<p>
This avoids a common problem with events: on configuration change (like rotation) an update
can be emitted if the observer is active. This LiveData only calls the observable if there's an
explicit call to setValue() or call().
<p>
Note that only one observer is going to be notified of changes.
*/
public class SingleLiveEvent<T> extends MutableLiveData<T> {
private static final String TAG = "SingleLiveEvent";
private final AtomicBoolean mPending = new AtomicBoolean(false);
@MainThread
public void observe(LifecycleOwner owner, final Observer<? super T> observer) {
if (hasActiveObservers()) {
Log.w(TAG, "Multiple observers registered but only one will be notified of changes.");
}
// Observe the internal MutableLiveData
super.observe(owner, new Observer<T>() {
@Override
public void onChanged(@Nullable T t) {
if (mPending.compareAndSet(true, false)) {
observer.onChanged(t);
}
}
});
}
@MainThread
public void setValue(@Nullable T t) {
mPending.set(true);
super.setValue(t);
}
/**
Used for cases where T is Void, to make calls cleaner.
*/
@MainThread
publi
c void call() {
setValue(null);
}
}
[](
)MainActivityViewModel 中使用 SingleLiveEvent：
public class MainActivityViewModel extends ViewModel {
private SingleLiveEvent<Boolean> _navigateToDetails = new SingleLiveEvent<>();
public LiveData<Boolean> navigateToDetails(){
return _navigateToDetails;
}
public void userClicksOnButton() {
_navigateToDetails.setValue(true);
}
}
[](
)MainActivity 中监听：
@Override
public void onResume() {
super.onResume();
mViewModel.navigateToDetails().observe(this, new Observer<Boolean>() {
@Override
public void onChanged(Boolean aBoolean) {
if (mViewModel.navigateToDetails().getValue()){
NavigatorUser.starDetailActivity();
}
}
});
}
官网针对 SingleLiveEvent 参考链接如下：
[medium.com/androiddeve…](
)
SingleLiveEvent 的问题在于：它仅限于一个观察者。如果你无意中添加了多个，则只会有一个收到回调，并且无法保证哪一个会收到。
[](
)3、LiveDataBus 消息总线替代 RxBus、EventBus
通过 LiveDataBus 可以实现如下需求：
基于 LiveData 组件；
保证内存不会泄漏；
不用反注册消息总线；
[](
)先看一下 LiveDataBus 用法：
注册订阅
LiveDataBus.get()
.with("key_test", String.class)
.observe(this, new Observer<String>() {
@Override
public void onChanged(@Nullable String s) {
}
});
发送消息：
LiveDataBus.get().with("key_test").setValue(s);
用法上和 EventBus 非常相像，但我们的优势不用手动反注册，不用担心内存泄漏了。
[](
)问题分析：
我们先前通过源码分析得知：消息分发核心方法：
void considerNotify(ObserverWrapper observer) {
//观察者没有处于活跃状态,则不分发。
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
//观察者接收的消息的次数>=livedata 发送消息的次数,不分发。
//如果之前已经发送过数据了，新注册的 observer 也能接收到最后一条数据。
if (observer.mLastVersion >= mVersion) {
return;
}
//根本原因在于 ObserverWrapper 的 version 字段在创建时=-1,没有主动和 LiveData 的 mVersion 字段对齐
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}
控制黏性事件的突破口在于观察者的 version 字段，我们要在注册一个新的 Observer 时把它的 mLastVersion 字段和 LiveData.mVersion 字段主动保持一致就可以了。
但是上面这个 version 字段我们都是拿不到也无法修改的，LiveDataBus 的解决方案是：
在调用 observe 的时候，通过反射拿到 LifecycleBoundObserver，再把 LifecycleBoundObserver 的 version 设置成和 LiveData 一致。
看一下 LiveDataBus 的最终实现：
public final class LiveDataBus {
private final Map<String, BusMutableLiveData<Object>> bus;
private LiveDataBus() {
bus = new HashMap<>();
}
private static class SingletonHolder {
private static final LiveDataBus DEFAULT_BUS = new LiveDataBus();
}
public static LiveDataBus get() {
return SingletonHolder.DEFAULT_BUS;
}
public <T> MutableLiveData<T> with(String key, Class<T> type) {
if (!bus.containsKey(key)) {
bus.put(key, new BusMutableLiveData<>());
}
return (MutableLiveData<T>) bus.get(key);
}
public MutableLiveData<Object> with(String key) {
return with(key, Object.class);
}
private static class ObserverWrapper<T> implements Observer<T> {
private Observer<T> observer;
public ObserverWrapper(Observer<T> observer) {
this.observer = observer;
}
@Override
public void onChanged(@Nullable T t) {
if (observer != null) {
if (isCallOnObserve()) {
return;
}
observer.onChanged(t);
}
}
private boolean isCallOnObserve() {
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
if (stackTrace != null && stackTrace.length > 0) {
for (StackTraceElement element : stackTrace) {
if ("android.arch.lifecycle.LiveData".equals(element.getClassName()) &&
"observeForever".equals(element.getMethodName())) {
return true;
}
}
}
return false;
}
}
private static class BusMutableLiveData<T> extends MutableLiveData<T> {
private Map<Observer, Observer> observerMap = new HashMap<>();
@Override
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
super.observe(owner, observer);
try {
hook(observer);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void observeForever(@NonNull Observer<T> observer) {
if (!observerMap.containsKey(observer)) {
observerMap.put(observer, new ObserverWrapper(observer));
}
super.observeForever(observerMap.get(observer));
}
@Override
public void removeObserver(@NonNull Observer<T> observer) {
Observer realObserver = null;
if (observerMap.containsKey(observer)) {
realObserver = observerMap.remove(observer);
} else {
realObserver = observer;
}
super.removeObserver(realObserver);
}
private void hook(@NonNull Observer<T> observer) throws Exception {
//get wrapper's version
Class<LiveData> classLiveData = LiveData.class;
Field fieldObservers = classLiveData.getDeclaredField("mObservers");
fieldObservers.setAccessible(true);
Object objectObservers = fieldObservers.get(this);
Class<?> classObservers = objectObservers.getClass();
Method methodGet = classObservers.getDeclaredMethod("get", Object.class);
methodGet.setAccessible(true);
Object objectWrapperEntry = methodGet.invoke(objectObservers, observer);
Object objectWrapper = null;
if (objectWrapperEntry instanceof Map.Entry) {
objectWrapper = ((Map.Entry) objectWrapperEntry).getValue();
}
if (objectWrapper == null) {
throw new NullPointerException("Wrapper can not be bull!");
}
Class<?> classObserverWrapper = objectWrapper.getClass().getSuperclass();
Field fieldLastVersion = classObserverWrapper.getDeclaredField("mLastVersion");
fieldLastVersion.setAccessible(true);
//get livedata's version
Field fieldVersion = classLiveData.getDeclaredField("mVersion");
fieldVersion.setAccessible(true);
Object objectVersion = fieldVersion.get(this);
//set wrapper's version
fieldLastVersion.set(objectWrapper, objectVersion);
}
}
}
这样 LiveDataBus 的实现及其简单 相对 EventBus 复杂的实现，LiveDataBus 只需要一个类就可以实现。
该方案是美团技术团队提供的，并且通过演进，他们封装了 LiveEventBus 是一款 Android 消息总线，基于 LiveData，具有生命周期感知能力，支持 Sticky，支持 AndroidX，支持跨进程，支持跨 APP，感兴趣的可以看下具体实现：
[github.com/JeremyLiao/…](
)
可以看下他们针对常用消息总线对比：
[](
)4、UnPeekLiveData 经过深度思考的解决粘性事件方案
UnPeekLiveData 具有如下特性：
一条消息能被多个观察者消费
消息被所有观察者消费完毕后才开始阻止倒灌
可以通过 clear 方法手动将消息从内存中移除
让非入侵设计成为可能，遵循开闭原则
基于 “访问权限控制” 支持 "读写分离”，遵循唯一可信源的消息分发理念
UnPeekLiveData 提供了构造器模式，可通过构造器组装适合自己业务场景的 UnPeekLiveData。
UnPeekLiveData<Moment> test =
new UnPeekLiveData.Builder<Moment>()
.setAllowNullValue(false)
.create();
具体是实现：
[](
)ProtectedUnPeekLiveData：
public class ProtectedUnPeekLiveData<T> extends LiveData<T> {
protected boolean isAllowNullValue;
private final HashMap<Integer, Boolean> observers = new HashMap<>();
public void observeInActivity(@NonNull AppCompatActivity activity, @NonNull Observer<? super T> observer) {
LifecycleOwner owner = activity;
Integer storeId = System.identityHashCode(activity.getViewModelStore());
observe(storeId, owner, observer);
}
public void observeInFragment(@NonNull Fragment fragment, @NonNull Observer<? super T> observer) {
LifecycleOwner owner = fragment.getViewLifecycleOwner();
Integer storeId = System.identityHashCode(fragment.getViewModelStore());
observe(storeId, owner, observer);
}
private void observe(@NonNull Integer storeId,
@NonNull LifecycleOwner owner,
@NonNull Observer<? super T> observer) {
if (observers.get(storeId) == null) {
observers.put(storeId, true);
}
super.observe(owner, t -> {
if (!observers.get(storeId)) {
observers.put(storeId, true);
if (t != null || isAllowNullValue) {
observer.onChanged(t);
}
}
});
}
/**
重写的 setValue 方法，默认不接收 null
可通过 Builder 配置允许接收
可通过 Builder 配置消息延时清理的时间
<p>
override setValue, do not receive null by default
You can configure to allow receiving through Builder
And also, You can configure the delay time of message clearing through Builder
@param value
*/
@Override
protected void setValue(T value) {
if (value != null || isAllowNullValue) {
for (Map.Entry<Integer, Boolean> entry : observers.entrySet()) {
entry.setValue(false);
}
super.setValue(value);
}
}
protected void clear() {
super.setValue(null);
}
}
[](
)UnPeekLiveData
public class UnPeekLiveData<T> extends ProtectedUnPeekLiveData<T> {
@Override
public void setValue(T value) {
super.setValue(value);
}
@Override
public void postValue(T value) {
super.postValue(value);
}
/**
TODO：Tip：请不要在 UnPeekLiveData 中使用 observe 方法。
取而代之的是在 Activity 和 fragment 中分别使用 observeInActivity 和 observeInFragment 来观察。
<p>
2020.10.15 背景缘由：
UnPeekLiveData 通过 ViewModelStore 来在各种场景下（如旋屏后）确定订阅者的唯一性和消息的消费状况，
因而在 Activity 和 fragment 对 LifecycleOwner 的使用存在差异的现状下，
我们采取注入局部变量的方式，来获取 store 和 owner。
@param owner
@param observer
*/
@Override
@Deprecated
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
throw new IllegalArgumentException("请不要在 UnPeekLiveData 中使用 observe 方法。" +
"取而代之的是在 Activity 和 Fragment 中分别使用 observeInActivity 和 observeInFragment 来观察。\n\n" +
还未添加个人签名 2021.10.31 加入
还未添加个人简介
评论