Kotlin 集合的可变LiveData_Kotlin_Collections_Mutablelivedata

Kotlin 集合的可变LiveData

kotlin collections

Kotlin 集合的可变LiveData,kotlin,collections,mutablelivedata,Kotlin,Collections,Mutablelivedata,我按束从服务器请求数据并将其存储在数组中。要跟踪下一束数据的获取，我有这个类。在addItems方法中，我通知diffobsers并传递新项目列表： class PackItems:MutableLiveData<ArrayList<GetPacksResponse.PackData>>() { private var diffObservers=ArrayList<Observer<List<GetPacksResponse.PackD

我按束从服务器请求数据并将其存储在数组中。要跟踪下一束数据的获取，我有这个类。在

addItems

方法中，我通知

diffobsers

并传递新项目列表：

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
        }
    }

UPD：如果我能公开完全不可变的

LiveData

，这将是理想的选择。但我不能只是写

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

但是，在这种情况下，我不能设置数据，因为现在MutabyPayTebe是LIFEDATA（不可变的）：（

< P>）我会考虑使用构造函数而不是继承：

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
}

编辑2：

但主要的问题是我需要使用custom

observeItems

方法返回custom

LiveData

类

关键是你不一定要这么做。无论何时调用

LiveData

的方法（例如

observe

），只需调用

items.asLiveData.observe（…）

。如果要将其传递给另一个方法

foo

接受

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
}

class PackItems（）：LiveData（）{
private val mutableData=MutableLiveData（）
...
有趣的观察者（所有者：生命周期所有者、价值观察者：观察者、差异观察者：观察者）{
可变数据。观察（所有者、valueObserver）
添加（diffObserver）
}
覆盖乐趣观察（所有者：LifecycleOwner，观察者：ArrayList）{
可变数据。观察（所有者、观察者）
}
覆盖乐趣移除观察者（所有者：LifecycleOwner）{
mutableData.removeObservators（所有者）//不是超级！
diffObservers=ArrayList（）
}
//等
}

但我认为这不是个好主意

>P>我会考虑使用合成而不是继承：

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
}

编辑2：

但主要的问题是我需要使用custom

observeItems

方法返回custom

LiveData

类

关键是你不一定要这么做。无论何时调用

LiveData

的方法（例如

observe

），只需调用

items.asLiveData.observe（…）

。如果要将其传递给另一个方法

foo

接受

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
}

class PackItems（）：LiveData（）{
private val mutableData=MutableLiveData（）
...
有趣的观察者（所有者：生命周期所有者、价值观察者：观察者、差异观察者：观察者）{
可变数据。观察（所有者、valueObserver）
添加（diffObserver）
}
覆盖乐趣观察（所有者：LifecycleOwner，观察者：ArrayList）{
可变数据。观察（所有者、观察者）
}
覆盖乐趣移除观察者（所有者：LifecycleOwner）{
mutableData.removeObservators（所有者）//不是超级！
diffObservers=ArrayList（）
}
//等
}

但我认为这不是个好主意

组合是一个全新的想法，但主要的问题是我需要使用custom

observeItems

methodAlexey返回custom

LiveData

类。我希望在片段中执行：

model.items.asLiveData.observeItems（…）

。您的方法不允许这样做，因为

LiveData

中没有

observeItems

方法，尤其是对于

observeItems

，您只需执行

model.items.observeItems（…）

，没有

asLiveData

。哦，你指的是

不是一个好主意

部分。好的，我知道了。让我试试看。在这种情况下，我如何更新

可变数据

？如果有公共api来做这件事，那么我最好给出一个片段

mutableData

它本身的组成是一个新的想法，但主要的问题是我需要返回带有自定义

observeItems

方法的自定义

LiveData

类，我想在片段中做：

model.items.asLiveData.observeItems（…）