Composer: Edit and reply.

TODO: call renderComposerMode and highlight selected item.

features/messages/src/main/java/io/element/android/x/features/messages/MessagesScreen.kt

@@ -40,6 +40,7 @@ import io.element.android.x.features.messages.model.*
 import io.element.android.x.features.messages.model.content.*
 import io.element.android.x.features.messages.textcomposer.MessageComposerViewModel
 import io.element.android.x.features.messages.textcomposer.MessageComposerViewState
+import io.element.android.x.textcomposer.MessageComposerMode
 import io.element.android.x.textcomposer.TextComposer
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch
@@ -71,6 +72,7 @@ fun MessagesScreen(
     val timelineItems by viewModel.collectAsState(MessagesViewState::timelineItems)
     val hasMoreToLoad by viewModel.collectAsState(MessagesViewState::hasMoreToLoad)
     val snackBarContent by viewModel.collectAsState(MessagesViewState::snackbarContent)
+    val composerMode by viewModel.collectAsState(MessagesViewState::composerMode)
     val composerFullScreen by composerViewModel.collectAsState(MessageComposerViewState::isFullScreen)
     val composerCanSendMessage by composerViewModel.collectAsState(MessageComposerViewState::isSendButtonVisible)
     val composerText by composerViewModel.collectAsState(MessageComposerViewState::text)
@@ -86,6 +88,8 @@ fun MessagesScreen(
         composerFullScreen = composerFullScreen,
         onComposerFullScreenChange = composerViewModel::onComposerFullScreenChange,
         onComposerTextChange = composerViewModel::updateText,
+        composerMode = composerMode,
+        onCloseSpecialMode = viewModel::setNormalMode,
         composerCanSendMessage = composerCanSendMessage,
         composerText = composerText,
         onClick = {
@@ -106,6 +110,16 @@ fun MessagesScreen(
         onActionClicked = {
             viewModel.handleItemAction(it)
             coroutineScope.launch {
+                val targetEvent = viewModel.getTargetEvent()
+                when (it) {
+                    is MessagesItemAction.Edit -> {
+                        // Entering Edit mode, update the text in the composer.
+                        val newComposerText =
+                            (targetEvent?.content as? MessagesTimelineItemTextBasedContent)?.body.orEmpty()
+                        composerViewModel.updateText(newComposerText)
+                    }
+                    else -> Unit
+                }
                 actionsSheetState.hide()
             }
         }
@@ -132,6 +146,8 @@ fun MessagesScreenContent(
     composerFullScreen: Boolean,
     onComposerFullScreenChange: () -> Unit,
     onComposerTextChange: (CharSequence) -> Unit,
+    composerMode: MessageComposerMode,
+    onCloseSpecialMode: () -> Unit,
     composerCanSendMessage: Boolean,
     composerText: StableCharSequence?,
     snackbarHostState: SnackbarHostState,
@@ -154,6 +170,8 @@ fun MessagesScreenContent(
                 onSendMessage = onSendMessage,
                 onClick = onClick,
                 onLongClick = onLongClick,
+                composerMode = composerMode,
+                onCloseSpecialMode = onCloseSpecialMode,
                 composerFullScreen = composerFullScreen,
                 onComposerFullScreenChange = onComposerFullScreenChange,
                 onComposerTextChange = onComposerTextChange,
@@ -173,6 +191,8 @@ fun MessagesContent(
     onSendMessage: (String) -> Unit,
     onClick: (MessagesTimelineItemState.MessageEvent) -> Unit,
     onLongClick: (MessagesTimelineItemState.MessageEvent) -> Unit,
+    composerMode: MessageComposerMode,
+    onCloseSpecialMode: () -> Unit,
     composerFullScreen: Boolean,
     onComposerFullScreenChange: () -> Unit,
     onComposerTextChange: (CharSequence) -> Unit,
@@ -201,6 +221,8 @@ fun MessagesContent(
             onSendMessage = onSendMessage,
             fullscreen = composerFullScreen,
             onFullscreenToggle = onComposerFullScreenChange,
+            composerMode = composerMode,
+            onCloseSpecialMode = onCloseSpecialMode,
             onComposerTextChange = onComposerTextChange,
             composerCanSendMessage = composerCanSendMessage,
             composerText = composerText?.charSequence?.toString(),

features/messages/src/main/java/io/element/android/x/features/messages/MessagesViewModel.kt

@@ -10,11 +10,13 @@ import io.element.android.x.features.messages.model.MessagesItemActionsSheetStat
 import io.element.android.x.features.messages.model.MessagesTimelineItemState
 import io.element.android.x.features.messages.model.MessagesViewState
 import io.element.android.x.features.messages.model.content.MessagesTimelineItemRedactedContent
+import io.element.android.x.features.messages.model.content.MessagesTimelineItemTextBasedContent
 import io.element.android.x.matrix.MatrixClient
 import io.element.android.x.matrix.MatrixInstance
 import io.element.android.x.matrix.media.MediaResolver
 import io.element.android.x.matrix.room.MatrixRoom
 import io.element.android.x.matrix.timeline.MatrixTimeline
+import io.element.android.x.textcomposer.MessageComposerMode
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
@@ -66,25 +68,72 @@ class MessagesViewModel(
     }
 
     fun sendMessage(text: String) {
-        viewModelScope.launch {
-            timeline.sendMessage(text)
+        withState { state ->
+            viewModelScope.launch {
+                when (state.composerMode) {
+                    is MessageComposerMode.Normal -> timeline.sendMessage(text)
+                    is MessageComposerMode.Edit -> timeline.editMessage(
+                        state.composerMode.eventId,
+                        text
+                    )
+                    is MessageComposerMode.Quote -> TODO()
+                    is MessageComposerMode.Reply -> timeline.replyMessage(
+                        state.composerMode.eventId,
+                        text
+                    )
+                }
+                // Reset composer
+                setNormalMode()
+            }
         }
     }
 
+    suspend fun getTargetEvent(): MessagesTimelineItemState.MessageEvent? {
+        val currentState = awaitState()
+        return currentState.itemActionsSheetState.invoke()?.targetItem
+    }
+
     fun handleItemAction(action: MessagesItemAction) {
         viewModelScope.launch(Dispatchers.Default) {
             val currentState = awaitState()
             Timber.v("Handle $action for ${currentState.itemActionsSheetState}")
-            val targetEvent =
-                currentState.itemActionsSheetState.invoke()?.targetItem ?: return@launch
+            val targetEvent = getTargetEvent()
+                ?: return@launch
             when (action) {
                 MessagesItemAction.Copy -> notImplementedYet()
                 MessagesItemAction.Forward -> notImplementedYet()
                 MessagesItemAction.Redact -> handleActionRedact(targetEvent)
+                MessagesItemAction.Edit -> handleActionEdit(targetEvent)
+                MessagesItemAction.Reply -> handleActionReply(targetEvent)
             }
         }
     }
 
+    fun setNormalMode() {
+        setComposerMode(MessageComposerMode.Normal(""))
+    }
+
+    private fun handleActionEdit(targetEvent: MessagesTimelineItemState.MessageEvent) {
+        setComposerMode(
+            MessageComposerMode.Edit(
+                targetEvent.id,
+                (targetEvent.content as? MessagesTimelineItemTextBasedContent)?.body.orEmpty()
+            )
+        )
+    }
+
+    private fun handleActionReply(targetEvent: MessagesTimelineItemState.MessageEvent) {
+        setComposerMode(MessageComposerMode.Reply(targetEvent.safeSenderName, targetEvent.id, ""))
+    }
+
+    private fun setComposerMode(mode: MessageComposerMode) {
+        setState {
+            copy(
+                composerMode = mode
+            )
+        }
+    }
+
     private fun notImplementedYet() {
         setSnackbarContent("Not implemented yet!")
     }
@@ -110,10 +159,12 @@ class MessagesViewModel(
                     emptyList()
                 } else {
                     mutableListOf(
+                        MessagesItemAction.Reply,
                         MessagesItemAction.Forward,
                         MessagesItemAction.Copy,
                     ).also {
                         if (messagesTimelineItemState.isMine) {
+                            it.add(MessagesItemAction.Edit)
                             it.add(MessagesItemAction.Redact)
                         }
                     }

features/messages/src/main/java/io/element/android/x/features/messages/model/MessagesItemAction.kt

@@ -13,4 +13,6 @@ sealed class MessagesItemAction(
     object Forward : MessagesItemAction("Forward", VectorIcons.ArrowForward)
     object Copy : MessagesItemAction("Copy", VectorIcons.Copy)
     object Redact : MessagesItemAction("Redact", VectorIcons.Delete, destructive = true)
+    object Reply : MessagesItemAction("Reply", VectorIcons.Reply)
+    object Edit : MessagesItemAction("Edit", VectorIcons.Edit)
 }

features/messages/src/main/java/io/element/android/x/features/messages/model/MessagesViewState.kt

@@ -4,6 +4,7 @@ import com.airbnb.mvrx.Async
 import com.airbnb.mvrx.MavericksState
 import com.airbnb.mvrx.Uninitialized
 import io.element.android.x.designsystem.components.avatar.AvatarData
+import io.element.android.x.textcomposer.MessageComposerMode
 
 data class MessagesViewState(
     val roomId: String,
@@ -13,6 +14,8 @@ data class MessagesViewState(
     val hasMoreToLoad: Boolean = true,
     val itemActionsSheetState: Async<MessagesItemActionsSheetState> = Uninitialized,
     val snackbarContent: String? = null,
+    // TODO Highlight item in reply / edit in the timeline
+    val composerMode: MessageComposerMode = MessageComposerMode.Normal(""),
 ) : MavericksState {
 
     @Suppress("unused")