该方法的优势：
Activity 不需要执行任何操作，也不需要对此通信有任何了解。
除了 SharedViewModel 约定之外，Fragment 不需要相互了解。如果其中一个 Fragment 消失，另一个 Fragment 将继续照常工作。
每个 Fragment 都有自己的生命周期，而不受另一个 Fragment 的生命周期的影响。如果一个 Fragment 替换另一个 Fragment，界面将继续工作而没有任何问题。
2、SingleLiveEvent官方解决单次监听的方案
视图层（Activity 或者 Fragment）与 ViewModel 层进行通讯的一种便捷的方式就是使用 LiveData 来进行观察。这个视图层订阅 Livedata 的数据变化并对其变化做出反应。这适用于连续不断显示在屏幕的数据，比如上面LiveData和ViewModel实现跨页面通信的列子。
但是，有一些数据只会消费一次，就像是 Snackbar 消息，导航事件或者一个触发 Dialog 展示/消失的数据。
如下场景，主页面监听是否跳转到详情页面，来执行跳转逻辑的情况：
主页的 MainActivityViewModel 代码如下：
public class MainActivityViewModel extends ViewModel {
private MutableLiveEvent _navigateToDetails = new MutableLiveEvent<>();
public LiveData navigateToDetails(){
return _navigateToDetails;
}
public void userClicksOnButton() {
_navigateToDetails.setValue(true);
}
}
主页面onResume中监听，保证每次到主页面就监听：
@Override
public void onResume() {
super.onResume();
mViewModel.navigateToDetails().observe(this, new Observer() {
@Override
public void onChanged(Boolean aBoolean) {
if (mViewModel.navigateToDetails().getValue()){
NavigatorUser.starDetailActivity();
}
}
});
}
这种使用方式的问题是：_navigateToDetails 中的值会永远为 true，从而导致无法回到首页。 复现步骤是：
用户点击按钮，启动详情页 DetailsActivity
用户点击返回键，返回到主界面 MainActivity
这时 MainActivity 由非活动状态恢复到活动状态
但 myViewModel 观察到 _navigateToDetails 仍旧为 true，就又跳转到详情页 DetailsActivity
一种看起来没问题的解决方案是：页面跳转后立马把标志位设为 false，如 MainActivityViewModel 所示：
public void userClicksOnButton() {
_navigateToDetails.setValue(true);
_navigateToDetails.setValue(false);
}
然而，需要注意的是：
LiveData 不能保证发射它接收到的每个数据值。
例如我们在没有活动的观察者时设置了一个新值，这个新值不会被发送，
此外，在多个子线程中操作 LiveData 可能发生竞争状况，从而导致观察者只会收到一次回调。
但这个方案的主要问题是：别人很难看懂这个代码，并且这种代码也很丑陋。那么，我们应该怎么确保在导航事件发生后恢复初值呢？
另一种稍微好点，但仍有问题的方案是：View 告诉 ViewModel，导航事件已经完成，LiveData 应该恢复默认值了。
@Override
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) {
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）
结语
网上高级工程师面试相关文章鱼龙混杂，要么一堆内容，要么内容质量太浅， 鉴于此我整理了上述安卓开发高级工程师面试题以及答案。希望帮助大家顺利进阶为高级工程师。
目前我就职于某大厂安卓高级工程师职位，在当下大环境下也想为安卓工程师出一份力，通过我的技术经验整理了面试经常问的题，答案部分是一篇文章或者几篇文章，都是我认真看过并且觉得不错才整理出来。
大家知道高级工程师不会像刚入门那样被问的问题一句话两句话就能表述清楚，所以我通过过滤好文章来帮助大家理解。
现在都说互联网寒冬，其实只要自身技术能力够强，咱们就不怕！我这边专门针对Android开发工程师整理了一套【Android进阶学习视频】、【全套Android面试秘籍】、【Android知识点PDF】。
一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
2856143108)]
[外链图片转存中…(img-39VypHVr-1712856143108)]
[外链图片转存中…(img-h0pWfELR-1712856143108)]
[外链图片转存中…(img-jAS86AP8-1712856143109)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-XO1Y5q4O-1712856143109)]
结语
网上高级工程师面试相关文章鱼龙混杂，要么一堆内容，要么内容质量太浅， 鉴于此我整理了上述安卓开发高级工程师面试题以及答案。希望帮助大家顺利进阶为高级工程师。
目前我就职于某大厂安卓高级工程师职位，在当下大环境下也想为安卓工程师出一份力，通过我的技术经验整理了面试经常问的题，答案部分是一篇文章或者几篇文章，都是我认真看过并且觉得不错才整理出来。
大家知道高级工程师不会像刚入门那样被问的问题一句话两句话就能表述清楚，所以我通过过滤好文章来帮助大家理解。
[外链图片转存中…(img-XUDtZ6J1-1712856143109)]
现在都说互联网寒冬，其实只要自身技术能力够强，咱们就不怕！我这边专门针对Android开发工程师整理了一套【Android进阶学习视频】、【全套Android面试秘籍】、【Android知识点PDF】。
一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-gPDd7EM6-1712856143110)]