将项目添加到LiveData列表时通知观察者

Question

将项目添加到LiveData列表时,我需要获取Observer事件.但正如我所理解的那样,只有当我用新的列表替换旧列表时才会收到事件.例如,当我做下一个时:

list.value = mutableListOf(IssuePost(UserEntity(name, email, photoUrl), issueEntity))

观察者得到事件.但是当我只是将item添加到value时,Observer是静默的.您能否就我如何实施我的需求提出建议？

Answer 1

在内部,LiveData将每个更改跟踪为版本号(简单计数器存储为int).调用setValue()会增加此版本并使用新数据更新任何观察者(仅当观察者的版本号小于LiveData的版本时).

看来启动此过程的唯一方法是调用setValue()或postValue().副作用是如果LiveData的底层数据结构发生了变化(例如向Collection中添加元素),则不会发生任何事情将其传达给观察者.

因此,在将项添加到列表后,您必须调用setValue().我提供了两种方法可以在下面解决这个问题.我更喜欢第一种选择.

选项1

将列表保留在LiveData之外,并在列表内容更改时随参考更新.

private val mIssuePosts = ArrayList<IssuePost>()
private val mIssuePostLiveData = MutableLiveData<List<IssuePost>>()

fun addIssuePost(issuePost: IssuePost) {
   mIssuePosts.add(issuePost)
   mIssuePostLiveData.value = mIssuePosts
}

选项2

通过LiveData跟踪列表,并在列表内容更改时使用自己的值更新LiveData.

private val mIssuePostLiveData = MutableLiveData<List<IssuePost>>()

init {
   mIssuePostLiveData.value = ArrayList()
}

fun addIssuePost(issuePost: IssuePost) {
    mIssuePostLiveData.value?.add(issuePost)
    mIssuePostLiveData.value = mIssuePostLiveData.value
}

这些解决方案中的任何一个都应该帮助您每次修改当前列表时都必须创建一个新列表,以通知观察者.

Answer 2

我使用Kotlin Extension Function使其变得更容易：

fun <T> MutableLiveData<T>.notifyObserver() {
    this.value = this.value
}

然后以任何MutableLiveData类似的方式使用它：

fun addIssuePost(issuePost: IssuePost) {
    mIssuePostLiveData.value?.add(issuePost)
    mIssuePostLiveData.notifyObserver()
}

Answer 3

迟到了，但这里有一个更简洁的 Gnzlt 答案版本，带有空检查以及可变和不可变列表：

// for mutable list
operator fun <T> MutableLiveData<MutableList<T>>.plusAssign(item: T) {
    val value = this.value ?: mutableListOf()
    value.add(item)
    this.value = value
}

// for immutable list
operator fun <T> MutableLiveData<List<T>>.plusAssign(item: T) {
    val value = this.value ?: emptyList()
    this.value = value + listOf(item)
}

在你的代码中：

list += IssuePost(UserEntity(name, email, photoUrl), issueEntity))

Answer 4

LiveData只会在其包装的对象引用更改时发出通知。当你分配一个新List的LiveData，然后它会通知，因为它包装的对象引用更改，但如果从添加/删除项目LiveData的List也不会通知，因为它仍然具有相同的List引用作为包装对象。所以你可以通过MutableLiveData如下扩展来克服这个问题：

fun <T> MutableLiveData<MutableList<T>>.addNewItem(item: T) {
    val oldValue = this.value ?: mutableListOf()
    oldValue.add(item)
    this.value = oldValue
}

fun <T> MutableLiveData<MutableList<T>>.addNewItemAt(index: Int, item: T) {
    val oldValue = this.value ?: mutableListOf()
    oldValue.add(index, item)
    this.value = oldValue
}

fun <T> MutableLiveData<MutableList<T>>.removeItemAt(index: Int) {
    if (!this.value.isNullOrEmpty()) {
        val oldValue = this.value
        oldValue?.removeAt(index)
        this.value = oldValue
    } else {
        this.value = mutableListOf()
    }
}

然后添加/删除您MutableLiveData喜欢的项目：

// Here is your IssuePost list
var issuePostList = MutableLiveData<MutableList<IssuePost>>()

// Add new item to your list
issuePostList.addNewItem(IssuePost(UserEntity(name, email, photoUrl), issueEntity))

// Delete an item from your list at position i
issuePostList.removeItemAt(i)

// Add new item to your list at position i
issuePostList.addNewItemAt(i, IssuePost(UserEntity(name, email, photoUrl), issueEntity))

Answer 5

我找到了一个更好的 Kotlin 解决方案：

class MutableListLiveData<T>(
        private val list: MutableList<T> = mutableListOf()
) : MutableList<T> by list, LiveData<List<T>>() {

    override fun add(element: T): Boolean =
            element.actionAndUpdate { list.add(it) }

    override fun add(index: Int, element: T) =
            list.add(index, element).also { updateValue() }

    override fun addAll(elements: Collection<T>): Boolean =
            elements.actionAndUpdate { list.addAll(elements) }

    override fun addAll(index: Int, elements: Collection<T>): Boolean =
            elements.actionAndUpdate { list.addAll(index, it) }

    override fun remove(element: T): Boolean =
            element.actionAndUpdate { list.remove(it) }

    override fun removeAt(index: Int): T =
            list.removeAt(index).also { updateValue() }

    override fun removeAll(elements: Collection<T>): Boolean =
            elements.actionAndUpdate { list.removeAll(it) }

    override fun retainAll(elements: Collection<T>): Boolean =
            elements.actionAndUpdate { list.retainAll(it) }

    override fun clear() =
            list.clear().also { updateValue() }

    override fun set(index: Int, element: T): T =
            list.set(index, element).also { updateValue() }

    private fun <T> T.actionAndUpdate(action: (item: T) -> Boolean): Boolean =
            action(this).applyIfTrue { updateValue() }

    private fun Boolean.applyIfTrue(action: () -> Unit): Boolean {
        takeIf { it }?.run { action() }
        return this
    }

    private fun updateValue() {
        value = list
    }
}

这种实现的优点是您可以在MutableListLiveData. 然后你可以像这样使用它，你的LiveData会自动更新：

private val _items = MutableListLiveData<Item>()
val items: LiveData<List<Item>> = _items

fun addItem(item: Item) {
   _items.add(item)
}