[移动开发] 【Jetpack系列】理解LiveData的粘性事件，并去除

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 移动开发 -> 【Jetpack系列】理解LiveData的粘性事件，并去除 -> 正文阅读

[移动开发]【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逻辑，我们再来一下注册事件：

    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());

    }
}