【Jetpack系列】理解LiveData的粘性事件，并去除

文章目录

1. 现象

在使用Jetpack的LiveData时，我们经常会遇到所谓的粘性事件，具体什么是粘性事件呢？我们可以看一个例子，存在两个Activity,分别为FirstActivity和SecondActivity, 我们在FirstActivity中先发射了数据，然后进入了SecondActivity中，在SecondActivity中监听LiveData的变化，但是我们会很惊奇的发现，SecondActivity在FirstActivity发射之后才注册监听LiveData的事件，居然也能收到以前的发射数据。这就有些和我们的尝试相悖了，我们一般的常识，是先注册监听事件了才会有事件回调，并且注册事件是不管之前发生的逻辑的。

我们可以看一下具体表现形式：
在这里插入图片描述

2. 粘性事件的原理

现在我们可以简单的过一下源码，LiveData的源码算是比较简单的，基本上能在很短的时间内去掌握的。
对于LiveData的用法，这里就不详细去讲了，我们直接看一个代码：

    private val mLiveData : MutableLiveData<String> = 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<Map.Entry<Observer<? super T>, 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逻辑，我们再来一下注册事件：

扫描二维码关注公众号，回复： 15430649 查看本文章

    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> 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，因此条件①不成立，会进入下面的回调阶段，此时就会出现，刚一注册，就会收到上次发射数据的回调。
源码到这里，基本上就流程就走了一遍了。

3. 去掉粘性事件

首先，这个粘性事件并不是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方法即可，然后就可以去掉所谓的粘性事件了。