Jetpack Compose MVI聊天应用：发送消息后如何同步所有用户状态？

• 现象：发送消息后仅发送者界面状态更新，其他用户需操作键盘或重启聊天才能看到新消息；但打开聊天时通过LaunchedEffect(Unit)触发getMessages()，所有用户都能正常加载并刷新消息。
• 核心代码：ViewModel中的sendMessage()和getMessages()函数如下：

@RequiresApi(Build.VERSION_CODES.O)
@SuppressLint("SimpleDateFormat")
private fun sendMessage(text: String) {
    val calendar: Calendar = Calendar.getInstance()
    val currentDate = LocalDate.now()

    val time = SimpleDateFormat("HH:mm")
    val currentMonthName = currentDate.month.getDisplayName(
        TextStyle.FULL, Locale.getDefault()
    )

    val message = MessageModel(
        name = Firebase.auth.currentUser?.displayName.toString(),
        text = text,
        time = time.format(calendar.time),
        isMine = false,
        sender = Firebase.auth.currentUser?.uid.toString(),
        date = currentDate.dayOfMonth.toString() + " " + currentMonthName,
        isNewDate = false
    )

    viewModelScope.launch {
        repository.addMessage(message)

        _uiState.value.counter += 1
    }
}

private fun getMessages() {
    _uiState.update { currentState ->
        currentState.copy(
            isLoading = true
        )
    }

    viewModelScope.launch {
        var i = 0
        repository.getMessages()
            .map { messages ->
                _messagesItemsSenders.add(messages.get(0).sender)
                _messagesDates.add(messages.get(0).date)
                _messagesPaddingMineAfterLastOther.add(messages.get(0).isMine)

                // Check for new sender
                if ((_messagesItemsSenders.size > 1) && (!messages.get(0).isMine) and
                        (_messagesItemsSenders[i] == _messagesItemsSenders[i-1])) {
                    messages.get(0).isMoreOne = true
                }

                // Check for new date
                messages.get(0).isNewDate =
                    !((_messagesDates.size > 1) && (_messagesDates[i] == _messagesDates[i-1]))

                // Set padding for first message that called "isMine"
                messages.get(0).isPaddingMine = (_messagesPaddingMineAfterLastOther.size > 1) &&
                        (messages.get(0).isMine) and
                        (_messagesPaddingMineAfterLastOther[i]
                                != _messagesPaddingMineAfterLastOther[i-1])

                i += 1
                ChatViewState(messages = messages, isLoading = false)
            }
            .collect() { newState ->
                _uiState.value = newState
            }
    }
}

核心原因 #

1. getMessages()流监听不持久：如果repository.getMessages()仅返回单次数据快照，而非实时监听数据源变化的流，那么只有打开聊天时会加载一次，后续新消息无法触发流更新。
2. ViewModel状态处理逻辑混乱：直接修改ViewModel内的可变集合（_messagesItemsSenders等），这些集合不属于状态的一部分，无法触发UI重组；且依赖历史集合状态处理消息UI属性，会导致数据逻辑出错。
3. 发送消息的状态标记错误：sendMessage()中设置isMine = false，会导致发送者自身消息被识别为他人消息，后续UI渲染异常。

具体修复步骤 #

1. 让Repository返回实时监听的Flow #

以Firebase Firestore为例，将getMessages()改为实时监听流，确保数据源变化时能主动推送更新：

// Repository层示例代码
fun getMessages(): Flow<List<MessageModel>> = callbackFlow {
    val listener = firestore.collection("messages")
        .addSnapshotListener { snapshot, error ->
            if (error != null) {
                close(error)
                return@addSnapshotListener
            }
            val messages = snapshot?.documents?.mapNotNull { doc ->
                doc.toObject(MessageModel::class.java)
            } ?: emptyList()
            trySend(messages)
        }
    awaitClose { listener.remove() }
}.flowOn(Dispatchers.IO)

2. 重构ViewModel的消息状态处理逻辑 #

移除ViewModel内的可变集合，基于完整消息列表实时计算UI属性，避免依赖历史状态：

private fun getMessages() {
    viewModelScope.launch {
        repository.getMessages()
            // 按时间排序，建议给MessageModel添加timestamp字段
            .map { messages -> messages.sortedBy { it.timestamp } }
            .map { sortedMessages ->
                sortedMessages.mapIndexed { index, message ->
                    val prevMessage = if (index > 0) sortedMessages[index-1] else null
                    val isSameSender = prevMessage?.sender == message.sender
                    val isSameDate = prevMessage?.date == message.date
                    val isFirstMineAfterOther = prevMessage?.isMine != true && message.isMine

                    message.copy(
                        isMoreOne = !message.isMine && isSameSender,
                        isNewDate = !isSameDate,
                        isPaddingMine = isFirstMineAfterOther,
                        // 统一在这判断是否为当前用户消息，避免发送时设置错误
                        isMine = message.sender == Firebase.auth.currentUser?.uid
                    )
                }
            }
            .onStart {
                _uiState.value = _uiState.value.copy(isLoading = true)
            }
            .map { processedMessages ->
                ChatViewState(messages = processedMessages, isLoading = false)
            }
            .collect { newState ->
                _uiState.value = newState
            }
    }
}

3. 修正发送消息的isMine标记 #

// sendMessage中的MessageModel创建部分
val message = MessageModel(
    // ...其他字段
    isMine = true, // 或者后续在getMessages中统一判断，更可靠
    // ...
)

4. 确保所有用户都启动实时监听 #

在聊天界面Composable中，通过LaunchedEffect启动监听：

@Composable
fun ChatScreen(viewModel: ChatViewModel) {
    val uiState by viewModel.uiState.collectAsState()

    LaunchedEffect(Unit) {
        viewModel.getMessages()
    }

    // 渲染聊天列表、输入框等UI...
}

内容的提问来源于stack exchange，提问作者www sss