Sulkta-OSS/element-x-ada
3
0
Fork 0
Code Issues 1 Pull requests 7 Projects Releases Packages Wiki Activity Actions

Rename MessageComposerEvents to MessageComposerEvent

Browse source
This commit is contained in:
Benoit Marty 2025-11-10 16:29:30 +01:00
parent 8603d54778
commit 24c213901e
12 changed files with 153 additions and 153 deletions
Download patch file Download diff file Expand all files Collapse all files

4
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesNode.kt
View file

@ -33,7 +33,7 @@ import io.element.android.features.knockrequests.api.banner.KnockRequestsBannerR
import io.element.android.features.messages.impl.actionlist.ActionListPresenter import io.element.android.features.messages.impl.actionlist.ActionListPresenter
import io.element.android.features.messages.impl.actionlist.model.TimelineItemActionPostProcessor import io.element.android.features.messages.impl.actionlist.model.TimelineItemActionPostProcessor
import io.element.android.features.messages.impl.attachments.Attachment import io.element.android.features.messages.impl.attachments.Attachment
import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvents import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvent
import io.element.android.features.messages.impl.messagecomposer.MessageComposerPresenter import io.element.android.features.messages.impl.messagecomposer.MessageComposerPresenter
import io.element.android.features.messages.impl.timeline.TimelineController import io.element.android.features.messages.impl.timeline.TimelineController
import io.element.android.features.messages.impl.timeline.TimelineEvents import io.element.android.features.messages.impl.timeline.TimelineEvents
@ -242,7 +242,7 @@ class MessagesNode(
OnLifecycleEvent { _, event -> OnLifecycleEvent { _, event ->
when (event) { when (event) {
Lifecycle.Event.ON_PAUSE -> state.composerState.eventSink(MessageComposerEvents.SaveDraft) Lifecycle.Event.ON_PAUSE -> state.composerState.eventSink(MessageComposerEvent.SaveDraft)
else -> Unit else -> Unit
} }
} }

10
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesPresenter.kt
View file

@ -34,7 +34,7 @@ import io.element.android.features.messages.impl.actionlist.ActionListState
import io.element.android.features.messages.impl.actionlist.model.TimelineItemAction import io.element.android.features.messages.impl.actionlist.model.TimelineItemAction
import io.element.android.features.messages.impl.crypto.identity.IdentityChangeState import io.element.android.features.messages.impl.crypto.identity.IdentityChangeState
import io.element.android.features.messages.impl.link.LinkState import io.element.android.features.messages.impl.link.LinkState
import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvents import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvent
import io.element.android.features.messages.impl.messagecomposer.MessageComposerState import io.element.android.features.messages.impl.messagecomposer.MessageComposerState
import io.element.android.features.messages.impl.pinned.banner.PinnedMessagesBannerState import io.element.android.features.messages.impl.pinned.banner.PinnedMessagesBannerState
import io.element.android.features.messages.impl.timeline.MarkAsFullyRead import io.element.android.features.messages.impl.timeline.MarkAsFullyRead
@ -479,7 +479,7 @@ class MessagesPresenter(
}.orEmpty(), }.orEmpty(),
) )
composerState.eventSink( composerState.eventSink(
MessageComposerEvents.SetMode(composerMode) MessageComposerEvent.SetMode(composerMode)
) )
} }
} }
@ -494,7 +494,7 @@ class MessagesPresenter(
content = "", content = "",
) )
composerState.eventSink( composerState.eventSink(
MessageComposerEvents.SetMode(composerMode) MessageComposerEvent.SetMode(composerMode)
) )
} }
@ -507,7 +507,7 @@ class MessagesPresenter(
content = (targetEvent.content as? TimelineItemEventContentWithAttachment)?.caption.orEmpty(), content = (targetEvent.content as? TimelineItemEventContentWithAttachment)?.caption.orEmpty(),
) )
composerState.eventSink( composerState.eventSink(
MessageComposerEvents.SetMode(composerMode) MessageComposerEvent.SetMode(composerMode)
) )
} }
@ -524,7 +524,7 @@ class MessagesPresenter(
hideImage = timelineProtectionState.hideMediaContent(targetEvent.eventId), hideImage = timelineProtectionState.hideMediaContent(targetEvent.eventId),
) )
composerState.eventSink( composerState.eventSink(
MessageComposerEvents.SetMode(composerMode) MessageComposerEvent.SetMode(composerMode)
) )
} }
} }

4
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesView.kt
View file

@ -52,7 +52,7 @@ import io.element.android.features.messages.impl.link.LinkEvents
import io.element.android.features.messages.impl.link.LinkView import io.element.android.features.messages.impl.link.LinkView
import io.element.android.features.messages.impl.messagecomposer.AttachmentsBottomSheet import io.element.android.features.messages.impl.messagecomposer.AttachmentsBottomSheet
import io.element.android.features.messages.impl.messagecomposer.DisabledComposerView import io.element.android.features.messages.impl.messagecomposer.DisabledComposerView
import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvents import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvent
import io.element.android.features.messages.impl.messagecomposer.MessageComposerView import io.element.android.features.messages.impl.messagecomposer.MessageComposerView
import io.element.android.features.messages.impl.messagecomposer.suggestions.SuggestionsPickerView import io.element.android.features.messages.impl.messagecomposer.suggestions.SuggestionsPickerView
import io.element.android.features.messages.impl.pinned.banner.PinnedMessagesBannerState import io.element.android.features.messages.impl.pinned.banner.PinnedMessagesBannerState
@ -256,7 +256,7 @@ fun MessagesView(
roomAvatarData = state.roomAvatar, roomAvatarData = state.roomAvatar,
suggestions = state.composerState.suggestions, suggestions = state.composerState.suggestions,
onSelectSuggestion = { onSelectSuggestion = {
state.composerState.eventSink(MessageComposerEvents.InsertSuggestion(it)) state.composerState.eventSink(MessageComposerEvent.InsertSuggestion(it))
} }
) )
} }

16
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/AttachmentsBottomSheet.kt
View file

@ -64,7 +64,7 @@ internal fun AttachmentsBottomSheet(
// Send 'DismissAttachmentMenu' event when the bottomsheet was just hidden // Send 'DismissAttachmentMenu' event when the bottomsheet was just hidden
LaunchedEffect(isVisible) { LaunchedEffect(isVisible) {
if (!isVisible) { if (!isVisible) {
state.eventSink(MessageComposerEvents.DismissAttachmentMenu) state.eventSink(MessageComposerEvent.DismissAttachmentMenu)
} }
} }
@ -99,25 +99,25 @@ private fun AttachmentSourcePickerMenu(
.imePadding() .imePadding()
) { ) {
ListItem( ListItem(
modifier = Modifier.clickable { state.eventSink(MessageComposerEvents.PickAttachmentSource.PhotoFromCamera) }, modifier = Modifier.clickable { state.eventSink(MessageComposerEvent.PickAttachmentSource.PhotoFromCamera) },
leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.TakePhoto())), leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.TakePhoto())),
headlineContent = { Text(stringResource(R.string.screen_room_attachment_source_camera_photo)) }, headlineContent = { Text(stringResource(R.string.screen_room_attachment_source_camera_photo)) },
style = ListItemStyle.Primary, style = ListItemStyle.Primary,
) )
ListItem( ListItem(
modifier = Modifier.clickable { state.eventSink(MessageComposerEvents.PickAttachmentSource.VideoFromCamera) }, modifier = Modifier.clickable { state.eventSink(MessageComposerEvent.PickAttachmentSource.VideoFromCamera) },
leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.VideoCall())), leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.VideoCall())),
headlineContent = { Text(stringResource(R.string.screen_room_attachment_source_camera_video)) }, headlineContent = { Text(stringResource(R.string.screen_room_attachment_source_camera_video)) },
style = ListItemStyle.Primary, style = ListItemStyle.Primary,
) )
ListItem( ListItem(
modifier = Modifier.clickable { state.eventSink(MessageComposerEvents.PickAttachmentSource.FromGallery) }, modifier = Modifier.clickable { state.eventSink(MessageComposerEvent.PickAttachmentSource.FromGallery) },
leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.Image())), leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.Image())),
headlineContent = { Text(stringResource(R.string.screen_room_attachment_source_gallery)) }, headlineContent = { Text(stringResource(R.string.screen_room_attachment_source_gallery)) },
style = ListItemStyle.Primary, style = ListItemStyle.Primary,
) )
ListItem( ListItem(
modifier = Modifier.clickable { state.eventSink(MessageComposerEvents.PickAttachmentSource.FromFiles) }, modifier = Modifier.clickable { state.eventSink(MessageComposerEvent.PickAttachmentSource.FromFiles) },
leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.Attachment())), leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.Attachment())),
headlineContent = { Text(stringResource(R.string.screen_room_attachment_source_files)) }, headlineContent = { Text(stringResource(R.string.screen_room_attachment_source_files)) },
style = ListItemStyle.Primary, style = ListItemStyle.Primary,
@ -125,7 +125,7 @@ private fun AttachmentSourcePickerMenu(
if (state.canShareLocation) { if (state.canShareLocation) {
ListItem( ListItem(
modifier = Modifier.clickable { modifier = Modifier.clickable {
state.eventSink(MessageComposerEvents.PickAttachmentSource.Location) state.eventSink(MessageComposerEvent.PickAttachmentSource.Location)
onSendLocationClick() onSendLocationClick()
}, },
leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.LocationPin())), leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.LocationPin())),
@ -135,7 +135,7 @@ private fun AttachmentSourcePickerMenu(
} }
ListItem( ListItem(
modifier = Modifier.clickable { modifier = Modifier.clickable {
state.eventSink(MessageComposerEvents.PickAttachmentSource.Poll) state.eventSink(MessageComposerEvent.PickAttachmentSource.Poll)
onCreatePollClick() onCreatePollClick()
}, },
leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.Polls())), leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.Polls())),
@ -144,7 +144,7 @@ private fun AttachmentSourcePickerMenu(
) )
if (enableTextFormatting) { if (enableTextFormatting) {
ListItem( ListItem(
modifier = Modifier.clickable { state.eventSink(MessageComposerEvents.ToggleTextFormatting(enabled = true)) }, modifier = Modifier.clickable { state.eventSink(MessageComposerEvent.ToggleTextFormatting(enabled = true)) },
leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.TextFormatting())), leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.TextFormatting())),
headlineContent = { Text(stringResource(R.string.screen_room_attachment_text_formatting)) }, headlineContent = { Text(stringResource(R.string.screen_room_attachment_text_formatting)) },
style = ListItemStyle.Primary, style = ListItemStyle.Primary,

