Merge branch 'develop' into feature-oled-black

2026-04-05 12:06:20 +04:00 · 2026-04-05 12:06:20 +04:00 · f19295d63d
commit f19295d63d
parent 5e6a6af409 67671126f2
291 changed files with 4973 additions and 1595 deletions
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesFlowNode.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesFlowNode.kt
@ -293,6 +293,10 @@ class MessagesFlowNode(
                    override fun navigateToThread(threadRootId: ThreadId, focusedEventId: EventId?) {
                        backstack.push(NavTarget.Thread(threadRootId, focusedEventId))
                    }
+
+                    override fun navigateToDeveloperSettings() {
+                        callback.navigateToDeveloperSettings()
+                    }
                }
                val inputs = MessagesNode.Inputs(focusedEventId = navTarget.focusedEventId)
                createNode<MessagesNode>(buildContext, listOf(callback, inputs))
@ -502,6 +506,10 @@ class MessagesFlowNode(
                    override fun navigateToThread(threadRootId: ThreadId, focusedEventId: EventId?) {
                        backstack.push(NavTarget.Thread(threadRootId, focusedEventId))
                    }
+
+                    override fun navigateToDeveloperSettings() {
+                        callback.navigateToDeveloperSettings()
+                    }
                }
                createNode<ThreadedMessagesNode>(buildContext, listOf(inputs, callback))
            }
@ -567,7 +575,7 @@ class MessagesFlowNode(
                    assetType = event.content.assetType,
                )
                NavTarget.LocationViewer(
-                   mode = mode
+                    mode = mode
                ).takeIf { locationService.isServiceAvailable() }
            }
            else -> null
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesNavigator.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesNavigator.kt
@ -23,6 +23,8 @@ interface MessagesNavigator {
    fun navigateToEditPoll(eventId: EventId)
    fun navigateToPreviewAttachments(attachments: ImmutableList<Attachment>, inReplyToEventId: EventId?)
    fun navigateToRoom(roomId: RoomId, eventId: EventId?, serverNames: List<String>)
+    fun navigateToMember(userId: UserId)
    fun navigateToThread(threadRootId: ThreadId, focusedEventId: EventId?)
+    fun navigateToDeveloperSettings()
    fun close()
 }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesNode.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesNode.kt
