public void onResume() {
super.onResume();
mViewModel.navigateToDetails().observe(this, new Observer() {
@Override
public void onChanged(Boolean aBoolean) {
if (mViewModel.navigateToDetails().getValue()){
myViewModel.navigateToDetailsHandled()
NavigatorUser.starDetailActivity();
}
}
});
}
然后在 MainActivityViewModel 中添加一个 navigateToDetailsHandled() 方法：
public class MainActivityViewModel extends ViewModel {
//对外提供请求接口对象
public final CommonRequest commonRequest = new CommonRequest();
private SingleLiveEvent _navigateToDetails = new SingleLiveEvent<>();
public LiveData navigateToDetails(){
return _navigateToDetails;
}
public void userClicksOnButton() {
_navigateToDetails.setValue(true);
}
//新增方法
public void navigateToDetailsHandled() {
_navigateToDetails.setValue(true);
}
}
这种方法的问题是：存在很多样板代码，
ViewModel 中每添加一个事件都要添加一个对应的方法，并且很容易出错。
此外，观察者（View）很容易忘记调用 ViewModel 的这个方法。
一种还可以接受的解决方案是：SingleLiveEvent。
这个类是 Google 官方 Demo 中的适用于这种特殊场景的解决方案，它是一个仅发送一次更新的 LiveData。
SingleLiveEvent代码如下：
/**
-
A lifecycle-aware observable that sends only new updates after subscription, used for events like
-
navigation and Snackbar messages.
-
-
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().
-
-
Note that only one observer is going to be notified of changes.
*/
public class SingleLiveEvent extends MutableLiveData {
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() {
@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
public void call() {
setValue(null);
}
}
MainActivityViewModel中使用SingleLiveEvent：
public class MainActivityViewModel extends ViewModel {
private SingleLiveEvent _navigateToDetails = new SingleLiveEvent<>();
public LiveData navigateToDetails(){
return _navigateToDetails;
}
public void userClicksOnButton() {
_navigateToDetails.setValue(true);
}
}
MainActivity中监听：
@Override
public void onResume() {
super.onResume();
mViewModel.navigateToDetails().observe(this, new Observer() {
@Override
public void onChanged(Boolean aBoolean) {
if (mViewModel.navigateToDetails().getValue()){
NavigatorUser.starDetailActivity();
}
}
});
}
官网针对SingleLiveEvent参考链接如下：
SingleLiveEvent 的问题在于：它仅限于一个观察者。如果你无意中添加了多个，则只会有一个收到回调，并且无法保证哪一个会收到。
3、LiveDataBus消息总线替代RxBus、EventBus
通过LiveDataBus可以实现如下需求：
-
基于 LiveData 组件；
-
保证内存不会泄漏；
-
不用反注册消息总线；
先看一下LiveDataBus用法：
注册订阅
LiveDataBus.get()
.with(“key_test”, String.class)
.observe(this, new Observer() {
@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> 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 MutableLiveData with(String key, Class type) {
if (!bus.containsKey(key)) {
bus.put(key, new BusMutableLiveData<>());
}
return (MutableLiveData) bus.get(key);
}
public MutableLiveData with(String key) {
return with(key, Object.class);
}
private static class ObserverWrapper implements Observer {
private Observer observer;
public ObserverWrapper(Observer 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 extends MutableLiveData {
private Map<Observer, Observer> observerMap = new HashMap<>();
@Override
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
super.observe(owner, observer);
try {
hook(observer);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void observeForever(@NonNull Observer observer) {
if (!observerMap.containsKey(observer)) {
observerMap.put(observer, new ObserverWrapper(observer));
}
super.observeForever(observerMap.get(observer));
}
@Override
public void removeObserver(@NonNull Observer observer) {
Observer realObserver = null;
if (observerMap.containsKey(observer)) {
realObserver = observerMap.remove(observer);
} else {
realObserver = observer;
}
super.removeObserver(realObserver);
}
private void hook(@NonNull Observer observer) throws Exception {
//get wrapper’s version
Class 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，感兴趣的可以看下具体实现：
可以看下他们针对常用消息总线对比： 
4、UnPeekLiveData经过深度思考的解决粘性事件方案
UnPeekLiveData具有如下特性：
- 一条消息能被多个观察者消费
- 消息被所有观察者消费完毕后才开始阻止倒灌
- 可以通过 clear 方法手动将消息从内存中移除
- 让非入侵设计成为可能，遵循开闭原则
- 基于 “访问权限控制” 支持 "读写分离”，遵循唯一可信源的消息分发理念
UnPeekLiveData 提供了构造器模式，可通过构造器组装适合自己业务场景的 UnPeekLiveData。
UnPeekLiveData test =
new UnPeekLiveData.Builder()
.setAllowNullValue(false)
.create();
具体是实现：
ProtectedUnPeekLiveData：
public class ProtectedUnPeekLiveData extends LiveData {
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 配置消息延时清理的时间
-
-
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 extends ProtectedUnPeekLiveData {
@Override
public void setValue(T value) {
super.setValue(value);
}
@Override
public void postValue(T value) {
super.postValue(value);
}
/**
- TODO：Tip：请不要在 UnPeekLiveData 中使用 observe 方法。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）
尾声
最后，我再重复一次，如果你想成为一个优秀的 Android 开发人员，请集中精力，对基础和重要的事情做深度研究。
对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。 整理的这些架构技术希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。
最后想要拿高薪实现技术提升薪水得到质的飞跃。最快捷的方式，就是有人可以带着你一起分析，这样学习起来最为高效，所以为了大家能够顺利进阶中高级、架构师，我特地为大家准备了一套高手学习的源码和框架视频等精品Android架构师教程，保证你学了以后保证薪资上升一个台阶。
当你有了学习线路，学习哪些内容，也知道以后的路怎么走了，理论看多了总要实践的。
进阶学习视频
附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
知识点，真正体系化！**
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）
尾声
最后，我再重复一次，如果你想成为一个优秀的 Android 开发人员，请集中精力，对基础和重要的事情做深度研究。
对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。 整理的这些架构技术希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。
最后想要拿高薪实现技术提升薪水得到质的飞跃。最快捷的方式，就是有人可以带着你一起分析，这样学习起来最为高效，所以为了大家能够顺利进阶中高级、架构师，我特地为大家准备了一套高手学习的源码和框架视频等精品Android架构师教程，保证你学了以后保证薪资上升一个台阶。
当你有了学习线路，学习哪些内容，也知道以后的路怎么走了，理论看多了总要实践的。
进阶学习视频
[外链图片转存中…(img-mkNWTyWg-1712772797493)]
附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）
[外链图片转存中…(img-zYpuAq1T-1712772797493)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
868
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
