Android 开发把 -LiveData- 用于事件传递那些坑,一文详解
postSetValue(mld, d);}}
/**
向主线程的 handler 抛 SetValueRunnable*/public static <T> void postSetValue(MutableLiveData<T> mld, T d) {if (sMainHandler == null) {sMainHandler = new Handler(Looper.getMainLooper());}sMainHandler.post(SetValueRunnable.create(mld, d));}
private static class SetValueRunnable<T> implements Runnable {private final MutableLiveData<T> liveData;private final T data;
private SetValueRunnable(@NonNull MutableLiveData<T> liveData, T data) {this.liveData = liveData;this.data = data;}
@Overridepublic void run() {liveData.setValue(data);}
public static <T> SetValueRunnable<T> create(@NonNull MutableLiveData<T> liveData, T data) {return new SetValueRunnable<>(liveData, data);}}}
3.2、非激活状态的问题
其实我觉得这个问题的主要「责任」并不在 LiveData,而是在它的观察者,「是你告诉我你非激活的呀,那我怎么给你发数据呢,我发给你,万一你出问题了呢,那到底谁负责?」。我们常用的观察者其实是 LifecycleBoundObserver,在调用 public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) 会自动帮我们封装一个这样的观察者,而它会根据 LifecycleOwner 的生命周期呈现出「激活」和「非激活」状态。
// LifecycleBoundObserverboolean shouldBeActive() {return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);}
LiveData 默认的还有另外一种观察者 AlwaysActiveObserver,它是我们在调用 public void observeForever(@NonNull Observer<? super T> observer) 时生成的,顾名思义它会一直处于激活状态,LiveData 当然也不会替我们管理这样观察者的生命周期,我们需要在不使用时手动调用 public void removeObserver(@NonNull final Observer<? super T> observer) 移除观察者,否则可能会内存泄漏。
// AlwaysActiveObserverboolean shouldBeActive() {return true;}
这个 AlwaysActiveObserver 看样子能够解决我们的问题,他一直处于激活状态,那所有的事件都会回调给他,但是需要我们自己管理生命周期。这不是开历史倒车吗?好不容易有生命周期感知了,现在又要自己手动搞?
3.3、造一个生命周期感知的还不丢事件的观察者
手动管理生命周期是绝对不能忍的,AlwaysActiveObserver 可以解决刚才说的问题,那我们就造一个新的观察者来管理 observeForever 和 removeObserver 的问题。既然要造,那就造个好用的,首先事件一定不能丢,要不就没意义了;而且生命周期要观察者自己管理,不能只是简单的 observeForever 和 removeObserver,非激活状态之类的也要考虑进去。既然要管理生命周期,那就不得不用到 LifecycleOwner、Lifecycle,然后自己观察 LifecycleOwner 的 Lifecycle。
/**
Marks a class as a LifecycleObserver. It does not have any methods, instead, relies on
{@link OnLifecycleEvent} annotated methods.
<p>
@see Lifecycle Lifecycle - for samples and usage patterns.*/@SuppressWarnings("WeakerAccess")public interface LifecycleObserver {
}
Lifecycle 对外只给了这个接口,并不含有任何回调,我们需要用注释里说的 OnLifecycleEvent 注解来标记相应的函数,Lifecycle 会通过反射拿到标记的函数,然后生成对应的适配器,感兴趣的可以看下 Lifecycling.getCallback 函数。比如我们可以这样用
public class Observer implements LifecycleObserver {@OnLifecycleEvent(Lifecycle.Event.ON_START)private void onStart() {doSomethingOnStart();}}
拿到生命周期后,我们就可以在一开始 observeForever
,在 Lifecycle.Event.ON_DESTROY
时 removeObserver
。接下来就要考虑激活和非激活的状态了,既然用了 observeForever
,那每次事件都会有回调,这时候如果 Lifecycle
处于激活状态,那可以直接把事件发出去。但如果非激活,不能直接把事件发出去,又不能丢,那我们就需要先把事件存起来,然后在 Lifecycle
变为激活状态时再把存起来的事件发送出去。简单画了下流程图。
![](https://static001.infoq.cn/static/write/img/img-copy-disabled.4f2g7h.png)
/**
LiveData 用作事件传递时的观察者
保证所有事件不丢失,保存非激活状态的事件,并能够在激活状态回调,且没有内存泄漏
@see AsEventBus
@author funnywolf
@since 2019-05-18*/public class LiveEventObserver<T> implements LifecycleObserver, Observer<T
{private LiveData<T> mLiveData;private LifecycleOwner mOwner;private Observer<? super T> mObserver;
private final List<T> mPendingData = new ArrayList<>();
public LiveEventObserver(LiveData<T> liveData, LifecycleOwner owner, Observer<? super T> observer) {mLiveData = liveData;mOwner = owner;mObserver = observer;mOwner.getLifecycle().addObserver(this);mLiveData.observeForever(this);}
/**
在生命周期结束前的任何时候都可能会调用*/@Overridepublic void onChanged(@Nullable T t) {if (isActive()) {// 如果是激活状态,就直接更新 mObserver.onChanged(t);} else {// 非激活状态先把数据存起来 mPendingData.add(t);}}
/**
@return 是否是激活状态,即 onStart 之后到 onPause 之前*/private boolean isActive() {return mOwner.getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED);}
/**
onStart 之后就是激活状态了,如果之前存的有数据,就发送出去*/@OnLifecycleEvent(Lifecycle.Event.ON_ANY)private void onEvent(LifecycleOwner owner, Lifecycle.Event event) {if (owner != mOwner) {return;}if (event == Lifecycle.Event.ON_START || event == Lifecycle.Event.ON_RESUME) {for (int i = 0; i < mPendingData.size(); i++) {mObserver.onChanged(mPendingData.get(i));}mPendingData.clear();}}
/**
onDestroy 时解除各方的观察和绑定,并清空数据*/@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)private void onDestroy() {mLiveData.removeObserver(this);mLiveData = null;
mOwner.getLifecycle().removeObserver(this);mOwner = null;
mPendingData.clear();
mObserver = null;}
public static <T> void bind(@NonNull LiveData<T> liveData,@NonNull LifecycleOwner owner,@NonNull Observer<? super T> observer) {if (owner.getLifecycle().getCurrentState() == Lifecycle.State.DESTROYED) {return;}new LiveEventObserver<>(liveData, owner, observer);}}
3.4、保证 LiveData 的事件更新
3.1 也说过要自己处理 postValue,其次要保证用我们自己定义的观察者,需要重写 public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer)。
/**
用作事件总线的 {@link MutableLiveData}
@see AsEventBus
@author funnywolf
@since 2019-05-18*/public class EventMutableLiveData<T> extends MutableLiveData<T> {@Overridepublic void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {LiveEventObserver.bind(this, owner, observer);}
@Overridepublic void postValue(T value) {LiveDataUtils.setValue(this, value);}}
/**
用作事件总线的 {@link MediatorLiveData}
@see AsEventBus
@author funnywolf
@since 2019-05-18*/public class EventMediatorLiveData<T> extends MediatorLiveData<T> {
评论