@ -105,7 +105,7 @@ class MessagesNode(
    private val timelineController = TimelineController(room, room.liveTimeline)
    private val presenter = presenterFactory.create(
        navigator = this,
-        composerPresenter = messageComposerPresenterFactory.create(timelineController, this),
+        composerPresenter = messageComposerPresenterFactory.create(timelineController, this, isInThread = false),
        timelinePresenter = timelinePresenterFactory.create(timelineController = timelineController, this),
        actionListPresenter = actionListPresenterFactory.create(
            postProcessor = TimelineItemActionPostProcessor.Default,
@ -130,6 +130,7 @@ class MessagesNode(
        fun navigateToRoomDetails()
        fun navigateToPinnedMessagesList()
        fun navigateToKnockRequestsList()
+        fun navigateToDeveloperSettings()
    }

    override fun onBuilt() {
@ -222,10 +223,18 @@ class MessagesNode(
        }
    }

+    override fun navigateToMember(userId: UserId) {
+        callback.navigateToRoomMemberDetails(userId)
+    }
+
    override fun navigateToThread(threadRootId: ThreadId, focusedEventId: EventId?) {
        callback.navigateToThread(threadRootId, focusedEventId)
    }

+    override fun navigateToDeveloperSettings() {
+        callback.navigateToDeveloperSettings()
+    }
+
    private fun displaySameRoomToast() {
        context.toast(CommonStrings.screen_room_permalink_same_room_android)
    }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesView.kt
@ -39,6 +39,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.shadow
 import androidx.compose.ui.graphics.RectangleShape
 import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.Role
@ -464,6 +465,9 @@ private fun MessagesViewContent(
            val scrollBehavior = PinnedMessagesBannerViewDefaults.rememberScrollBehavior(
                pinnedMessagesCount = (state.pinnedMessagesBannerState as? PinnedMessagesBannerState.Visible)?.pinnedMessagesCount() ?: 0,
            )
+            val density = LocalDensity.current
+            var pinnedBannerHeightDp by remember { mutableStateOf(0.dp) }
+
            TimelineView(
                state = state.timelineState,
                timelineProtectionState = state.timelineProtectionState,
@ -479,11 +483,13 @@ private fun MessagesViewContent(
                forceJumpToBottomVisibility = forceJumpToBottomVisibility,
                onJoinCallClick = onJoinCallClick,
                nestedScrollConnection = scrollBehavior.nestedScrollConnection,
+                floatingDateTopOffset = pinnedBannerHeightDp,
            )

            if (state.timelineState.timelineMode !is Timeline.Mode.Thread) {
                AnimatedVisibility(
                    visible = state.pinnedMessagesBannerState is PinnedMessagesBannerState.Visible && scrollBehavior.isVisible,
+                    modifier = Modifier.onSizeChanged { pinnedBannerHeightDp = with(density) { it.height.toDp() } },
                    enter = expandVertically(),
                    exit = shrinkVertically(),
                ) {
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerEvent.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerEvent.kt
@ -36,4 +36,5 @@ sealed interface MessageComposerEvent {
    data class SuggestionReceived(val suggestion: Suggestion?) : MessageComposerEvent
    data class InsertSuggestion(val resolvedSuggestion: ResolvedSuggestion) : MessageComposerEvent
    data object SaveDraft : MessageComposerEvent
+    data object ClearSlashError : MessageComposerEvent
 }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerPresenter.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerPresenter.kt
@ -15,6 +15,7 @@ import androidx.annotation.VisibleForTesting
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateListOf
@ -33,12 +34,14 @@ import im.vector.app.features.analytics.plan.Interaction
 import io.element.android.features.location.api.LocationService
 import io.element.android.features.messages.impl.MessagesNavigator
 import io.element.android.features.messages.impl.attachments.Attachment
+import io.element.android.features.messages.impl.attachments.Attachment.Media
 import io.element.android.features.messages.impl.attachments.preview.error.sendAttachmentError
 import io.element.android.features.messages.impl.draft.ComposerDraftService
 import io.element.android.features.messages.impl.messagecomposer.suggestions.RoomAliasSuggestionsDataSource
 import io.element.android.features.messages.impl.messagecomposer.suggestions.SuggestionsProcessor
 import io.element.android.features.messages.impl.timeline.TimelineController
 import io.element.android.features.messages.impl.utils.TextPillificationHelper
+import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.core.extensions.runCatchingExceptions
 import io.element.android.libraries.core.mimetype.MimeTypes
@ -68,6 +71,9 @@ import io.element.android.libraries.permissions.api.PermissionsEvent
 import io.element.android.libraries.permissions.api.PermissionsPresenter
 import io.element.android.libraries.preferences.api.store.SessionPreferencesStore
 import io.element.android.libraries.push.api.notifications.conversations.NotificationConversationService
+import io.element.android.libraries.slashcommands.api.SlashCommand
+import io.element.android.libraries.slashcommands.api.SlashCommandService
+import io.element.android.libraries.slashcommands.api.message
 import io.element.android.libraries.textcomposer.mentions.MentionSpanProvider
 import io.element.android.libraries.textcomposer.mentions.ResolvedSuggestion
 import io.element.android.libraries.textcomposer.model.MarkdownTextEditorState
@ -104,6 +110,7 @@ import io.element.android.libraries.core.mimetype.MimeTypes.Any as AnyMimeTypes
 class MessageComposerPresenter(
    @Assisted private val navigator: MessagesNavigator,
    @Assisted private val timelineController: TimelineController,
+    @Assisted private val isInThread: Boolean,
    @SessionCoroutineScope private val sessionCoroutineScope: CoroutineScope,
    private val room: JoinedRoom,
    private val mediaPickerProvider: PickerProvider,
@ -125,10 +132,15 @@ class MessageComposerPresenter(
    private val suggestionsProcessor: SuggestionsProcessor,
    private val mediaOptimizationConfigProvider: MediaOptimizationConfigProvider,
    private val notificationConversationService: NotificationConversationService,
+    private val slashCommandService: SlashCommandService,
 ) : Presenter<MessageComposerState> {
    @AssistedFactory
    interface Factory {
-        fun create(timelineController: TimelineController, navigator: MessagesNavigator): MessageComposerPresenter
+        fun create(
+            timelineController: TimelineController,
+            navigator: MessagesNavigator,
+            isInThread: Boolean,
+        ): MessageComposerPresenter
    }

    private val mediaSender = mediaSenderFactory.create(timelineMode = timelineController.mainTimelineMode())
@ -218,6 +230,8 @@ class MessageComposerPresenter(
            }
        )

+        val slashCommandAction = remember { mutableStateOf<AsyncAction<Unit>>(AsyncAction.Uninitialized) }
+
        LaunchedEffect(Unit) {
            val draft = draftService.loadDraft(
                roomId = room.roomId,
@ -246,12 +260,13 @@ class MessageComposerPresenter(
                    sessionCoroutineScope.sendMessage(
                        markdownTextEditorState = markdownTextEditorState,
                        richTextEditorState = richTextEditorState,
+                        slashCommandAction = slashCommandAction,
                    )
                }
                is MessageComposerEvent.SendUri -> {
                    val inReplyToEventId = (messageComposerContext.composerMode as? MessageComposerMode.Reply)?.eventId
                    sessionCoroutineScope.sendAttachment(
-                        attachment = Attachment.Media(
+                        attachment = Media(
                            localMedia = localMediaFactory.createFromUri(
                                uri = event.uri,
                                mimeType = null,
@ -340,6 +355,9 @@ class MessageComposerPresenter(
                                    val link = permalinkBuilder.permalinkForRoomAlias(suggestion.roomAlias).getOrNull() ?: return@launch
                                    richTextEditorState.insertMentionAtSuggestion(text = text, link = link)
                                }
+                                is ResolvedSuggestion.Command -> {
+                                    richTextEditorState.replaceSuggestion(suggestion.command.command)
+                                }
                            }
                        } else if (markdownTextEditorState.currentSuggestion != null) {
                            markdownTextEditorState.insertSuggestion(
@ -354,6 +372,9 @@ class MessageComposerPresenter(
                    val draft = createDraftFromState(markdownTextEditorState, richTextEditorState)
                    sessionCoroutineScope.updateDraft(draft, isVolatile = false)
                }
+                MessageComposerEvent.ClearSlashError -> {
+                    slashCommandAction.value = AsyncAction.Uninitialized
+                }
            }
        }

@ -385,6 +406,7 @@ class MessageComposerPresenter(
            suggestions = suggestions.toImmutableList(),
            resolveMentionDisplay = resolveMentionDisplay,
            resolveAtRoomMentionDisplay = resolveAtRoomMentionDisplay,
+            slashCommandAction = slashCommandAction.value,
            eventSink = ::handleEvent,
        )
    }
@ -422,6 +444,7 @@ class MessageComposerPresenter(
                    roomAliasSuggestions = roomAliasSuggestions,
                    currentUserId = currentUserId,
                    canSendRoomMention = ::canSendRoomMention,
+                    isInThread = isInThread,
                )
                suggestions.clear()
                suggestions.addAll(result)
@ -433,9 +456,69 @@ class MessageComposerPresenter(
    private fun CoroutineScope.sendMessage(
        markdownTextEditorState: MarkdownTextEditorState,
        richTextEditorState: RichTextEditorState,
+        slashCommandAction: MutableState<AsyncAction<Unit>>,
    ) = launch {
        val message = currentComposerMessage(markdownTextEditorState, richTextEditorState, withMentions = true)
        val capturedMode = messageComposerContext.composerMode
+
+        val slashCommand = if (capturedMode is MessageComposerMode.Normal) {
+            slashCommandService.parse(
+                textMessage = message.markdown,
+                formattedMessage = message.html,
+                isInThreadTimeline = isInThread,
+            )
+        } else {
+            SlashCommand.NotACommand
+        }
+
+        when (slashCommand) {
+            is SlashCommand.NotACommand -> Unit
+            is SlashCommand.Error -> {
+                slashCommandAction.value = AsyncAction.Failure(Exception(slashCommand.message()))
+                return@launch
+            }
+            is SlashCommand.SlashCommandNavigation -> {
+                when (slashCommand) {
+                    is SlashCommand.ShowUser -> {
+                        navigator.navigateToMember(slashCommand.userId)
+                    }
+                    SlashCommand.DevTools -> {
+                        navigator.navigateToDeveloperSettings()
+                    }
+                }
+                resetComposer(markdownTextEditorState, richTextEditorState, fromEdit = capturedMode is MessageComposerMode.Edit)
+                return@launch
+            }
+            is SlashCommand.SlashCommandSendMessage -> {
+                timelineController.invokeOnCurrentTimeline {
+                    slashCommandService.proceedSendMessage(slashCommand, this)
+                        .onFailure { cause ->
+                            Timber.e(cause, "Failed to proceed with admin slash command")
+                            slashCommandAction.value = AsyncAction.Failure(cause)
+                        }
+                        .onSuccess {
+                            // Reset composer
+                            resetComposer(markdownTextEditorState, richTextEditorState, fromEdit = capturedMode is MessageComposerMode.Edit)
+                        }
+                }
+                return@launch
+            }
+            is SlashCommand.SlashCommandAdmin -> {
+                slashCommandAction.value = AsyncAction.Loading
+                slashCommandService.proceedAdmin(slashCommand)
+                    .onFailure { cause ->
+                        Timber.e(cause, "Failed to proceed with admin slash command")
+                        slashCommandAction.value = AsyncAction.Failure(cause)
+                    }
+                    .onSuccess {
+                        // Reset composer
+                        resetComposer(markdownTextEditorState, richTextEditorState, fromEdit = capturedMode is MessageComposerMode.Edit)
+                        slashCommandAction.value = AsyncAction.Uninitialized
+                    }
+                return@launch
+            }
+        }
+
        // Reset composer right away
        resetComposer(markdownTextEditorState, richTextEditorState, fromEdit = capturedMode is MessageComposerMode.Edit)
        when (capturedMode) {
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerState.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerState.kt
@ -9,6 +9,7 @@
 package io.element.android.features.messages.impl.messagecomposer

 import androidx.compose.runtime.Stable
+import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.textcomposer.mentions.ResolvedSuggestion
 import io.element.android.libraries.textcomposer.model.MessageComposerMode
 import io.element.android.libraries.textcomposer.model.TextEditorState
@ -26,5 +27,6 @@ data class MessageComposerState(
    val suggestions: ImmutableList<ResolvedSuggestion>,
    val resolveMentionDisplay: (String, String) -> TextDisplay,
    val resolveAtRoomMentionDisplay: () -> TextDisplay,
+    val slashCommandAction: AsyncAction<Unit>,
    val eventSink: (MessageComposerEvent) -> Unit,
 )
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerStateProvider.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerStateProvider.kt
@ -9,6 +9,7 @@
 package io.element.android.features.messages.impl.messagecomposer

 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.textcomposer.mentions.ResolvedSuggestion
 import io.element.android.libraries.textcomposer.model.MessageComposerMode
 import io.element.android.libraries.textcomposer.model.TextEditorState
@ -32,6 +33,7 @@ fun aMessageComposerState(
    showAttachmentSourcePicker: Boolean = false,
    canShareLocation: Boolean = true,
    suggestions: ImmutableList<ResolvedSuggestion> = persistentListOf(),
+    slashCommandAction: AsyncAction<Unit> = AsyncAction.Uninitialized,
    eventSink: (MessageComposerEvent) -> Unit = {},
 ) = MessageComposerState(
    textEditorState = textEditorState,
@ -43,5 +45,6 @@ fun aMessageComposerState(
    suggestions = suggestions,
    resolveMentionDisplay = { _, _ -> TextDisplay.Plain },
    resolveAtRoomMentionDisplay = { TextDisplay.Plain },
+    slashCommandAction = slashCommandAction,
    eventSink = eventSink,
 )
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerView.kt
@ -22,6 +22,7 @@ import io.element.android.features.messages.api.timeline.voicemessages.composer.
 import io.element.android.features.messages.api.timeline.voicemessages.composer.VoiceMessageComposerState
 import io.element.android.features.messages.api.timeline.voicemessages.composer.VoiceMessageComposerStateProvider
 import io.element.android.features.messages.api.timeline.voicemessages.composer.aVoiceMessageComposerState
+import io.element.android.libraries.designsystem.components.async.AsyncActionView
 import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
 import io.element.android.libraries.textcomposer.TextComposer
@ -115,6 +116,12 @@ internal fun MessageComposerView(
        onTyping = ::onTyping,
        onSelectRichContent = ::sendUri,
    )
+
+    AsyncActionView(
+        async = state.slashCommandAction,
+        onSuccess = {},
+        onErrorDismiss = { state.eventSink(MessageComposerEvent.ClearSlashError) },
+    )
 }

@PreviewsDayNight
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/suggestions/SuggestionsPickerView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/suggestions/SuggestionsPickerView.kt
@ -29,6 +29,7 @@ import io.element.android.libraries.designsystem.components.avatar.Avatar
 import io.element.android.libraries.designsystem.components.avatar.AvatarData
 import io.element.android.libraries.designsystem.components.avatar.AvatarSize
 import io.element.android.libraries.designsystem.components.avatar.AvatarType
+import io.element.android.libraries.designsystem.components.avatar.AvatarType.Room
 import io.element.android.libraries.designsystem.components.avatar.anAvatarData
 import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
@ -40,6 +41,7 @@ import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.api.room.RoomMembershipState
 import io.element.android.libraries.matrix.ui.model.getAvatarData
+import io.element.android.libraries.slashcommands.api.SlashCommandSuggestion
 import io.element.android.libraries.textcomposer.mentions.ResolvedSuggestion
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
@ -63,6 +65,7 @@ fun SuggestionsPickerView(
                    is ResolvedSuggestion.AtRoom -> "@room"
                    is ResolvedSuggestion.Member -> suggestion.roomMember.userId.value
                    is ResolvedSuggestion.Alias -> suggestion.roomId.value
+                    is ResolvedSuggestion.Command -> suggestion.command.command
                }
            }
        ) {
@ -91,54 +94,81 @@ private fun SuggestionItemView(
    modifier: Modifier = Modifier,
 ) {
    Row(
-        modifier = modifier.clickable { onSelectSuggestion(suggestion) },
-        horizontalArrangement = Arrangement.spacedBy(16.dp),
+        modifier = modifier
+            .clickable { onSelectSuggestion(suggestion) }
+            .padding(horizontal = 16.dp),
    ) {
        val avatarSize = AvatarSize.Suggestion
        val avatarData = when (suggestion) {
            is ResolvedSuggestion.AtRoom -> roomAvatar?.copy(size = avatarSize) ?: AvatarData(roomId, roomName, null, avatarSize)
            is ResolvedSuggestion.Member -> suggestion.roomMember.getAvatarData(avatarSize)
            is ResolvedSuggestion.Alias -> suggestion.getAvatarData(avatarSize)
+            is ResolvedSuggestion.Command -> null
        }
        val avatarType = when (suggestion) {
-            is ResolvedSuggestion.Alias -> AvatarType.Room()
+            is ResolvedSuggestion.Alias -> Room()
            ResolvedSuggestion.AtRoom,
            is ResolvedSuggestion.Member -> AvatarType.User
+            is ResolvedSuggestion.Command -> null
        }
        val title = when (suggestion) {
            is ResolvedSuggestion.AtRoom -> stringResource(R.string.screen_room_mentions_at_room_title)
            is ResolvedSuggestion.Member -> suggestion.roomMember.displayName
            is ResolvedSuggestion.Alias -> suggestion.roomName
+            is ResolvedSuggestion.Command -> suggestion.command.command
+        }
+        val details = when (suggestion) {
+            is ResolvedSuggestion.AtRoom,
+            is ResolvedSuggestion.Member,
+            is ResolvedSuggestion.Alias -> null
+            is ResolvedSuggestion.Command -> suggestion.command.parameters
        }
        val subtitle = when (suggestion) {
            is ResolvedSuggestion.AtRoom -> "@room"
            is ResolvedSuggestion.Member -> suggestion.roomMember.userId.value
            is ResolvedSuggestion.Alias -> suggestion.roomAlias.value
+            is ResolvedSuggestion.Command -> suggestion.command.description
+        }
+        if (avatarData != null && avatarType != null) {
+            Avatar(
+                avatarData = avatarData,
+                avatarType = avatarType,
+                modifier = Modifier.padding(top = 12.dp, bottom = 12.dp, end = 16.dp),
+            )
        }
-        Avatar(
-            avatarData = avatarData,
-            avatarType = avatarType,
-            modifier = Modifier.padding(start = 16.dp, top = 12.dp, bottom = 12.dp),
-        )
        Column(
            modifier = Modifier
                .fillMaxWidth()
-                .padding(end = 16.dp, top = 8.dp, bottom = 8.dp)
+                .padding(top = 8.dp, bottom = 8.dp)
                .align(Alignment.CenterVertically),
        ) {
-            title?.let {
-                Text(
-                    text = it,
-                    style = ElementTheme.typography.fontBodyLgRegular,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis,
-                )
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(4.dp)
+            ) {
+                title?.let {
+                    Text(
+                        text = it,
+                        style = ElementTheme.typography.fontBodyLgRegular,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                    )
+                }
+                details?.let {
+                    Text(
+                        text = it,
+                        style = ElementTheme.typography.fontBodyMdRegular,
+                        maxLines = 1,
+                        color = ElementTheme.colors.textSecondary,
+                        overflow = TextOverflow.Ellipsis,
+                    )
+                }
            }
            Text(
                text = subtitle,
                style = ElementTheme.typography.fontBodySmRegular,
                color = ElementTheme.colors.textSecondary,
-                maxLines = 1,
+                maxLines = 2,
                overflow = TextOverflow.Ellipsis,
            )
        }
@ -174,7 +204,21 @@ internal fun SuggestionsPickerViewPreview() {
                    roomId = RoomId("!room:matrix.org"),
                    roomName = "My room",
                    roomAvatarUrl = null,
-                )
+                ),
+                ResolvedSuggestion.Command(
+                    command = SlashCommandSuggestion(
+                        command = "/noparam",
+                        parameters = null,
+                        description = "A slash command without parameters",
+                    )
+                ),
+                ResolvedSuggestion.Command(
+                    command = SlashCommandSuggestion(
+                        command = "/withparam",
+                        parameters = "<user-id> [reason]",
+                        description = "A slash command with parameters",
+                    )
+                ),
            ),
            onSelectSuggestion = {}
        )
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/suggestions/SuggestionsProcessor.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/suggestions/SuggestionsProcessor.kt
@ -15,6 +15,7 @@ import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.api.room.RoomMembersState
 import io.element.android.libraries.matrix.api.room.RoomMembershipState
 import io.element.android.libraries.matrix.api.room.roomMembers
+import io.element.android.libraries.slashcommands.api.SlashCommandService
 import io.element.android.libraries.textcomposer.mentions.ResolvedSuggestion
 import io.element.android.libraries.textcomposer.model.Suggestion
 import io.element.android.libraries.textcomposer.model.SuggestionType
@ -23,7 +24,9 @@ import io.element.android.libraries.textcomposer.model.SuggestionType
 * This class is responsible for processing suggestions when `@`, `/` or `#` are type in the composer.
 */
@Inject
-class SuggestionsProcessor {
+class SuggestionsProcessor(
+    private val slashCommandService: SlashCommandService,
+) {
    /**
     *  Process the suggestion.
     *  @param suggestion The current suggestion input
@ -31,6 +34,7 @@ class SuggestionsProcessor {
     *  @param roomAliasSuggestions The available room alias suggestions
     *  @param currentUserId The current user id
     *  @param canSendRoomMention Should return true if the current user can send room mentions
+     *  @param isInThread Whether the composer is in a thread or not, used to filter slash commands suggestions
     *  @return The list of suggestions to display
     */
    suspend fun process(
@ -39,6 +43,7 @@ class SuggestionsProcessor {
        roomAliasSuggestions: List<RoomAliasSuggestion>,
        currentUserId: UserId,
        canSendRoomMention: suspend () -> Boolean,
+        isInThread: Boolean,
    ): List<ResolvedSuggestion> {
        suggestion ?: return emptyList()
        return when (suggestion.type) {
@ -69,7 +74,16 @@ class SuggestionsProcessor {
                        )
                    }
            }
-            SuggestionType.Command,
+            SuggestionType.Command -> {
+                // Command suggestions are valid only if this is the beginning of the message
+                if (suggestion.start == 0) {
+                    slashCommandService.getSuggestions(suggestion.text, isInThread).map {
+                        ResolvedSuggestion.Command(it)
+                    }
+                } else {
+                    emptyList()
+                }
+            }
            SuggestionType.Emoji,
            is SuggestionType.Custom -> {
                // Clear suggestions
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/threads/ThreadedMessagesNode.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/threads/ThreadedMessagesNode.kt
@ -112,7 +112,7 @@ class ThreadedMessagesNode(
        this.timelineController = timelineController
        return presenterFactory.create(
            navigator = this,
-            composerPresenter = messageComposerPresenterFactory.create(timelineController, this),
+            composerPresenter = messageComposerPresenterFactory.create(timelineController, this, isInThread = true),
            timelinePresenter = timelinePresenterFactory.create(timelineController = timelineController, this),
            // TODO add special processor for threaded timeline
            actionListPresenter = actionListPresenterFactory.create(
@ -136,6 +136,7 @@ class ThreadedMessagesNode(
        fun navigateToEditPoll(eventId: EventId)
        fun navigateToRoomCall(roomId: RoomId, isAudioCall: Boolean)
        fun navigateToThread(threadRootId: ThreadId, focusedEventId: EventId?)
+        fun navigateToDeveloperSettings()
    }

    override fun onBuilt() {
@ -233,10 +234,18 @@ class ThreadedMessagesNode(
        callback.handlePermalinkClick(permalinkData)
    }

+    override fun navigateToMember(userId: UserId) {
+        callback.navigateToRoomMemberDetails(userId)
+    }
+
    override fun navigateToThread(threadRootId: ThreadId, focusedEventId: EventId?) {
        callback.navigateToThread(threadRootId, focusedEventId)
    }

+    override fun navigateToDeveloperSettings() {
+        callback.navigateToDeveloperSettings()
+    }
+
    override fun close() = navigateUp()

    @Composable
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelinePresenter.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelinePresenter.kt
@ -149,6 +149,9 @@ class TimelinePresenter(
        val displayThreadSummaries by produceState(false) {
            value = featureFlagService.isFeatureEnabled(FeatureFlags.Threads)
        }
+        val displayFloatingDateBadge by produceState(false) {
+            value = featureFlagService.isFeatureEnabled(FeatureFlags.FloatingDateBadge)
+        }

        fun handleEvent(event: TimelineEvent) {
            when (event) {
@ -315,6 +318,7 @@ class TimelinePresenter(
            messageShieldDialogData = messageShieldDialogData.value,
            resolveVerifiedUserSendFailureState = resolveVerifiedUserSendFailureState,
            displayThreadSummaries = displayThreadSummaries,
+            displayFloatingDateBadge = displayFloatingDateBadge,
            eventSink = ::handleEvent,
        )
    }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineState.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineState.kt
@ -34,6 +34,7 @@ data class TimelineState(
    val messageShieldDialogData: MessageShieldData?,
    val resolveVerifiedUserSendFailureState: ResolveVerifiedUserSendFailureState,
    val displayThreadSummaries: Boolean,
+    val displayFloatingDateBadge: Boolean,
    val eventSink: (TimelineEvent) -> Unit,
 ) {
    private val lastTimelineEvent = timelineItems.firstOrNull { it is TimelineItem.Event } as? TimelineItem.Event
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineStateProvider.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineStateProvider.kt
@ -56,6 +56,7 @@ fun aTimelineState(
    messageShield: MessageShield? = null,
    resolveVerifiedUserSendFailureState: ResolveVerifiedUserSendFailureState = aResolveVerifiedUserSendFailureState(),
    displayThreadSummaries: Boolean = false,
+    displayFloatingDateBadge: Boolean = false,
    eventSink: (TimelineEvent) -> Unit = {},
 ): TimelineState {
    val focusedEventId = timelineItems.filterIsInstance<TimelineItem.Event>().getOrNull(focusedEventIndex)?.eventId
@ -75,6 +76,7 @@ fun aTimelineState(
        messageShieldDialogData = messageShield?.let { MessageShieldData(it) },
        resolveVerifiedUserSendFailureState = resolveVerifiedUserSendFailureState,
        displayThreadSummaries = displayThreadSummaries,
+        displayFloatingDateBadge = displayFloatingDateBadge,
        eventSink = eventSink,
    )
 }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineView.kt
@ -47,10 +47,12 @@ import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.platform.rememberNestedScrollInteropConnection
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import io.element.android.compound.theme.ElementTheme
 import io.element.android.compound.tokens.generated.CompoundIcons
 import io.element.android.features.messages.impl.crypto.sendfailure.resolve.ResolveVerifiedUserSendFailureView
+import io.element.android.features.messages.impl.timeline.components.FloatingDateBadgeOverlay
 import io.element.android.features.messages.impl.timeline.components.TimelineItemRow
 import io.element.android.features.messages.impl.timeline.components.toText
 import io.element.android.features.messages.impl.timeline.di.LocalTimelineItemPresenterFactories
@ -105,6 +107,7 @@ fun TimelineView(
    lazyListState: LazyListState = rememberLazyListState(),
    forceJumpToBottomVisibility: Boolean = false,
    nestedScrollConnection: NestedScrollConnection = rememberNestedScrollInteropConnection(),
+    floatingDateTopOffset: Dp = 0.dp,
 ) {
    fun clearFocusRequestState() {
        state.eventSink(TimelineEvent.ClearFocusRequestState)
@ -210,6 +213,15 @@ fun TimelineView(
                onJumpToLive = ::onJumpToLive,
                onFocusEventRender = ::onFocusEventRender,
            )
+
+            if (state.displayFloatingDateBadge && useReverseLayout) {
+                FloatingDateBadgeOverlay(
+                    lazyListState = lazyListState,
+                    timelineItems = state.timelineItems,
+                    isLive = state.isLive,
+                    topOffset = floatingDateTopOffset,
+                )
+            }
        }
    }

--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/FloatingDateBadge.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/FloatingDateBadge.kt
@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.messages.impl.timeline.components
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import io.element.android.compound.theme.ElementTheme
+import io.element.android.features.messages.impl.timeline.model.TimelineItem
+import io.element.android.features.messages.impl.timeline.model.virtual.TimelineItemDaySeparatorModel
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.designsystem.theme.components.Surface
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.designsystem.theme.floatingDateBadgeBackground
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.collectLatest
+import kotlin.time.Duration.Companion.milliseconds
+
+@Composable
+internal fun BoxScope.FloatingDateBadgeOverlay(
+    lazyListState: LazyListState,
+    timelineItems: ImmutableList<TimelineItem>,
+    isLive: Boolean,
+    topOffset: Dp = 0.dp,
+) {
+    // This needs to be a state to trigger a `derivedState` recalculation
+    val updatedTimelineItems by rememberUpdatedState(timelineItems)
+
+    // Look for the last visible item with a timestamp, starting from the last visible item and going backwards until we find one or reach the start of the list
+    val lastVisibleItemWithTimestamp by remember {
+        derivedStateOf {
+            var index = lazyListState.layoutInfo.visibleItemsInfo.lastOrNull()?.index ?: return@derivedStateOf null
+            while (index >= 0) {
+                when (val item = updatedTimelineItems.getOrNull(index)) {
+                    is TimelineItem.Event -> return@derivedStateOf item
+                    is TimelineItem.Virtual -> if (item.model is TimelineItemDaySeparatorModel) return@derivedStateOf item
+                    is TimelineItem.GroupedEvents -> return@derivedStateOf item.events.firstOrNull()
+                    null -> Unit
+                }
+                index--
+            }
+            null
+        }
+    }
+
+    // Store the formatted date so we recompute it lazily and can keep it around even if we need to dispose the badge because the timeline items changed
+    var formattedDate: String? by remember { mutableStateOf(null) }
+    // Update the formatted date when we have a new non-null timestamp
+    LaunchedEffect(lastVisibleItemWithTimestamp) {
+        lastVisibleItemWithTimestamp?.formattedDate()?.let { formattedDate = it }
+    }
+
+    val isAtBottom by remember {
+        derivedStateOf {
+            lazyListState.firstVisibleItemIndex < 3 && isLive
+        }
+    }
+
+    var isBadgeVisible by remember { mutableStateOf(false) }
+
+    LaunchedEffect(Unit) {
+        snapshotFlow { lazyListState.isScrollInProgress }
+            .collectLatest { isScrolling ->
+                if (isScrolling) {
+                    isBadgeVisible = true
+                } else {
+                    delay(2000.milliseconds)
+                    isBadgeVisible = false
+                }
+            }
+    }
+
+    val showBadge = isBadgeVisible && !isAtBottom && formattedDate != null
+
+    AnimatedVisibility(
+        visible = showBadge,
+        modifier = Modifier
+            .align(Alignment.TopCenter)
+            .padding(top = 8.dp + topOffset),
+        enter = fadeIn(animationSpec = tween(150)),
+        exit = fadeOut(animationSpec = tween(300)),
+    ) {
+        formattedDate?.let { dateText ->
+            FloatingDateBadge(
+                modifier = Modifier.padding(8.dp),
+                dateText = dateText,
+            )
+        }
+    }
+}
+
+@Composable
+internal fun FloatingDateBadge(
+    dateText: String,
+    modifier: Modifier = Modifier,
+) {
+    Surface(
+        modifier = modifier,
+        shape = RoundedCornerShape(16.dp),
+        color = ElementTheme.colors.floatingDateBadgeBackground,
+        shadowElevation = 4.dp,
+    ) {
+        Text(
+            modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
+            text = dateText,
+            style = ElementTheme.typography.fontBodyMdMedium,
+            color = ElementTheme.colors.textPrimary,
+        )
+    }
+}
+
+@PreviewsDayNight
+@Composable
+internal fun FloatingDateBadgePreview() = ElementPreview {
+    Box(modifier = Modifier.padding(16.dp)) {
+        FloatingDateBadge(dateText = "March 9, 2026")
+    }
+}
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemEventFactory.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemEventFactory.kt
@ -66,6 +66,11 @@ class TimelineItemEventFactory(
            timestamp = currentTimelineItem.event.timestamp,
            mode = DateFormatterMode.TimeOnly,
        )
+        val sentDate = dateFormatter.format(
+            timestamp = currentTimelineItem.event.timestamp,
+            mode = DateFormatterMode.Day,
+            useRelative = true,
+        )
        val senderAvatarData = AvatarData(
            id = currentSender.value,
            name = senderProfile.getDisambiguatedDisplayName(currentSender),
@ -108,6 +113,7 @@ class TimelineItemEventFactory(
            canBeRepliedTo = currentTimelineItem.event.canBeRepliedTo,
            sentTimeMillis = currentTimelineItem.event.timestamp,
            sentTime = sentTime,
+            sentDate = sentDate,
            groupPosition = groupPosition,
            reactionsState = currentTimelineItem.computeReactionsState(),
            readReceiptState = currentTimelineItem.computeReadReceiptState(roomMembers),
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/TimelineItem.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/TimelineItem.kt
@ -15,6 +15,7 @@ import io.element.android.features.messages.impl.timeline.model.event.TimelineIt
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemStickerContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemTextBasedContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVideoContent
+import io.element.android.features.messages.impl.timeline.model.virtual.TimelineItemDaySeparatorModel
 import io.element.android.features.messages.impl.timeline.model.virtual.TimelineItemVirtualModel
 import io.element.android.libraries.designsystem.components.avatar.AvatarData
 import io.element.android.libraries.matrix.api.core.EventId
@ -59,6 +60,12 @@ sealed interface TimelineItem {
        is GroupedEvents -> "groupedEvent"
    }

+    fun formattedDate(): String? = when (this) {
+        is Event -> sentDate.takeIf { it.isNotEmpty() }
+        is Virtual -> (model as? TimelineItemDaySeparatorModel)?.formattedDate?.takeIf { it.isNotEmpty() }
+        is GroupedEvents -> null
+    }
+
    data class Virtual(
        val id: UniqueId,
        val model: TimelineItemVirtualModel
@ -75,6 +82,7 @@ sealed interface TimelineItem {
        val content: TimelineItemEventContent,
        val sentTimeMillis: Long = 0L,
        val sentTime: String = "",
+        val sentDate: String = "",
        val isMine: Boolean = false,
        val isEditable: Boolean,
        val canBeRepliedTo: Boolean,