30
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerEvents.kt → features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerEvent.kt
View file

@ -13,15 +13,15 @@ import io.element.android.libraries.textcomposer.mentions.ResolvedSuggestion
import io.element.android.libraries.textcomposer.model.MessageComposerMode import io.element.android.libraries.textcomposer.model.MessageComposerMode
import io.element.android.libraries.textcomposer.model.Suggestion import io.element.android.libraries.textcomposer.model.Suggestion
sealed interface MessageComposerEvents { sealed interface MessageComposerEvent {
data object ToggleFullScreenState : MessageComposerEvents data object ToggleFullScreenState : MessageComposerEvent
data object SendMessage : MessageComposerEvents data object SendMessage : MessageComposerEvent
data class SendUri(val uri: Uri) : MessageComposerEvents data class SendUri(val uri: Uri) : MessageComposerEvent
data object CloseSpecialMode : MessageComposerEvents data object CloseSpecialMode : MessageComposerEvent
data class SetMode(val composerMode: MessageComposerMode) : MessageComposerEvents data class SetMode(val composerMode: MessageComposerMode) : MessageComposerEvent
data object AddAttachment : MessageComposerEvents data object AddAttachment : MessageComposerEvent
data object DismissAttachmentMenu : MessageComposerEvents data object DismissAttachmentMenu : MessageComposerEvent
sealed interface PickAttachmentSource : MessageComposerEvents { sealed interface PickAttachmentSource : MessageComposerEvent {
data object FromGallery : PickAttachmentSource data object FromGallery : PickAttachmentSource
data object FromFiles : PickAttachmentSource data object FromFiles : PickAttachmentSource
data object PhotoFromCamera : PickAttachmentSource data object PhotoFromCamera : PickAttachmentSource
@ -30,10 +30,10 @@ sealed interface MessageComposerEvents {
data object Poll : PickAttachmentSource data object Poll : PickAttachmentSource
} }
data class ToggleTextFormatting(val enabled: Boolean) : MessageComposerEvents data class ToggleTextFormatting(val enabled: Boolean) : MessageComposerEvent
data class Error(val error: Throwable) : MessageComposerEvents data class Error(val error: Throwable) : MessageComposerEvent
data class TypingNotice(val isTyping: Boolean) : MessageComposerEvents data class TypingNotice(val isTyping: Boolean) : MessageComposerEvent
data class SuggestionReceived(val suggestion: Suggestion?) : MessageComposerEvents data class SuggestionReceived(val suggestion: Suggestion?) : MessageComposerEvent
data class InsertSuggestion(val resolvedSuggestion: ResolvedSuggestion) : MessageComposerEvents data class InsertSuggestion(val resolvedSuggestion: ResolvedSuggestion) : MessageComposerEvent
data object SaveDraft : MessageComposerEvents data object SaveDraft : MessageComposerEvent
} }

46
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerPresenter.kt
View file

@ -132,7 +132,7 @@ class MessageComposerPresenter(
private val mediaSender = mediaSenderFactory.create(timelineMode = timelineController.mainTimelineMode()) private val mediaSender = mediaSenderFactory.create(timelineMode = timelineController.mainTimelineMode())
private val cameraPermissionPresenter = permissionsPresenterFactory.create(Manifest.permission.CAMERA) private val cameraPermissionPresenter = permissionsPresenterFactory.create(Manifest.permission.CAMERA)
private var pendingEvent: MessageComposerEvents? = null private var pendingEvent: MessageComposerEvent? = null
private val suggestionSearchTrigger = MutableStateFlow<Suggestion?>(null) private val suggestionSearchTrigger = MutableStateFlow<Suggestion?>(null)
// Used to disable some UI related elements in tests // Used to disable some UI related elements in tests
@ -186,8 +186,8 @@ class MessageComposerPresenter(
LaunchedEffect(cameraPermissionState.permissionGranted) { LaunchedEffect(cameraPermissionState.permissionGranted) {
if (cameraPermissionState.permissionGranted) { if (cameraPermissionState.permissionGranted) {
when (pendingEvent) { when (pendingEvent) {
is MessageComposerEvents.PickAttachmentSource.PhotoFromCamera -> cameraPhotoPicker.launch() is MessageComposerEvent.PickAttachmentSource.PhotoFromCamera -> cameraPhotoPicker.launch()
is MessageComposerEvents.PickAttachmentSource.VideoFromCamera -> cameraVideoPicker.launch() is MessageComposerEvent.PickAttachmentSource.VideoFromCamera -> cameraVideoPicker.launch()
else -> Unit else -> Unit
} }
pendingEvent = null pendingEvent = null
@ -228,10 +228,10 @@ class MessageComposerPresenter(
} }
} }
fun handleEvent(event: MessageComposerEvents) { fun handleEvent(event: MessageComposerEvent) {
when (event) { when (event) {
MessageComposerEvents.ToggleFullScreenState -> isFullScreen.value = !isFullScreen.value MessageComposerEvent.ToggleFullScreenState -> isFullScreen.value = !isFullScreen.value
MessageComposerEvents.CloseSpecialMode -> { MessageComposerEvent.CloseSpecialMode -> {
if (messageComposerContext.composerMode.isEditing) { if (messageComposerContext.composerMode.isEditing) {
localCoroutineScope.launch { localCoroutineScope.launch {
resetComposer(markdownTextEditorState, richTextEditorState, fromEdit = true) resetComposer(markdownTextEditorState, richTextEditorState, fromEdit = true)
@ -240,13 +240,13 @@ class MessageComposerPresenter(
messageComposerContext.composerMode = MessageComposerMode.Normal messageComposerContext.composerMode = MessageComposerMode.Normal
} }
} }
is MessageComposerEvents.SendMessage -> { is MessageComposerEvent.SendMessage -> {
sessionCoroutineScope.sendMessage( sessionCoroutineScope.sendMessage(
markdownTextEditorState = markdownTextEditorState, markdownTextEditorState = markdownTextEditorState,
richTextEditorState = richTextEditorState, richTextEditorState = richTextEditorState,
) )
} }
is MessageComposerEvents.SendUri -> { is MessageComposerEvent.SendUri -> {
val inReplyToEventId = (messageComposerContext.composerMode as? MessageComposerMode.Reply)?.eventId val inReplyToEventId = (messageComposerContext.composerMode as? MessageComposerMode.Reply)?.eventId
sessionCoroutineScope.sendAttachment( sessionCoroutineScope.sendAttachment(
attachment = Attachment.Media( attachment = Attachment.Media(
@ -263,22 +263,22 @@ class MessageComposerPresenter(
// Reset composer since the attachment has been sent // Reset composer since the attachment has been sent
messageComposerContext.composerMode = MessageComposerMode.Normal messageComposerContext.composerMode = MessageComposerMode.Normal
} }
is MessageComposerEvents.SetMode -> { is MessageComposerEvent.SetMode -> {
localCoroutineScope.setMode(event.composerMode, markdownTextEditorState, richTextEditorState) localCoroutineScope.setMode(event.composerMode, markdownTextEditorState, richTextEditorState)
} }
MessageComposerEvents.AddAttachment -> localCoroutineScope.launch { MessageComposerEvent.AddAttachment -> localCoroutineScope.launch {
showAttachmentSourcePicker = true showAttachmentSourcePicker = true
} }
MessageComposerEvents.DismissAttachmentMenu -> showAttachmentSourcePicker = false MessageComposerEvent.DismissAttachmentMenu -> showAttachmentSourcePicker = false
MessageComposerEvents.PickAttachmentSource.FromGallery -> localCoroutineScope.launch { MessageComposerEvent.PickAttachmentSource.FromGallery -> localCoroutineScope.launch {
showAttachmentSourcePicker = false showAttachmentSourcePicker = false
galleryMediaPicker.launch() galleryMediaPicker.launch()
} }
MessageComposerEvents.PickAttachmentSource.FromFiles -> localCoroutineScope.launch { MessageComposerEvent.PickAttachmentSource.FromFiles -> localCoroutineScope.launch {
showAttachmentSourcePicker = false showAttachmentSourcePicker = false
filesPicker.launch() filesPicker.launch()
} }
MessageComposerEvents.PickAttachmentSource.PhotoFromCamera -> localCoroutineScope.launch { MessageComposerEvent.PickAttachmentSource.PhotoFromCamera -> localCoroutineScope.launch {
showAttachmentSourcePicker = false showAttachmentSourcePicker = false
if (cameraPermissionState.permissionGranted) { if (cameraPermissionState.permissionGranted) {
cameraPhotoPicker.launch() cameraPhotoPicker.launch()
@ -287,7 +287,7 @@ class MessageComposerPresenter(
cameraPermissionState.eventSink(PermissionsEvents.RequestPermissions) cameraPermissionState.eventSink(PermissionsEvents.RequestPermissions)
} }
} }
MessageComposerEvents.PickAttachmentSource.VideoFromCamera -> localCoroutineScope.launch { MessageComposerEvent.PickAttachmentSource.VideoFromCamera -> localCoroutineScope.launch {
showAttachmentSourcePicker = false showAttachmentSourcePicker = false
if (cameraPermissionState.permissionGranted) { if (cameraPermissionState.permissionGranted) {
cameraVideoPicker.launch() cameraVideoPicker.launch()
@ -296,32 +296,32 @@ class MessageComposerPresenter(
cameraPermissionState.eventSink(PermissionsEvents.RequestPermissions) cameraPermissionState.eventSink(PermissionsEvents.RequestPermissions)
} }
} }
MessageComposerEvents.PickAttachmentSource.Location -> { MessageComposerEvent.PickAttachmentSource.Location -> {
showAttachmentSourcePicker = false showAttachmentSourcePicker = false
// Navigation to the location picker screen is done at the view layer // Navigation to the location picker screen is done at the view layer
} }
MessageComposerEvents.PickAttachmentSource.Poll -> { MessageComposerEvent.PickAttachmentSource.Poll -> {
showAttachmentSourcePicker = false showAttachmentSourcePicker = false
// Navigation to the create poll screen is done at the view layer // Navigation to the create poll screen is done at the view layer
} }
is MessageComposerEvents.ToggleTextFormatting -> { is MessageComposerEvent.ToggleTextFormatting -> {
showAttachmentSourcePicker = false showAttachmentSourcePicker = false
localCoroutineScope.toggleTextFormatting(event.enabled, markdownTextEditorState, richTextEditorState) localCoroutineScope.toggleTextFormatting(event.enabled, markdownTextEditorState, richTextEditorState)
} }
is MessageComposerEvents.Error -> { is MessageComposerEvent.Error -> {
analyticsService.trackError(event.error) analyticsService.trackError(event.error)
} }
is MessageComposerEvents.TypingNotice -> { is MessageComposerEvent.TypingNotice -> {
if (sendTypingNotifications) { if (sendTypingNotifications) {
localCoroutineScope.launch { localCoroutineScope.launch {
room.typingNotice(event.isTyping) room.typingNotice(event.isTyping)
} }
} }
} }
is MessageComposerEvents.SuggestionReceived -> { is MessageComposerEvent.SuggestionReceived -> {
suggestionSearchTrigger.value = event.suggestion suggestionSearchTrigger.value = event.suggestion
} }
is MessageComposerEvents.InsertSuggestion -> { is MessageComposerEvent.InsertSuggestion -> {
localCoroutineScope.launch { localCoroutineScope.launch {
if (showTextFormatting) { if (showTextFormatting) {
when (val suggestion = event.resolvedSuggestion) { when (val suggestion = event.resolvedSuggestion) {
@ -348,7 +348,7 @@ class MessageComposerPresenter(
} }
} }
} }
MessageComposerEvents.SaveDraft -> { MessageComposerEvent.SaveDraft -> {
val draft = createDraftFromState(markdownTextEditorState, richTextEditorState) val draft = createDraftFromState(markdownTextEditorState, richTextEditorState)
sessionCoroutineScope.updateDraft(draft, isVolatile = false) sessionCoroutineScope.updateDraft(draft, isVolatile = false)
} }

2
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerState.kt
View file

@ -26,5 +26,5 @@ data class MessageComposerState(
val suggestions: ImmutableList<ResolvedSuggestion>, val suggestions: ImmutableList<ResolvedSuggestion>,
val resolveMentionDisplay: (String, String) -> TextDisplay, val resolveMentionDisplay: (String, String) -> TextDisplay,
val resolveAtRoomMentionDisplay: () -> TextDisplay, val resolveAtRoomMentionDisplay: () -> TextDisplay,
val eventSink: (MessageComposerEvents) -> Unit, val eventSink: (MessageComposerEvent) -> Unit,
) )

2
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerStateProvider.kt
View file

@ -32,7 +32,7 @@ fun aMessageComposerState(
showAttachmentSourcePicker: Boolean = false, showAttachmentSourcePicker: Boolean = false,
canShareLocation: Boolean = true, canShareLocation: Boolean = true,
suggestions: ImmutableList<ResolvedSuggestion> = persistentListOf(), suggestions: ImmutableList<ResolvedSuggestion> = persistentListOf(),
eventSink: (MessageComposerEvents) -> Unit = {}, eventSink: (MessageComposerEvent) -> Unit = {},
) = MessageComposerState( ) = MessageComposerState(
textEditorState = textEditorState, textEditorState = textEditorState,
isFullScreen = isFullScreen, isFullScreen = isFullScreen,

16
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerView.kt
View file

@ -38,36 +38,36 @@ internal fun MessageComposerView(
) { ) {
val view = LocalView.current val view = LocalView.current
fun sendMessage() { fun sendMessage() {
state.eventSink(MessageComposerEvents.SendMessage) state.eventSink(MessageComposerEvent.SendMessage)
} }
fun sendUri(uri: Uri) { fun sendUri(uri: Uri) {
state.eventSink(MessageComposerEvents.SendUri(uri)) state.eventSink(MessageComposerEvent.SendUri(uri))
} }
fun onAddAttachment() { fun onAddAttachment() {
state.eventSink(MessageComposerEvents.AddAttachment) state.eventSink(MessageComposerEvent.AddAttachment)
} }
fun onCloseSpecialMode() { fun onCloseSpecialMode() {
state.eventSink(MessageComposerEvents.CloseSpecialMode) state.eventSink(MessageComposerEvent.CloseSpecialMode)
} }
fun onDismissTextFormatting() { fun onDismissTextFormatting() {
view.clearFocus() view.clearFocus()
state.eventSink(MessageComposerEvents.ToggleTextFormatting(enabled = false)) state.eventSink(MessageComposerEvent.ToggleTextFormatting(enabled = false))
} }
fun onSuggestionReceived(suggestion: Suggestion?) { fun onSuggestionReceived(suggestion: Suggestion?) {
state.eventSink(MessageComposerEvents.SuggestionReceived(suggestion)) state.eventSink(MessageComposerEvent.SuggestionReceived(suggestion))
} }
fun onError(error: Throwable) { fun onError(error: Throwable) {
state.eventSink(MessageComposerEvents.Error(error)) state.eventSink(MessageComposerEvent.Error(error))
} }
fun onTyping(typing: Boolean) { fun onTyping(typing: Boolean) {
state.eventSink(MessageComposerEvents.TypingNotice(typing)) state.eventSink(MessageComposerEvent.TypingNotice(typing))
} }
val coroutineScope = rememberCoroutineScope() val coroutineScope = rememberCoroutineScope()

4
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/threads/ThreadedMessagesNode.kt
View file

@ -33,7 +33,7 @@ import io.element.android.features.messages.impl.MessagesView
import io.element.android.features.messages.impl.actionlist.ActionListPresenter import io.element.android.features.messages.impl.actionlist.ActionListPresenter
import io.element.android.features.messages.impl.actionlist.model.TimelineItemActionPostProcessor import io.element.android.features.messages.impl.actionlist.model.TimelineItemActionPostProcessor
import io.element.android.features.messages.impl.attachments.Attachment import io.element.android.features.messages.impl.attachments.Attachment
import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvents import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvent
import io.element.android.features.messages.impl.messagecomposer.MessageComposerPresenter import io.element.android.features.messages.impl.messagecomposer.MessageComposerPresenter
import io.element.android.features.messages.impl.timeline.TimelineController import io.element.android.features.messages.impl.timeline.TimelineController
import io.element.android.features.messages.impl.timeline.TimelineEvents import io.element.android.features.messages.impl.timeline.TimelineEvents
@ -234,7 +234,7 @@ class ThreadedMessagesNode(
val state = presenter.present() val state = presenter.present()
OnLifecycleEvent { _, event -> OnLifecycleEvent { _, event ->
when (event) { when (event) {
Lifecycle.Event.ON_PAUSE -> state.composerState.eventSink(MessageComposerEvents.SaveDraft) Lifecycle.Event.ON_PAUSE -> state.composerState.eventSink(MessageComposerEvent.SaveDraft)
else -> Unit else -> Unit
} }
} }

38
features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/MessagesPresenterTest.kt
View file

@ -20,7 +20,7 @@ import io.element.android.features.messages.impl.actionlist.model.TimelineItemAc
import io.element.android.features.messages.impl.crypto.identity.anIdentityChangeState import io.element.android.features.messages.impl.crypto.identity.anIdentityChangeState
import io.element.android.features.messages.impl.fixtures.aMessageEvent import io.element.android.features.messages.impl.fixtures.aMessageEvent
import io.element.android.features.messages.impl.link.aLinkState import io.element.android.features.messages.impl.link.aLinkState
import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvents import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvent
import io.element.android.features.messages.impl.messagecomposer.MessageComposerState import io.element.android.features.messages.impl.messagecomposer.MessageComposerState
import io.element.android.features.messages.impl.messagecomposer.aMessageComposerState import io.element.android.features.messages.impl.messagecomposer.aMessageComposerState
import io.element.android.features.messages.impl.pinned.banner.aLoadedPinnedMessagesBannerState import io.element.android.features.messages.impl.pinned.banner.aLoadedPinnedMessagesBannerState
@ -304,7 +304,7 @@ class MessagesPresenterTest {
@Test @Test
fun `present - handle action reply`() = runTest { fun `present - handle action reply`() = runTest {
val composerRecorder = EventsRecorder<MessageComposerEvents>() val composerRecorder = EventsRecorder<MessageComposerEvent>()
val presenter = createMessagesPresenter( val presenter = createMessagesPresenter(
messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) }, messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) },
) )
@ -313,7 +313,7 @@ class MessagesPresenterTest {
initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Reply, aMessageEvent())) initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Reply, aMessageEvent()))
awaitItem() awaitItem()
composerRecorder.assertSingle( composerRecorder.assertSingle(
MessageComposerEvents.SetMode( MessageComposerEvent.SetMode(
composerMode = MessageComposerMode.Reply( composerMode = MessageComposerMode.Reply(
replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID), replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID),
hideImage = false, hideImage = false,
@ -335,7 +335,7 @@ class MessagesPresenterTest {
@Test @Test
fun `present - handle action reply to an image media message`() = runTest { fun `present - handle action reply to an image media message`() = runTest {
val composerRecorder = EventsRecorder<MessageComposerEvents>() val composerRecorder = EventsRecorder<MessageComposerEvent>()
val presenter = createMessagesPresenter( val presenter = createMessagesPresenter(
messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) }, messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) },
) )
@ -364,7 +364,7 @@ class MessagesPresenterTest {
initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Reply, mediaMessage)) initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Reply, mediaMessage))
awaitItem() awaitItem()
composerRecorder.assertSingle( composerRecorder.assertSingle(
MessageComposerEvents.SetMode( MessageComposerEvent.SetMode(
composerMode = MessageComposerMode.Reply( composerMode = MessageComposerMode.Reply(
replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID), replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID),
hideImage = false, hideImage = false,
@ -376,7 +376,7 @@ class MessagesPresenterTest {
@Test @Test
fun `present - handle action reply to a video media message`() = runTest { fun `present - handle action reply to a video media message`() = runTest {
val composerRecorder = EventsRecorder<MessageComposerEvents>() val composerRecorder = EventsRecorder<MessageComposerEvent>()
val presenter = createMessagesPresenter( val presenter = createMessagesPresenter(
messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) }, messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) },
) )
@ -406,7 +406,7 @@ class MessagesPresenterTest {
initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Reply, mediaMessage)) initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Reply, mediaMessage))
awaitItem() awaitItem()
composerRecorder.assertSingle( composerRecorder.assertSingle(
MessageComposerEvents.SetMode( MessageComposerEvent.SetMode(
composerMode = MessageComposerMode.Reply( composerMode = MessageComposerMode.Reply(
replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID), replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID),
hideImage = false, hideImage = false,
@ -418,7 +418,7 @@ class MessagesPresenterTest {
@Test @Test
fun `present - handle action reply to a file media message`() = runTest { fun `present - handle action reply to a file media message`() = runTest {
val composerRecorder = EventsRecorder<MessageComposerEvents>() val composerRecorder = EventsRecorder<MessageComposerEvent>()
val presenter = createMessagesPresenter( val presenter = createMessagesPresenter(
messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) }, messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) },
) )
@ -441,7 +441,7 @@ class MessagesPresenterTest {
initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Reply, mediaMessage)) initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Reply, mediaMessage))
awaitItem() awaitItem()
composerRecorder.assertSingle( composerRecorder.assertSingle(
MessageComposerEvents.SetMode( MessageComposerEvent.SetMode(
composerMode = MessageComposerMode.Reply( composerMode = MessageComposerMode.Reply(
replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID), replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID),
hideImage = false, hideImage = false,
@ -453,7 +453,7 @@ class MessagesPresenterTest {
@Test @Test
fun `present - handle action edit`() = runTest { fun `present - handle action edit`() = runTest {
val composerRecorder = EventsRecorder<MessageComposerEvents>() val composerRecorder = EventsRecorder<MessageComposerEvent>()
val presenter = createMessagesPresenter( val presenter = createMessagesPresenter(
messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) }, messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) },
) )
@ -462,7 +462,7 @@ class MessagesPresenterTest {
initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Edit, aMessageEvent())) initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Edit, aMessageEvent()))
awaitItem() awaitItem()
composerRecorder.assertSingle( composerRecorder.assertSingle(
MessageComposerEvents.SetMode( MessageComposerEvent.SetMode(
composerMode = MessageComposerMode.Edit( composerMode = MessageComposerMode.Edit(
eventOrTransactionId = AN_EVENT_ID.toEventOrTransactionId(), eventOrTransactionId = AN_EVENT_ID.toEventOrTransactionId(),
content = (aMessageEvent().content as TimelineItemTextContent).body content = (aMessageEvent().content as TimelineItemTextContent).body
@ -892,7 +892,7 @@ class MessagesPresenterTest {
@Test @Test
fun `present - handle action reply to a poll`() = runTest { fun `present - handle action reply to a poll`() = runTest {
val composerRecorder = EventsRecorder<MessageComposerEvents>() val composerRecorder = EventsRecorder<MessageComposerEvent>()
val presenter = createMessagesPresenter( val presenter = createMessagesPresenter(
messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) }, messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) },
) )
@ -904,7 +904,7 @@ class MessagesPresenterTest {
initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Reply, poll)) initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.Reply, poll))
skipItems(1) skipItems(1)
composerRecorder.assertSingle( composerRecorder.assertSingle(
MessageComposerEvents.SetMode( MessageComposerEvent.SetMode(
composerMode = MessageComposerMode.Reply( composerMode = MessageComposerMode.Reply(
replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID), replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID),
hideImage = false, hideImage = false,
@ -1009,7 +1009,7 @@ class MessagesPresenterTest {
caption = A_CAPTION, caption = A_CAPTION,
) )
) )
val composerRecorder = EventsRecorder<MessageComposerEvents>() val composerRecorder = EventsRecorder<MessageComposerEvent>()
val presenter = createMessagesPresenter( val presenter = createMessagesPresenter(
messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) }, messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) },
) )
@ -1018,7 +1018,7 @@ class MessagesPresenterTest {
initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.EditCaption, messageEvent)) initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.EditCaption, messageEvent))
awaitItem() awaitItem()
composerRecorder.assertSingle( composerRecorder.assertSingle(
MessageComposerEvents.SetMode( MessageComposerEvent.SetMode(
composerMode = MessageComposerMode.EditCaption( composerMode = MessageComposerMode.EditCaption(
eventOrTransactionId = AN_EVENT_ID.toEventOrTransactionId(), eventOrTransactionId = AN_EVENT_ID.toEventOrTransactionId(),
content = A_CAPTION, content = A_CAPTION,
@ -1030,7 +1030,7 @@ class MessagesPresenterTest {
@Test @Test
fun `present - handle action add caption`() = runTest { fun `present - handle action add caption`() = runTest {
val composerRecorder = EventsRecorder<MessageComposerEvents>() val composerRecorder = EventsRecorder<MessageComposerEvent>()
val presenter = createMessagesPresenter( val presenter = createMessagesPresenter(
messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) }, messageComposerPresenter = { aMessageComposerState(eventSink = composerRecorder) },
) )
@ -1044,7 +1044,7 @@ class MessagesPresenterTest {
initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.AddCaption, messageEvent)) initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.AddCaption, messageEvent))
awaitItem() awaitItem()
composerRecorder.assertSingle( composerRecorder.assertSingle(
MessageComposerEvents.SetMode( MessageComposerEvent.SetMode(
composerMode = MessageComposerMode.EditCaption( composerMode = MessageComposerMode.EditCaption(
eventOrTransactionId = AN_EVENT_ID.toEventOrTransactionId(), eventOrTransactionId = AN_EVENT_ID.toEventOrTransactionId(),
content = "", content = "",
@ -1231,7 +1231,7 @@ class MessagesPresenterTest {
@Test @Test
fun `present - handle action reply in a thread with threads disabled`() = runTest { fun `present - handle action reply in a thread with threads disabled`() = runTest {
val composerRecorder = EventsRecorder<MessageComposerEvents>() val composerRecorder = EventsRecorder<MessageComposerEvent>()
val presenter = createMessagesPresenter( val presenter = createMessagesPresenter(
featureFlagService = FakeFeatureFlagService( featureFlagService = FakeFeatureFlagService(
initialState = mapOf(FeatureFlags.Threads.key to false) initialState = mapOf(FeatureFlags.Threads.key to false)
@ -1243,7 +1243,7 @@ class MessagesPresenterTest {
initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.ReplyInThread, aMessageEvent())) initialState.eventSink(MessagesEvents.HandleAction(TimelineItemAction.ReplyInThread, aMessageEvent()))
awaitItem() awaitItem()
composerRecorder.assertSingle( composerRecorder.assertSingle(
MessageComposerEvents.SetMode( MessageComposerEvent.SetMode(
composerMode = MessageComposerMode.Reply( composerMode = MessageComposerMode.Reply(
replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID), replyToDetails = InReplyToDetails.Loading(AN_EVENT_ID),
hideImage = false, hideImage = false,

134
features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerPresenterTest.kt
View file

@ -154,10 +154,10 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink.invoke(MessageComposerEvents.ToggleFullScreenState) initialState.eventSink.invoke(MessageComposerEvent.ToggleFullScreenState)
val fullscreenState = awaitItem() val fullscreenState = awaitItem()
assertThat(fullscreenState.isFullScreen).isTrue() assertThat(fullscreenState.isFullScreen).isTrue()
fullscreenState.eventSink.invoke(MessageComposerEvents.ToggleFullScreenState) fullscreenState.eventSink.invoke(MessageComposerEvent.ToggleFullScreenState)
val notFullscreenState = awaitItem() val notFullscreenState = awaitItem()
assertThat(notFullscreenState.isFullScreen).isFalse() assertThat(notFullscreenState.isFullScreen).isFalse()
} }
@ -196,7 +196,7 @@ class MessageComposerPresenterTest {
}.test { }.test {
var state = awaitFirstItem() var state = awaitFirstItem()
val mode = anEditMode(message = ANOTHER_MESSAGE) val mode = anEditMode(message = ANOTHER_MESSAGE)
state.eventSink.invoke(MessageComposerEvents.SetMode(mode)) state.eventSink.invoke(MessageComposerEvent.SetMode(mode))
state = awaitItem() state = awaitItem()
assertThat(state.mode).isEqualTo(mode) assertThat(state.mode).isEqualTo(mode)
assertThat(state.textEditorState.messageHtml()).isEqualTo(ANOTHER_MESSAGE) assertThat(state.textEditorState.messageHtml()).isEqualTo(ANOTHER_MESSAGE)
@ -238,7 +238,7 @@ class MessageComposerPresenterTest {
}.test { }.test {
var state = awaitFirstItem() var state = awaitFirstItem()
val mode = anEditCaptionMode(caption = A_CAPTION) val mode = anEditCaptionMode(caption = A_CAPTION)
state.eventSink.invoke(MessageComposerEvents.SetMode(mode)) state.eventSink.invoke(MessageComposerEvent.SetMode(mode))
state = awaitItem() state = awaitItem()
assertThat(state.mode).isEqualTo(mode) assertThat(state.mode).isEqualTo(mode)
assertThat(state.textEditorState.messageHtml()).isEqualTo(A_CAPTION) assertThat(state.textEditorState.messageHtml()).isEqualTo(A_CAPTION)
@ -280,11 +280,11 @@ class MessageComposerPresenterTest {
presenter.test { presenter.test {
var state = awaitFirstItem() var state = awaitFirstItem()
val mode = anEditCaptionMode(caption = A_CAPTION) val mode = anEditCaptionMode(caption = A_CAPTION)
state.eventSink.invoke(MessageComposerEvents.SetMode(mode)) state.eventSink.invoke(MessageComposerEvent.SetMode(mode))
state = awaitItem() state = awaitItem()
assertThat(state.mode).isEqualTo(mode) assertThat(state.mode).isEqualTo(mode)
assertThat(state.textEditorState.messageMarkdown(permalinkBuilder)).isEqualTo(A_CAPTION) assertThat(state.textEditorState.messageMarkdown(permalinkBuilder)).isEqualTo(A_CAPTION)
state.eventSink.invoke(MessageComposerEvents.SendMessage) state.eventSink.invoke(MessageComposerEvent.SendMessage)
val messageSentState = awaitItem() val messageSentState = awaitItem()
assertThat(messageSentState.textEditorState.messageMarkdown(permalinkBuilder)).isEqualTo("") assertThat(messageSentState.textEditorState.messageMarkdown(permalinkBuilder)).isEqualTo("")
waitForPredicate { analyticsService.capturedEvents.size == 1 } waitForPredicate { analyticsService.capturedEvents.size == 1 }
@ -321,13 +321,13 @@ class MessageComposerPresenterTest {
}.test { }.test {
var state = awaitFirstItem() var state = awaitFirstItem()
val editMode = anEditMode(message = ANOTHER_MESSAGE) val editMode = anEditMode(message = ANOTHER_MESSAGE)
state.eventSink.invoke(MessageComposerEvents.SetMode(editMode)) state.eventSink.invoke(MessageComposerEvent.SetMode(editMode))
state = awaitItem() state = awaitItem()
assertThat(state.mode).isEqualTo(editMode) assertThat(state.mode).isEqualTo(editMode)
assertThat(state.textEditorState.messageHtml()).isEqualTo(ANOTHER_MESSAGE) assertThat(state.textEditorState.messageHtml()).isEqualTo(ANOTHER_MESSAGE)
val replyMode = aReplyMode() val replyMode = aReplyMode()
state.eventSink.invoke(MessageComposerEvents.SetMode(replyMode)) state.eventSink.invoke(MessageComposerEvent.SetMode(replyMode))
state = awaitItem() state = awaitItem()
assertThat(state.mode).isEqualTo(replyMode) assertThat(state.mode).isEqualTo(replyMode)
assertThat(state.textEditorState.messageHtml()).isEmpty() assertThat(state.textEditorState.messageHtml()).isEmpty()
@ -350,7 +350,7 @@ class MessageComposerPresenterTest {
}.test { }.test {
var state = awaitFirstItem() var state = awaitFirstItem()
val mode = aReplyMode() val mode = aReplyMode()
state.eventSink.invoke(MessageComposerEvents.SetMode(mode)) state.eventSink.invoke(MessageComposerEvent.SetMode(mode))
state = awaitItem() state = awaitItem()
assertThat(state.mode).isEqualTo(mode) assertThat(state.mode).isEqualTo(mode)
assertThat(state.textEditorState.messageHtml()).isEqualTo("") assertThat(state.textEditorState.messageHtml()).isEqualTo("")
@ -366,7 +366,7 @@ class MessageComposerPresenterTest {
}.test { }.test {
var state = awaitFirstItem() var state = awaitFirstItem()
val mode = aReplyMode() val mode = aReplyMode()
state.eventSink.invoke(MessageComposerEvents.SetMode(mode)) state.eventSink.invoke(MessageComposerEvent.SetMode(mode))
state = awaitItem() state = awaitItem()
assertThat(state.mode).isEqualTo(mode) assertThat(state.mode).isEqualTo(mode)
state.textEditorState.setHtml(A_REPLY) state.textEditorState.setHtml(A_REPLY)
@ -395,7 +395,7 @@ class MessageComposerPresenterTest {
initialState.textEditorState.setHtml(A_MESSAGE) initialState.textEditorState.setHtml(A_MESSAGE)
val withMessageState = awaitItem() val withMessageState = awaitItem()
assertThat(withMessageState.textEditorState.messageHtml()).isEqualTo(A_MESSAGE) assertThat(withMessageState.textEditorState.messageHtml()).isEqualTo(A_MESSAGE)
withMessageState.eventSink.invoke(MessageComposerEvents.SendMessage) withMessageState.eventSink.invoke(MessageComposerEvent.SendMessage)
val messageSentState = awaitItem() val messageSentState = awaitItem()
assertThat(messageSentState.textEditorState.messageHtml()).isEqualTo("") assertThat(messageSentState.textEditorState.messageHtml()).isEqualTo("")
waitForPredicate { analyticsService.capturedEvents.size == 1 } waitForPredicate { analyticsService.capturedEvents.size == 1 }
@ -432,7 +432,7 @@ class MessageComposerPresenterTest {
val withMessageState = awaitItem() val withMessageState = awaitItem()
assertThat(withMessageState.textEditorState.messageMarkdown(permalinkBuilder)).isEqualTo(A_MESSAGE) assertThat(withMessageState.textEditorState.messageMarkdown(permalinkBuilder)).isEqualTo(A_MESSAGE)
assertThat(withMessageState.textEditorState.messageHtml()).isNull() assertThat(withMessageState.textEditorState.messageHtml()).isNull()
withMessageState.eventSink.invoke(MessageComposerEvents.SendMessage) withMessageState.eventSink.invoke(MessageComposerEvent.SendMessage)
val messageSentState = awaitItem() val messageSentState = awaitItem()
assertThat(messageSentState.textEditorState.messageMarkdown(permalinkBuilder)).isEqualTo("") assertThat(messageSentState.textEditorState.messageMarkdown(permalinkBuilder)).isEqualTo("")
waitForPredicate { analyticsService.capturedEvents.size == 1 } waitForPredicate { analyticsService.capturedEvents.size == 1 }
@ -469,14 +469,14 @@ class MessageComposerPresenterTest {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
assertThat(initialState.textEditorState.messageHtml()).isEqualTo("") assertThat(initialState.textEditorState.messageHtml()).isEqualTo("")
val mode = anEditMode() val mode = anEditMode()
initialState.eventSink.invoke(MessageComposerEvents.SetMode(mode)) initialState.eventSink.invoke(MessageComposerEvent.SetMode(mode))
val withMessageState = awaitItem() val withMessageState = awaitItem()
assertThat(withMessageState.mode).isEqualTo(mode) assertThat(withMessageState.mode).isEqualTo(mode)
assertThat(withMessageState.textEditorState.messageHtml()).isEqualTo(A_MESSAGE) assertThat(withMessageState.textEditorState.messageHtml()).isEqualTo(A_MESSAGE)
withMessageState.textEditorState.setHtml(ANOTHER_MESSAGE) withMessageState.textEditorState.setHtml(ANOTHER_MESSAGE)
val withEditedMessageState = awaitItem() val withEditedMessageState = awaitItem()
assertThat(withEditedMessageState.textEditorState.messageHtml()).isEqualTo(ANOTHER_MESSAGE) assertThat(withEditedMessageState.textEditorState.messageHtml()).isEqualTo(ANOTHER_MESSAGE)
withEditedMessageState.eventSink.invoke(MessageComposerEvents.SendMessage) withEditedMessageState.eventSink.invoke(MessageComposerEvent.SendMessage)
skipItems(1) skipItems(1)
val messageSentState = awaitItem() val messageSentState = awaitItem()
assertThat(messageSentState.textEditorState.messageHtml()).isEqualTo("") assertThat(messageSentState.textEditorState.messageHtml()).isEqualTo("")
@ -524,14 +524,14 @@ class MessageComposerPresenterTest {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
assertThat(initialState.textEditorState.messageHtml()).isEqualTo("") assertThat(initialState.textEditorState.messageHtml()).isEqualTo("")
val mode = anEditMode() val mode = anEditMode()
initialState.eventSink.invoke(MessageComposerEvents.SetMode(mode)) initialState.eventSink.invoke(MessageComposerEvent.SetMode(mode))
val withMessageState = awaitItem() val withMessageState = awaitItem()
assertThat(withMessageState.mode).isEqualTo(mode) assertThat(withMessageState.mode).isEqualTo(mode)
assertThat(withMessageState.textEditorState.messageHtml()).isEqualTo(A_MESSAGE) assertThat(withMessageState.textEditorState.messageHtml()).isEqualTo(A_MESSAGE)
withMessageState.textEditorState.setHtml(ANOTHER_MESSAGE) withMessageState.textEditorState.setHtml(ANOTHER_MESSAGE)
val withEditedMessageState = awaitItem() val withEditedMessageState = awaitItem()
assertThat(withEditedMessageState.textEditorState.messageHtml()).isEqualTo(ANOTHER_MESSAGE) assertThat(withEditedMessageState.textEditorState.messageHtml()).isEqualTo(ANOTHER_MESSAGE)
withEditedMessageState.eventSink.invoke(MessageComposerEvents.SendMessage) withEditedMessageState.eventSink.invoke(MessageComposerEvent.SendMessage)
skipItems(1) skipItems(1)
val messageSentState = awaitItem() val messageSentState = awaitItem()
assertThat(messageSentState.textEditorState.messageHtml()).isEqualTo("") assertThat(messageSentState.textEditorState.messageHtml()).isEqualTo("")
@ -579,14 +579,14 @@ class MessageComposerPresenterTest {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
assertThat(initialState.textEditorState.messageHtml()).isEqualTo("") assertThat(initialState.textEditorState.messageHtml()).isEqualTo("")
val mode = anEditMode(eventOrTransactionId = A_TRANSACTION_ID.toEventOrTransactionId()) val mode = anEditMode(eventOrTransactionId = A_TRANSACTION_ID.toEventOrTransactionId())
initialState.eventSink.invoke(MessageComposerEvents.SetMode(mode)) initialState.eventSink.invoke(MessageComposerEvent.SetMode(mode))
val withMessageState = awaitItem() val withMessageState = awaitItem()
assertThat(withMessageState.mode).isEqualTo(mode) assertThat(withMessageState.mode).isEqualTo(mode)
assertThat(withMessageState.textEditorState.messageHtml()).isEqualTo(A_MESSAGE) assertThat(withMessageState.textEditorState.messageHtml()).isEqualTo(A_MESSAGE)
withMessageState.textEditorState.setHtml(ANOTHER_MESSAGE) withMessageState.textEditorState.setHtml(ANOTHER_MESSAGE)
val withEditedMessageState = awaitItem() val withEditedMessageState = awaitItem()
assertThat(withEditedMessageState.textEditorState.messageHtml()).isEqualTo(ANOTHER_MESSAGE) assertThat(withEditedMessageState.textEditorState.messageHtml()).isEqualTo(ANOTHER_MESSAGE)
withEditedMessageState.eventSink.invoke(MessageComposerEvents.SendMessage) withEditedMessageState.eventSink.invoke(MessageComposerEvent.SendMessage)
skipItems(1) skipItems(1)
val messageSentState = awaitItem() val messageSentState = awaitItem()
assertThat(messageSentState.textEditorState.messageHtml()).isEqualTo("") assertThat(messageSentState.textEditorState.messageHtml()).isEqualTo("")
@ -629,13 +629,13 @@ class MessageComposerPresenterTest {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
assertThat(initialState.textEditorState.messageHtml()).isEqualTo("") assertThat(initialState.textEditorState.messageHtml()).isEqualTo("")
val mode = aReplyMode() val mode = aReplyMode()
initialState.eventSink.invoke(MessageComposerEvents.SetMode(mode)) initialState.eventSink.invoke(MessageComposerEvent.SetMode(mode))
val state = awaitItem() val state = awaitItem()
assertThat(state.mode).isEqualTo(mode) assertThat(state.mode).isEqualTo(mode)
assertThat(state.textEditorState.messageHtml()).isEqualTo("") assertThat(state.textEditorState.messageHtml()).isEqualTo("")
state.textEditorState.setHtml(A_REPLY) state.textEditorState.setHtml(A_REPLY)
assertThat(state.textEditorState.messageHtml()).isEqualTo(A_REPLY) assertThat(state.textEditorState.messageHtml()).isEqualTo(A_REPLY)
state.eventSink.invoke(MessageComposerEvents.SendMessage) state.eventSink.invoke(MessageComposerEvent.SendMessage)
val messageSentState = awaitItem() val messageSentState = awaitItem()
assertThat(messageSentState.textEditorState.messageHtml()).isEqualTo("") assertThat(messageSentState.textEditorState.messageHtml()).isEqualTo("")
@ -664,7 +664,7 @@ class MessageComposerPresenterTest {
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
assertThat(initialState.showAttachmentSourcePicker).isFalse() assertThat(initialState.showAttachmentSourcePicker).isFalse()
initialState.eventSink(MessageComposerEvents.AddAttachment) initialState.eventSink(MessageComposerEvent.AddAttachment)
assertThat(awaitItem().showAttachmentSourcePicker).isTrue() assertThat(awaitItem().showAttachmentSourcePicker).isTrue()
} }
} }
@ -676,10 +676,10 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.AddAttachment) initialState.eventSink(MessageComposerEvent.AddAttachment)
skipItems(1) skipItems(1)
initialState.eventSink(MessageComposerEvents.DismissAttachmentMenu) initialState.eventSink(MessageComposerEvent.DismissAttachmentMenu)
assertThat(awaitItem().showAttachmentSourcePicker).isFalse() assertThat(awaitItem().showAttachmentSourcePicker).isFalse()
} }
} }
@ -719,7 +719,7 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.PickAttachmentSource.FromGallery) initialState.eventSink(MessageComposerEvent.PickAttachmentSource.FromGallery)
onPreviewAttachmentLambda.assertions().isCalledOnce() onPreviewAttachmentLambda.assertions().isCalledOnce()
} }
} }
@ -760,7 +760,7 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.PickAttachmentSource.FromGallery) initialState.eventSink(MessageComposerEvent.PickAttachmentSource.FromGallery)
onPreviewAttachmentLambda.assertions().isCalledOnce() onPreviewAttachmentLambda.assertions().isCalledOnce()
} }
} }
@ -776,7 +776,7 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.PickAttachmentSource.FromGallery) initialState.eventSink(MessageComposerEvent.PickAttachmentSource.FromGallery)
// No crashes here, otherwise it fails // No crashes here, otherwise it fails
} }
} }
@ -798,7 +798,7 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.PickAttachmentSource.FromFiles) initialState.eventSink(MessageComposerEvent.PickAttachmentSource.FromFiles)
onPreviewAttachmentLambda.assertions().isCalledOnce() onPreviewAttachmentLambda.assertions().isCalledOnce()
} }
} }
@ -813,10 +813,10 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.AddAttachment) initialState.eventSink(MessageComposerEvent.AddAttachment)
val attachmentOpenState = awaitItem() val attachmentOpenState = awaitItem()
assertThat(attachmentOpenState.showAttachmentSourcePicker).isTrue() assertThat(attachmentOpenState.showAttachmentSourcePicker).isTrue()
initialState.eventSink(MessageComposerEvents.PickAttachmentSource.Poll) initialState.eventSink(MessageComposerEvent.PickAttachmentSource.Poll)
val finalState = awaitItem() val finalState = awaitItem()
assertThat(finalState.showAttachmentSourcePicker).isFalse() assertThat(finalState.showAttachmentSourcePicker).isFalse()
} }
@ -832,10 +832,10 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.AddAttachment) initialState.eventSink(MessageComposerEvent.AddAttachment)
val attachmentOpenState = awaitItem() val attachmentOpenState = awaitItem()
assertThat(attachmentOpenState.showAttachmentSourcePicker).isTrue() assertThat(attachmentOpenState.showAttachmentSourcePicker).isTrue()
initialState.eventSink(MessageComposerEvents.PickAttachmentSource.Location) initialState.eventSink(MessageComposerEvent.PickAttachmentSource.Location)
val finalState = awaitItem() val finalState = awaitItem()
assertThat(finalState.showAttachmentSourcePicker).isFalse() assertThat(finalState.showAttachmentSourcePicker).isFalse()
} }
@ -860,7 +860,7 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.PickAttachmentSource.PhotoFromCamera) initialState.eventSink(MessageComposerEvent.PickAttachmentSource.PhotoFromCamera)
onPreviewAttachmentLambda.assertions().isCalledOnce() onPreviewAttachmentLambda.assertions().isCalledOnce()
} }
} }
@ -884,7 +884,7 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.PickAttachmentSource.PhotoFromCamera) initialState.eventSink(MessageComposerEvent.PickAttachmentSource.PhotoFromCamera)
permissionPresenter.setPermissionGranted() permissionPresenter.setPermissionGranted()
onPreviewAttachmentLambda.assertions().isCalledOnce() onPreviewAttachmentLambda.assertions().isCalledOnce()
cancelAndIgnoreRemainingEvents() cancelAndIgnoreRemainingEvents()
@ -910,7 +910,7 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.PickAttachmentSource.VideoFromCamera) initialState.eventSink(MessageComposerEvent.PickAttachmentSource.VideoFromCamera)
onPreviewAttachmentLambda.assertions().isCalledOnce() onPreviewAttachmentLambda.assertions().isCalledOnce()
} }
} }
@ -934,7 +934,7 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.PickAttachmentSource.VideoFromCamera) initialState.eventSink(MessageComposerEvent.PickAttachmentSource.VideoFromCamera)
val permissionState = awaitItem() val permissionState = awaitItem()
assertThat(permissionState.showAttachmentSourcePicker).isFalse() assertThat(permissionState.showAttachmentSourcePicker).isFalse()
permissionPresenter.setPermissionGranted() permissionPresenter.setPermissionGranted()
@ -951,7 +951,7 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink(MessageComposerEvents.Error(testException)) initialState.eventSink(MessageComposerEvent.Error(testException))
assertThat(analyticsService.trackedErrors).containsExactly(testException) assertThat(analyticsService.trackedErrors).containsExactly(testException)
} }
} }
@ -964,10 +964,10 @@ class MessageComposerPresenterTest {
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
assertThat(initialState.showTextFormatting).isFalse() assertThat(initialState.showTextFormatting).isFalse()
initialState.eventSink(MessageComposerEvents.AddAttachment) initialState.eventSink(MessageComposerEvent.AddAttachment)
val composerOptions = awaitItem() val composerOptions = awaitItem()
assertThat(composerOptions.showAttachmentSourcePicker).isTrue() assertThat(composerOptions.showAttachmentSourcePicker).isTrue()
composerOptions.eventSink(MessageComposerEvents.ToggleTextFormatting(true)) composerOptions.eventSink(MessageComposerEvent.ToggleTextFormatting(true))
skipItems(2) // composer options closed skipItems(2) // composer options closed
val showTextFormatting = awaitItem() val showTextFormatting = awaitItem()
assertThat(showTextFormatting.showAttachmentSourcePicker).isFalse() assertThat(showTextFormatting.showAttachmentSourcePicker).isFalse()
@ -976,7 +976,7 @@ class MessageComposerPresenterTest {
Interaction(index = null, interactionType = null, name = Interaction.Name.MobileRoomComposerFormattingEnabled) Interaction(index = null, interactionType = null, name = Interaction.Name.MobileRoomComposerFormattingEnabled)
) )
analyticsService.capturedEvents.clear() analyticsService.capturedEvents.clear()
showTextFormatting.eventSink(MessageComposerEvents.ToggleTextFormatting(false)) showTextFormatting.eventSink(MessageComposerEvent.ToggleTextFormatting(false))
skipItems(1) skipItems(1)
val finished = awaitItem() val finished = awaitItem()
assertThat(finished.showTextFormatting).isFalse() assertThat(finished.showTextFormatting).isFalse()
@ -1009,33 +1009,33 @@ class MessageComposerPresenterTest {
val initialState = awaitItem() val initialState = awaitItem()
// A null suggestion (no suggestion was received) returns nothing // A null suggestion (no suggestion was received) returns nothing
initialState.eventSink(MessageComposerEvents.SuggestionReceived(null)) initialState.eventSink(MessageComposerEvent.SuggestionReceived(null))
assertThat(awaitItem().suggestions).isEmpty() assertThat(awaitItem().suggestions).isEmpty()
// An empty suggestion returns the room and joined members that are not the current user // An empty suggestion returns the room and joined members that are not the current user
initialState.eventSink(MessageComposerEvents.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, ""))) initialState.eventSink(MessageComposerEvent.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, "")))
assertThat(awaitItem().suggestions) assertThat(awaitItem().suggestions)
.containsExactly(ResolvedSuggestion.AtRoom, ResolvedSuggestion.Member(bob), ResolvedSuggestion.Member(david)) .containsExactly(ResolvedSuggestion.AtRoom, ResolvedSuggestion.Member(bob), ResolvedSuggestion.Member(david))
// A suggestion containing a part of "room" will also return the room mention // A suggestion containing a part of "room" will also return the room mention
initialState.eventSink(MessageComposerEvents.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, "roo"))) initialState.eventSink(MessageComposerEvent.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, "roo")))
assertThat(awaitItem().suggestions).containsExactly(ResolvedSuggestion.AtRoom) assertThat(awaitItem().suggestions).containsExactly(ResolvedSuggestion.AtRoom)
// A non-empty suggestion will return those joined members whose user id matches it // A non-empty suggestion will return those joined members whose user id matches it
initialState.eventSink(MessageComposerEvents.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, "bob"))) initialState.eventSink(MessageComposerEvent.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, "bob")))
assertThat(awaitItem().suggestions).containsExactly(ResolvedSuggestion.Member(bob)) assertThat(awaitItem().suggestions).containsExactly(ResolvedSuggestion.Member(bob))
// A non-empty suggestion will return those joined members whose display name matches it // A non-empty suggestion will return those joined members whose display name matches it
initialState.eventSink(MessageComposerEvents.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, "dave"))) initialState.eventSink(MessageComposerEvent.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, "dave")))
assertThat(awaitItem().suggestions).containsExactly(ResolvedSuggestion.Member(david)) assertThat(awaitItem().suggestions).containsExactly(ResolvedSuggestion.Member(david))
// If the suggestion isn't a mention, no suggestions are returned // If the suggestion isn't a mention, no suggestions are returned
initialState.eventSink(MessageComposerEvents.SuggestionReceived(Suggestion(0, 0, SuggestionType.Command, ""))) initialState.eventSink(MessageComposerEvent.SuggestionReceived(Suggestion(0, 0, SuggestionType.Command, "")))
assertThat(awaitItem().suggestions).isEmpty() assertThat(awaitItem().suggestions).isEmpty()
// If user has no permission to send `@room` mentions, `RoomMemberSuggestion.Room` is not returned // If user has no permission to send `@room` mentions, `RoomMemberSuggestion.Room` is not returned
canUserTriggerRoomNotificationResult = false canUserTriggerRoomNotificationResult = false
initialState.eventSink(MessageComposerEvents.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, ""))) initialState.eventSink(MessageComposerEvent.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, "")))
assertThat(awaitItem().suggestions) assertThat(awaitItem().suggestions)
.containsExactly(ResolvedSuggestion.Member(bob), ResolvedSuggestion.Member(david)) .containsExactly(ResolvedSuggestion.Member(bob), ResolvedSuggestion.Member(david))
} }
@ -1070,7 +1070,7 @@ class MessageComposerPresenterTest {
val initialState = awaitItem() val initialState = awaitItem()
// An empty suggestion returns the joined members that are not the current user, but not the room // An empty suggestion returns the joined members that are not the current user, but not the room
initialState.eventSink(MessageComposerEvents.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, ""))) initialState.eventSink(MessageComposerEvent.SuggestionReceived(Suggestion(0, 0, SuggestionType.Mention, "")))
skipItems(1) skipItems(1)
assertThat(awaitItem().suggestions) assertThat(awaitItem().suggestions)
.containsExactly(ResolvedSuggestion.Member(bob), ResolvedSuggestion.Member(david)) .containsExactly(ResolvedSuggestion.Member(bob), ResolvedSuggestion.Member(david))
@ -1090,7 +1090,7 @@ class MessageComposerPresenterTest {
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.textEditorState.setHtml("Hey @bo") initialState.textEditorState.setHtml("Hey @bo")
initialState.eventSink(MessageComposerEvents.InsertSuggestion(ResolvedSuggestion.Member(aRoomMember(userId = A_USER_ID_2)))) initialState.eventSink(MessageComposerEvent.InsertSuggestion(ResolvedSuggestion.Member(aRoomMember(userId = A_USER_ID_2))))
assertThat(initialState.textEditorState.messageHtml()) assertThat(initialState.textEditorState.messageHtml())
.isEqualTo("Hey <a href='https://matrix.to/#/${A_USER_ID_2.value}'>${A_USER_ID_2.value}</a>") .isEqualTo("Hey <a href='https://matrix.to/#/${A_USER_ID_2.value}'>${A_USER_ID_2.value}</a>")
@ -1133,7 +1133,7 @@ class MessageComposerPresenterTest {
hasAtRoomMention = false hasAtRoomMention = false
) )
initialState.textEditorState.setHtml(A_MESSAGE) initialState.textEditorState.setHtml(A_MESSAGE)
initialState.eventSink(MessageComposerEvents.SendMessage) initialState.eventSink(MessageComposerEvent.SendMessage)
advanceUntilIdle() advanceUntilIdle()
@ -1141,7 +1141,7 @@ class MessageComposerPresenterTest {
.with(value(A_MESSAGE), any(), value(listOf(IntentionalMention.User(A_USER_ID)))) .with(value(A_MESSAGE), any(), value(listOf(IntentionalMention.User(A_USER_ID))))
// Check intentional mentions on reply sent // Check intentional mentions on reply sent
initialState.eventSink(MessageComposerEvents.SetMode(aReplyMode())) initialState.eventSink(MessageComposerEvent.SetMode(aReplyMode()))
val mentionUser2 = listOf(A_USER_ID_2.value) val mentionUser2 = listOf(A_USER_ID_2.value)
(awaitItem().textEditorState as? TextEditorState.Rich)?.richTextEditorState?.mentionsState = MentionsState( (awaitItem().textEditorState as? TextEditorState.Rich)?.richTextEditorState?.mentionsState = MentionsState(
userIds = mentionUser2, userIds = mentionUser2,
@ -1150,7 +1150,7 @@ class MessageComposerPresenterTest {
hasAtRoomMention = false hasAtRoomMention = false
) )
initialState.eventSink(MessageComposerEvents.SendMessage) initialState.eventSink(MessageComposerEvent.SendMessage)
advanceUntilIdle() advanceUntilIdle()
assert(replyMessageLambda) assert(replyMessageLambda)
@ -1159,7 +1159,7 @@ class MessageComposerPresenterTest {
// Check intentional mentions on edit message // Check intentional mentions on edit message
skipItems(1) skipItems(1)
initialState.eventSink(MessageComposerEvents.SetMode(anEditMode())) initialState.eventSink(MessageComposerEvent.SetMode(anEditMode()))
val mentionUser3 = listOf(A_USER_ID_3.value) val mentionUser3 = listOf(A_USER_ID_3.value)
(awaitItem().textEditorState as? TextEditorState.Rich)?.richTextEditorState?.mentionsState = MentionsState( (awaitItem().textEditorState as? TextEditorState.Rich)?.richTextEditorState?.mentionsState = MentionsState(
userIds = mentionUser3, userIds = mentionUser3,
@ -1168,7 +1168,7 @@ class MessageComposerPresenterTest {
hasAtRoomMention = false hasAtRoomMention = false
) )
initialState.eventSink(MessageComposerEvents.SendMessage) initialState.eventSink(MessageComposerEvent.SendMessage)
advanceUntilIdle() advanceUntilIdle()
assert(editMessageLambda) assert(editMessageLambda)
@ -1196,7 +1196,7 @@ class MessageComposerPresenterTest {
remember(state, state.textEditorState.messageHtml()) { state } remember(state, state.textEditorState.messageHtml()) { state }
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink.invoke(MessageComposerEvents.SendUri(Uri.parse("content://uri"))) initialState.eventSink.invoke(MessageComposerEvent.SendUri(Uri.parse("content://uri")))
waitForPredicate { mediaPreProcessor.processCallCount == 1 } waitForPredicate { mediaPreProcessor.processCallCount == 1 }
} }
} }
@ -1213,8 +1213,8 @@ class MessageComposerPresenterTest {
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
typingNoticeResult.assertions().isNeverCalled() typingNoticeResult.assertions().isNeverCalled()
initialState.eventSink.invoke(MessageComposerEvents.TypingNotice(true)) initialState.eventSink.invoke(MessageComposerEvent.TypingNotice(true))
initialState.eventSink.invoke(MessageComposerEvents.TypingNotice(false)) initialState.eventSink.invoke(MessageComposerEvent.TypingNotice(false))
advanceUntilIdle() advanceUntilIdle()
typingNoticeResult.assertions().isCalledExactly(2) typingNoticeResult.assertions().isCalledExactly(2)
.withSequence( .withSequence(
@ -1239,8 +1239,8 @@ class MessageComposerPresenterTest {
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
typingNoticeResult.assertions().isNeverCalled() typingNoticeResult.assertions().isNeverCalled()
initialState.eventSink.invoke(MessageComposerEvents.TypingNotice(true)) initialState.eventSink.invoke(MessageComposerEvent.TypingNotice(true))
initialState.eventSink.invoke(MessageComposerEvents.TypingNotice(false)) initialState.eventSink.invoke(MessageComposerEvent.TypingNotice(false))
typingNoticeResult.assertions().isNeverCalled() typingNoticeResult.assertions().isNeverCalled()
} }
} }
@ -1422,7 +1422,7 @@ class MessageComposerPresenterTest {
presenter.present() presenter.present()
}.test { }.test {
val initialState = awaitFirstItem() val initialState = awaitFirstItem()
initialState.eventSink.invoke(MessageComposerEvents.SaveDraft) initialState.eventSink.invoke(MessageComposerEvent.SaveDraft)
advanceUntilIdle() advanceUntilIdle()
assert(saveDraftLambda) assert(saveDraftLambda)
.isCalledOnce() .isCalledOnce()
@ -1452,26 +1452,26 @@ class MessageComposerPresenterTest {
val withMessageState = awaitItem() val withMessageState = awaitItem()
assertThat(withMessageState.textEditorState.messageMarkdown(permalinkBuilder)).isEqualTo(A_MESSAGE) assertThat(withMessageState.textEditorState.messageMarkdown(permalinkBuilder)).isEqualTo(A_MESSAGE)
withMessageState.eventSink(MessageComposerEvents.SaveDraft) withMessageState.eventSink(MessageComposerEvent.SaveDraft)
advanceUntilIdle() advanceUntilIdle()
withMessageState.eventSink(MessageComposerEvents.ToggleTextFormatting(true)) withMessageState.eventSink(MessageComposerEvent.ToggleTextFormatting(true))
skipItems(1) skipItems(1)
val withFormattingState = awaitItem() val withFormattingState = awaitItem()
assertThat(withFormattingState.showTextFormatting).isTrue() assertThat(withFormattingState.showTextFormatting).isTrue()
withFormattingState.eventSink(MessageComposerEvents.SaveDraft) withFormattingState.eventSink(MessageComposerEvent.SaveDraft)
advanceUntilIdle() advanceUntilIdle()
withFormattingState.eventSink(MessageComposerEvents.SetMode(anEditMode())) withFormattingState.eventSink(MessageComposerEvent.SetMode(anEditMode()))
val withEditModeState = awaitItem() val withEditModeState = awaitItem()
assertThat(withEditModeState.mode).isEqualTo(anEditMode()) assertThat(withEditModeState.mode).isEqualTo(anEditMode())
withEditModeState.eventSink(MessageComposerEvents.SaveDraft) withEditModeState.eventSink(MessageComposerEvent.SaveDraft)
advanceUntilIdle() advanceUntilIdle()
withEditModeState.eventSink(MessageComposerEvents.SetMode(aReplyMode())) withEditModeState.eventSink(MessageComposerEvent.SetMode(aReplyMode()))
val withReplyModeState = awaitItem() val withReplyModeState = awaitItem()
assertThat(withReplyModeState.mode).isEqualTo(aReplyMode()) assertThat(withReplyModeState.mode).isEqualTo(aReplyMode())
withReplyModeState.eventSink(MessageComposerEvents.SaveDraft) withReplyModeState.eventSink(MessageComposerEvent.SaveDraft)
advanceUntilIdle() advanceUntilIdle()
assert(saveDraftLambda) assert(saveDraftLambda)
@ -1514,7 +1514,7 @@ class MessageComposerPresenterTest {
} }
private suspend fun ReceiveTurbine<MessageComposerState>.backToNormalMode(state: MessageComposerState, skipCount: Int = 0): MessageComposerState { private suspend fun ReceiveTurbine<MessageComposerState>.backToNormalMode(state: MessageComposerState, skipCount: Int = 0): MessageComposerState {
state.eventSink.invoke(MessageComposerEvents.CloseSpecialMode) state.eventSink.invoke(MessageComposerEvent.CloseSpecialMode)
skipItems(skipCount) skipItems(skipCount)
val normalState = awaitItem() val normalState = awaitItem()
assertThat(normalState.mode).isEqualTo(MessageComposerMode.Normal) assertThat(normalState.mode).isEqualTo(MessageComposerMode.Normal)