首先這里是使用了GitHub中UnPeek-LiveData的代碼,用來構造一個AntiBackFlowLiveData,"數(shù)據(jù)倒灌"這個也是在里面有解釋就不做贅述

open class AntiBackFlowLiveData<T> : LiveData<T> {

    constructor() : super()

    constructor(value: T) : super(value)

    private var startVersion: Int = -1

    private val mCurrentVersion = AtomicInteger(startVersion)

    /**
     *  當 liveData 用作 event 時成艘，可使用該方法觀察 "生命周期敏感" 非粘性消息
     **/
    override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
        super.observe(owner, createObserverWrapper(observer, mCurrentVersion.get()))
    }

    /**
     *  當 liveData 用作 event 時赏半，可使用該方法觀察 "生命周期不敏感" 非粘性消息
     **/
    override fun observeForever(observer: Observer<in T>) {
        super.observeForever(createObserverWrapper(observer, mCurrentVersion.get()))
    }

    /**
     *  當 liveData 用作 state 時，可使用該方法來觀察 "生命周期不敏感" 粘性消息
     **/
    fun observeSticky(owner: LifecycleOwner, observer: Observer<in T>) {
        super.observe(owner, createObserverWrapper(observer, startVersion))
    }

    public override fun setValue(value: T) {
        mCurrentVersion.getAndIncrement()
        super.setValue(value)
    }

    public override fun postValue(value: T) {
        super.postValue(value)
    }

    private fun createObserverWrapper(observer: Observer<in T>, version: Int): ObserverWrapper<T> {
        return ObserverWrapper(observer, version)
    }

    override fun removeObserver(observer: Observer<in T>) {
        if (observer::class.java.isAssignableFrom(ObserverWrapper::class.java)) {
            super.removeObserver(observer)
        } else {
            super.removeObserver(createObserverWrapper(observer, startVersion))
        }
    }

    fun clear() {
        super.setValue(null)
    }

    inner class ObserverWrapper<T>(val observer: Observer<in T>, var version: Int) : Observer<T> {

        override fun onChanged(t: T?) {
            if (mCurrentVersion.get() > version) {
                observer.onChanged(t)
            }
        }

        override fun equals(other: Any?): Boolean {
            if (other == null || other::class.java != this::class.java) {
                return false
            }
            if (this === other) {
                return true
            }

            return Objects.equals(observer, (other as ObserverWrapper<*>).observer)
        }

        override fun hashCode(): Int {
            return Objects.hash(observer)
        }
    }
}

這里使用了自己的一個Version作為版本控制,避免數(shù)據(jù)的倒灌
為了方便使用一個全局的"AppViewModel"來進行一個Event的發(fā)送,所以在理論上是使用LiveData.observeForever這個方法來進行監(jiān)聽,但是在使用observeForever這個方法時需要在activity/Fragment被銷毀是remove掉這個lifecycleOwner,所以這里對LiveData進行一個生命周期的擴展,讓我們在使用的時候只需要監(jiān)聽,不需要去管理其他的生命周期

class ForeverLiveData<T> : AntiBackFlowLiveData<T>(), DefaultLifecycleObserver {
    private val mOwners: MutableList<LifecycleOwner> = mutableListOf()
    private val ownerMap  = mutableMapOf<Int,Observer<in T>>()

    fun observeForever(lifecycleOwner: LifecycleOwner, observer: Observer<in T>) {
        super.observeForever(observer)
        lifecycleOwner.lifecycle?.addObserver(this)
        mOwners.add(lifecycleOwner)
        ownerMap[lifecycleOwner.hashCode()] = observer
    }

    override fun onDestroy(owner: LifecycleOwner) {
        for ((key,value) in ownerMap){
            if (key == owner.hashCode()){
                this.removeObserver(value)
                ownerMap.remove(key)
            }
        }
        mOwners.forEach {
            if (owner == it) {
                it.lifecycle.removeObserver(this)
                mOwners.remove(it)
            }
        }
        super.onDestroy(owner)
    }
}

上述代碼繼承了DefaultLifecycleObserver ,并在onDestroy方法里面進行回收,避免了手動去調用移除