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

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

    constructor() : super()

    constructor(value: T) : super(value)

    private var startVersion: Int = -1

    private val mCurrentVersion = AtomicInteger(startVersion)

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

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

    /**
     *  當(dāng) liveData 用作 state 時(shí)，可使用該方法來(lái)觀察 "生命周期不敏感" 粘性消息
     **/
    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)
        }
    }
}

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

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方法里面進(jìn)行回收,避免了手動(dòng)去調(diào)用移除