- 1. 现象
- 2. 粘性事件的原理
- 3. 去掉粘性事件
在使用Jetpack的LiveData时，我们经常会遇到所谓的粘性事件，具体什么是粘性事件呢？我们可以看一个例子，存在两个Activity,分别为FirstActivity和SecondActivity, 我们在FirstActivity中先发射了数据，然后进入了SecondActivity中，在SecondActivity中监听LiveData的变化，但是我们会很惊奇的发现，SecondActivity在FirstActivity发射之后才注册监听LiveData的事件，居然也能收到以前的发射数据。这就有些和我们的尝试相悖了，我们一般的常识，是先注册监听事件了才会有事件回调，并且注册事件是不管之前发生的逻辑的。
我们可以看一下具体表现形式：
现在我们可以简单的过一下源码，LiveData的源码算是比较简单的，基本上能在很短的时间内去掌握的。
对于LiveData的用法，这里就不详细去讲了，我们直接看一个代码：
private val mLiveData : MutableLiveData= MutableLiveData() fun sendEvent(content: String) { mLiveData.value = content }
直接调用LiveData#setValue()方法：
@MainThread
protected void setValue(T value) {
mVersion++;
mData = value;
dispatchingValue(null);
}
setValue主要做了三件事：
- 设置将版本号mVersion + 1, 那么此时mVersion经过++之后，由默认值-1变为了0；
- 将 mData设置为最新值；
- 通知已经注册的监听器，mData已经发生改变，请及时更改。
在dispatchingValue方法中，我们可以看到参数填的是null,那么再次进入代码：
void dispatchingValue(@Nullable ObserverWrapper initiator) {
// ... 代码省略
for (Iterator, ObserverWrapper>> iterator
= mObservers.iteratorWithAdditions();
iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
对于每一个监听器来说，需要走一遍considerNotify方法：
private void considerNotify(ObserverWrapper observer) {
// ... 代码省略
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}
这里有一个判断，如果当前的ObserverWrapper的版本mLastVersion大于或者当前的mVersion,将不会再执行下去，代码直接返回。如果observer.mLastVersion的版本号小于mVersion,那么更新版本号，然后调用mObserver.onChanged回调。
过完了setValue逻辑，我们再来一下注册事件：
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
//... 代码省略
//1.
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
//2.
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
//3.
owner.getLifecycle().addObserver(wrapper);
}
同样，在observe中也同样做了三件事：
- 将我们的Observer封装成LifecycleBoundObserver, 因为需要在Android组件中运行，所以需要设置生命周期的边界；
- 将封装之后的LifecycleBoundObserver保存到 Observers Map集合中；
- 将封装之后的LifecycleBoundObserver添加到Lifecycle组件中，方便监听生命周期事件的变化。
现在我们需要把目光移到LifecycleBoundObserver源码中，因为已经被LifecycleOwner添加过，因此在监听到Activity的生命周期变化时，会触发onStateChanged方法：
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
}
在该方法中，将Lifecycle.State进行了更新，使得能和宿主LifeCycleOwner生命周期一致，然后调用activeStateChanged方法：
void activeStateChanged(boolean newActive) {
mActive = newActive;
changeActiveCounter(mActive ? 1 : -1);
if (mActive) {
dispatchingValue(this);
}
}
我们可以看到，最终还是会调用dispatchingValue方法，但是此时传入的参数并不是null,而是ObserverWrapper自己本身，因此进入：
void dispatchingValue(@Nullable ObserverWrapper initiator) {
//代码省略
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {
considerNotify(initiator);
initiator = null;
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
然后我们进入considerNotify方法：
private void considerNotify(ObserverWrapper observer) {
// 代码省略....
// 条件①
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}
此时，我们可以看到, observer.mLastVersion是初始值，为-1, 但是mVersion由于刚才设置了一次，所以mVersion现在的值为0，因此条件①不成立，会进入下面的回调阶段，此时就会出现，刚一注册，就会收到上次发射数据的回调。
源码到这里，基本上就流程就走了一遍了。
首先，这个粘性事件并不是Google的一个bug，他们这么写肯定是有他们的作用的。有些特殊情况下我们还是需要粘性事件的。但是对于一般情况下，如果我们想去掉这个粘性事件，应该如何操作呢？
我们使用的是反射去做的，由于分析过源码，其实最容易入手的地方就是 observer.mLastVersion >= mVersion 这个条件了。我们在注册Observer之后，在宿主下一个生命周期事件到来之前，把我们的Observer 的mLastVesion强制设置为mVersion的值就行了。
下面贴一下代码：
public class LiveDataStickinessFixUtils {
public static void fixStickiness(MutableLiveData liveData) {
try {
// 第一步
Field versionField = liveData.getClass().getSuperclass().getDeclaredField("mVersion");
versionField.setAccessible(true);
Integer currentVersion = (Integer) versionField.get(liveData);
if (null == currentVersion) {
Log.e("TAG", "live data version is null");
return;
}
// 第二步
Field mObserversField = liveData.getClass().getSuperclass().getDeclaredField("mObservers");
mObserversField.setAccessible(true);
Iterable iterable = (Iterable) mObserversField.get(liveData);
if (null == iterable) {
Log.d("TAG", "live data mObservers is null");
return;
}
// 第三步
Iterator iterator = iterable.iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry) iterator.next();
Object value = entry.getValue();
Log.d("TAG","show the value:" + value + "," + value.getClass());
Field mLastVersionField = value.getClass().getSuperclass().getDeclaredField("mLastVersion");
mLastVersionField.setAccessible(true);
mLastVersionField.set(value, currentVersion);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
下面来主要介绍这三步的作用：
第一步： 获取到LiveData中的mVersion值，因此这个mVersion值是未知的，所以需要动态获取；
第二步：将LiveData中所有注册的ObserverWrapper监听器统一取出来；
第三步：通过反射，将注册的ObserverWrapper中属性值mLastVersion通过反射设置为mVersion值。
然后在使用：
class SecondLiveDataUI : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.second_live_data_layout)
MyLiveDataManager.findLiveData().observe(this) { t -> Toast.makeText(this@SecondLiveDataUI, t, Toast.LENGTH_LONG).show() }
LiveDataStickinessFixUtils.fixStickiness(MyLiveDataManager.findLiveData());
}
}
在我们设置Observe监听之后，立即调用我们的LiveDataStickinessFixUtils.fixStickiness方法即可，然后就可以去掉所谓的粘性事件了。
