升职加薪学习旅程 -- 设置防止数据倒灌+ 永久监听的LiveData

首先这里是使用了GitHub中UnPeek-LiveData的代码,用来构造一个AntiBackFlowLiveData,"数据倒灌"这个也是在里面有解释就不做赘述

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作为版本控制,避免数据的倒灌
为了方便使用一个全局的"AppViewModel"来进行一个Event的发送,所以在理论上是使用LiveData.observeForever这个方法来进行监听,但是在使用observeForever这个方法时需要在activity/Fragment被销毁是remove掉这个lifecycleOwner,所以这里对LiveData进行一个生命周期的扩展,让我们在使用的时候只需要监听,不需要去管理其他的生命周期

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方法里面进行回收,避免了手动去调用移除