即使使用removeObserver也永远调用Livedata observer

Question

我正面临一个让我发疯的问题。

我尝试在onDestroyView（）中删除观察者，它可以工作，观察者被删除，但是一旦片段再次进入onActivityCreated（）中，并且我观察到livedata，观察者就会立即被触发...我总是使用“ViewLifecyCleOwner”作为所有者。

如果我返回实例化片段，是否有任何方法可以取消liveData的执行？

我所有的frag都扩展了ScopeFragment：

abstract class ScopedFragment : Fragment(), CoroutineScope {
    private lateinit var job: Job

    override val coroutineContext: CoroutineContext
        get() = job + Dispatchers.Main

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        job = Job()
    }

    override fun onDestroy() {
        super.onDestroy()
        job.cancel()
    }
}

class MyLiveDatas {
    private val _myLiveData = MutableLiveData<CustomType>()
    val myLiveData: LiveData<CustomType>
        get() = _myLiveData


    fun customTrigger(webSocketMessage: WebSocketMessage) {
        val createdCustomType = CreatedCustomType(webSocketMessage)
        _myLiveData.post(createdCustomType)
    }
}

class MyFragment: ScopedFragment(), KodeinAware {

    override val kodein by closestKodein()
    private val myLiveData: MyLiveDatas by instance()

    private val myLiveDataObserver = Observer<CustomType> { customType ->
        ... my actions
    }

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)

        myLiveDatas.myLiveData.observe(viewLifecycleOwner, myLiveDataObserver)
    }


    override fun onDestroyView() {
        super.onDestroyView()

        myLiveDatas.myLiveData.removeObserver(myLiveDataObserver)

        // I've also try removeObservers with viewLifecycleOwner
    }
}

多谢！

Answer 1

如果需要单个事件，则需要使用自定义实时数据

这是我的一个项目中的自定义可变实时数据，它正在工作

class SingleLiveEvent<T> : MediatorLiveData<T>() {

    private val observers = ArraySet<ObserverWrapper<in T>>()

    @MainThread
    override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
        val wrapper = ObserverWrapper(observer)
        observers.add(wrapper)
        super.observe(owner, wrapper)
    }

    @MainThread
    override fun removeObserver(observer: Observer<in T>) {
        if (observers.remove(observer)) {
            super.removeObserver(observer)
            return
        }
        val iterator = observers.iterator()
        while (iterator.hasNext()) {
            val wrapper = iterator.next()
            if (wrapper.observer == observer) {
                iterator.remove()
                super.removeObserver(wrapper)
                break
            }
        }
    }

    @MainThread
    override fun setValue(t: T?) {
        observers.forEach { it.newValue() }
        super.setValue(t)
    }

    private class ObserverWrapper<T>(val observer: Observer<T>) : Observer<T> {

        private var pending = false

        override fun onChanged(t: T?) {
            if (pending) {
                pending = false
                observer.onChanged(t)
            }
        }

        fun newValue() {
            pending = true
        }
    }
}