集合的MutableLiveData

Question

我通过包从服务器请求数据，并将其存储在获取下一批数据的array.To跟踪中-- class.In --通知diffObservers的addItems方法，并传递新项的列表：

class PackItems:MutableLiveData<ArrayList<GetPacksResponse.PackData>>() {
        private var diffObservers=ArrayList<Observer<List<GetPacksResponse.PackData>>>()
        private var active=false

        fun observeItems(owner: LifecycleOwner, valueObserver:Observer<List<GetPacksResponse.PackData>>,diffObserver:Observer<List<GetPacksResponse.PackData>>) {
            super.observe(owner,valueObserver)
            diffObservers.add(diffObserver)
        }

        override fun removeObservers(owner: LifecycleOwner) {
            super.removeObservers(owner)
            diffObservers= ArrayList()
        }

        fun addItems(toAdd:List<GetPacksResponse.PackData>) {
            value?.addAll(toAdd)
            if (active)
                for (observer in diffObservers)
                    observer.onChanged(toAdd)
        }

        override fun onActive() {
            super.onActive()
            active=true
        }

        override fun onInactive() {
            super.onInactive()
            active=false
        }
    }

问题是PackItems是MutableLiveData，向LiveData公开it.Is并不是很好的实践?就像我们通常做的那样：

private val _items = MutableLiveData<List<Int>>()
val items: LiveData<List<Int>> = _items

UPD：理想情况下，如果我能够公开完全不可变的LiveData.But，我就不能仅仅编写

private val _packs:PackItems=PackItems()
val packs:LiveData<ArrayList<GetPacksResponse.PackData>>
get()=_packs

因为在本例中，packs不包含observeItems method.Therefore，所以必须有从LiveData派生的自定义类，例如：

open class PackItems: LiveData<ArrayList<GetPacksResponse.PackData>>() {
    protected var active=false
    protected var diffObservers = ArrayList<Observer<List<GetPacksResponse.PackData>>>()

    fun observeItems(owner: LifecycleOwner, valueObserver: Observer<List<GetPacksResponse.PackData>>, diffObserver: Observer<List<GetPacksResponse.PackData>>) {
        super.observe(owner,valueObserver)
        diffObservers.add(diffObserver)
    }
   //...
}

class MutablePackItems: PackItems() {
    fun addItems(toAdd:List<GetPacksResponse.PackData>) {
        value?.addAll(toAdd)
        if (active)
            for (observer in diffObservers)
                observer.onChanged(toAdd)
    }
}

但在这种情况下，我将无法设置数据，因为现在MutablePackItems是LiveData(不可变) :)

Answer 1

我会考虑使用组合而不是继承：

class PackItems() {
    private val mutableData = MutableLiveData<ArrayList<GetPacksResponse.PackData>>()
    val asLiveData: LiveData<ArrayList<GetPacksResponse.PackData>> get() = mutableData
    ...

    fun observeItems(owner: LifecycleOwner, valueObserver:Observer<List<GetPacksResponse.PackData>>,diffObserver:Observer<List<GetPacksResponse.PackData>>) {
        mutableData.observe(owner,valueObserver)
        diffObservers.add(diffObserver)
    }

    fun removeObservers(owner: LifecycleOwner) {
        mutableData.removeObservers(owner)
        diffObservers = ArrayList()
    }

    // etc
}

编辑:要像在原始代码中一样设置active，可能要麻烦一些：

    private val mutableData = object : MutableLiveData<ArrayList<GetPacksResponse.PackData>>() {
        override fun onActive() {
            super.onActive()
            active = true
        }

        override fun onInactive() {
            super.onInactive()
            active = false
        }
    }

编辑2：

但是主要的问题是我需要用自定义LiveData方法返回自定义observeItems类。

关键是你不一定。每当您调用LiveData的方法(例如observe)时，只需调用items.asLiveData.observe(...)。如果您想将它传递给另一种方法foo accepting LiveData，请调用foo(items.asLiveData)。

原则上，您可以通过扩展LiveData并将所有调用委托给mutableData来修改这种方法。

class PackItems(): LiveData<ArrayList<GetPacksResponse.PackData>>() {
    private val mutableData = MutableLiveData<ArrayList<GetPacksResponse.PackData>>()
    ...

    fun observeItems(owner: LifecycleOwner, valueObserver:Observer<List<GetPacksResponse.PackData>>,diffObserver:Observer<List<GetPacksResponse.PackData>>) {
        mutableData.observe(owner,valueObserver)
        diffObservers.add(diffObserver)
    }

    override fun observe(owner: LifecycleOwner, observer: ArrayList<GetPacksResponse.PackData>) {
        mutableData.observe(owner, observer)
    }

    override fun removeObservers(owner: LifecycleOwner) {
        mutableData.removeObservers(owner) // not super!
        diffObservers = ArrayList()
    }

    // etc
}

但我不认为这是个好主意。