解决livedata的粘性事件

MyMutableLiveData 继承 MutableLiveData

class MyMutableLiveData : MutableLiveData<Any>() {
    open inner class WrapperObserver(private val stick : Boolean = false, //是否是粘性观察，是的话会收到订阅之前的消息
    private val observer : Observer<Any>) : Observer<Any> {

    /**
     * 是否是新加入的观察者
     */
    private val isFirstObserver : AtomicBoolean = AtomicBoolean(true)
    override fun onChanged(t : Any) {
        if(mLock.get() && !stick) {
            //当前是锁定状态非粘性观察者，且是新的观察者，设置成不是新观察者。如果不是新观察者，则通知
            if(isFirstObserver.compareAndSet(false, false)) {
                observer.onChanged(t)
            }
        } else {
            //非锁定状态或粘性观察者，修改为不是新观察者，接收通知
            isFirstObserver.set(false)
            observer.onChanged(t)
        }
    }
}

    //消息通知锁
    private val mLock : AtomicBoolean = AtomicBoolean(true)

    override fun observe(owner : LifecycleOwner, observer : Observer<Any>) {
        observe(owner, false, observer)
    }


    fun observe(owner : LifecycleOwner, stick : Boolean = false, observer : Observer<Any>) {
        //新来的观察者锁住消息通知
        mLock.set(true)
        super.observe(owner, WrapperObserver(stick, observer))
    }

    override fun observeForever(observer : Observer<Any>) {
        observeForever(false, observer)
    }

    fun observeForever(stick : Boolean = false, observer : Observer<Any>) {
        //新来的观察者锁住消息通知
        mLock.set(true)
        super.observeForever(WrapperObserver(stick, observer))
    }

    @MainThread
    override fun setValue(t : Any?) {
        mLock.set(false)
        super.setValue(t)
    }

    override fun postValue(value : Any?) {
        mLock.set(false)
        super.postValue(value)
    }

    /**
     * Used for cases where T is Void, to make calls cleaner.
     */
    @MainThread
    fun call() {
        value = null
    }
}

LiveDataBus

object LiveDataBus {

    private val liveDataMap by lazy {
        hashMapOf<String, MutableLiveData<Any>>()
    }

    fun register(key:String): MyMutableLiveData {
        if (!liveDataMap.containsKey(key)){
            liveDataMap[key] = MyMutableLiveData()
        }
        return liveDataMap[key] as MyMutableLiveData
    }
}

使用

LiveDataBus.register(TAG).postValue(position)

LiveDataBus.register(TAG).observe(owner){
                
}