Merge remote-tracking branch 'origin/develop' into feature/cjs/view-location-in-timeline

2023-06-30 09:30:31 +01:00 · 2023-06-30 09:30:31 +01:00 · 005b22391f
commit 005b22391f
parent 9ec800ad89 a2a5d251d1
454 changed files with 2400 additions and 1234 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
@ -29,6 +29,7 @@ import com.bumble.appyx.navmodel.backstack.operation.push
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.location.api.SendLocationEntryPoint
 import io.element.android.features.messages.api.MessagesEntryPoint
 import io.element.android.features.messages.impl.attachments.Attachment
 import io.element.android.features.messages.impl.attachments.preview.AttachmentsPreviewNode
@ -57,6 +58,7 @@ import kotlinx.parcelize.Parcelize
 class MessagesFlowNode @AssistedInject constructor(
    @Assisted buildContext: BuildContext,
    @Assisted plugins: List<Plugin>,
+    private val sendLocationEntryPoint: SendLocationEntryPoint,
 ) : BackstackNode<MessagesFlowNode.NavTarget>(
    backstack = BackStack(
        initialElement = NavTarget.Messages,
@ -88,6 +90,9 @@ class MessagesFlowNode @AssistedInject constructor(

        @Parcelize
        data class ReportMessage(val eventId: EventId, val senderId: UserId) : NavTarget
+
+        @Parcelize
+        object SendLocation : NavTarget
    }

    private val callback = plugins<MessagesEntryPoint.Callback>().firstOrNull()
@ -123,6 +128,10 @@ class MessagesFlowNode @AssistedInject constructor(
                    override fun onReportMessage(eventId: EventId, senderId: UserId) {
                        backstack.push(NavTarget.ReportMessage(eventId, senderId))
                    }
+
+                    override fun onSendLocationClicked() {
+                        backstack.push(NavTarget.SendLocation)
+                    }
                }
                createNode<MessagesNode>(buildContext, listOf(callback))
            }
@ -155,6 +164,9 @@ class MessagesFlowNode @AssistedInject constructor(
                val inputs = ReportMessageNode.Inputs(navTarget.eventId, navTarget.senderId)
                createNode<ReportMessageNode>(buildContext, listOf(inputs))
            }
+            NavTarget.SendLocation -> {
+                sendLocationEntryPoint.createNode(this, buildContext)
+            }
        }
    }

--- 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
@ -57,6 +57,7 @@ class MessagesNode @AssistedInject constructor(
        fun onShowEventDebugInfoClicked(eventId: EventId, debugInfo: TimelineItemDebugInfo)
        fun onForwardEventClicked(eventId: EventId)
        fun onReportMessage(eventId: EventId, senderId: UserId)
+        fun onSendLocationClicked()
    }

    init {
@ -93,6 +94,10 @@ class MessagesNode @AssistedInject constructor(
    override fun onReportContentClicked(eventId: EventId, senderId: UserId) {
        callback?.onReportMessage(eventId, senderId)
    }
+    
+    private fun onSendLocationClicked() {
+        callback?.onSendLocationClicked()
+    }

    @Composable
    override fun View(modifier: Modifier) {
@ -104,6 +109,7 @@ class MessagesNode @AssistedInject constructor(
            onEventClicked = this::onEventClicked,
            onPreviewAttachments = this::onPreviewAttachments,
            onUserDataClicked = this::onUserDataClicked,
+            onSendLocationClicked = this::onSendLocationClicked,
            modifier = modifier,
        )
    }
--- 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
@ -65,6 +65,7 @@ import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.features.networkmonitor.api.ui.ConnectivityIndicatorView
 import io.element.android.libraries.androidutils.ui.hideKeyboard
 import io.element.android.libraries.designsystem.components.ProgressDialog
+import io.element.android.libraries.designsystem.components.ProgressDialogType
 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.button.BackButton
@ -91,6 +92,7 @@ fun MessagesView(
    onEventClicked: (event: TimelineItem.Event) -> Unit,
    onUserDataClicked: (UserId) -> Unit,
    onPreviewAttachments: (ImmutableList<Attachment>) -> Unit,
+    onSendLocationClicked: () -> Unit,
    modifier: Modifier = Modifier,
 ) {
    LogCompositions(tag = "MessagesScreen", msg = "Root")
@ -152,7 +154,8 @@ fun MessagesView(
                        state.retrySendMenuState.eventSink(RetrySendMenuEvents.EventSelected(event))
                    }
                },
-                onReactionClicked = ::onEmojiReactionClicked
+                onReactionClicked = ::onEmojiReactionClicked,
+                onSendLocationClicked = onSendLocationClicked,
            )
        },
        snackbarHost = {
@ -216,7 +219,15 @@ private fun AttachmentStateView(
        is AttachmentsState.Previewing -> LaunchedEffect(state) {
            onPreviewAttachments(state.attachments)
        }
-        is AttachmentsState.Sending -> ProgressDialog(text = stringResource(id = CommonStrings.common_loading))
+        is AttachmentsState.Sending -> {
+            ProgressDialog(
+                type = when (state) {
+                    is AttachmentsState.Sending.Uploading -> ProgressDialogType.Determinate(state.progress)
+                    is AttachmentsState.Sending.Processing -> ProgressDialogType.Indeterminate
+                },
+                text = stringResource(id = CommonStrings.common_sending)
+            )
+        }
    }
 }

@ -228,6 +239,7 @@ fun MessagesViewContent(
    onReactionClicked: (key: String, TimelineItem.Event) -> Unit,
    onMessageLongClicked: (TimelineItem.Event) -> Unit,
    onTimestampClicked: (TimelineItem.Event) -> Unit,
+    onSendLocationClicked: () -> Unit,
    modifier: Modifier = Modifier,
 ) {
    Column(
@ -251,6 +263,7 @@ fun MessagesViewContent(
        if (state.userHasPermissionToSendMessage) {
            MessageComposerView(
                state = state.composerState,
+                onSendLocationClicked = onSendLocationClicked,
                modifier = Modifier
                    .fillMaxWidth()
                    .wrapContentHeight(Alignment.Bottom)
@ -338,5 +351,6 @@ private fun ContentToPreview(state: MessagesState) {
        onEventClicked = {},
        onPreviewAttachments = {},
        onUserDataClicked = {},
+        onSendLocationClicked = {},
    )
 }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/actionlist/ActionListView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/actionlist/ActionListView.kt
@ -39,7 +39,6 @@ import androidx.compose.material.icons.outlined.AddReaction
 import androidx.compose.material.ripple.rememberRipple
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.SheetState
 import androidx.compose.material3.rememberModalBottomSheetState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
@ -48,6 +47,7 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
@ -87,8 +87,8 @@ fun ActionListView(
    onEmojiReactionClicked: (String, TimelineItem.Event) -> Unit,
    onCustomReactionClicked: (TimelineItem.Event) -> Unit,
    modifier: Modifier = Modifier,
-    sheetState: SheetState = rememberModalBottomSheetState()
 ) {
+    val sheetState = rememberModalBottomSheetState()
    val coroutineScope = rememberCoroutineScope()
    val targetItem = (state.target as? ActionListState.Target.Success)?.event

@ -119,22 +119,21 @@ fun ActionListView(
    }

    fun onDismiss() {
-        sheetState.hide(coroutineScope) {
-            state.eventSink(ActionListEvents.Clear)
-        }
+        state.eventSink(ActionListEvents.Clear)
    }

    if (targetItem != null) {
        ModalBottomSheet(
            sheetState = sheetState,
            onDismissRequest = ::onDismiss,
+            modifier = modifier,
        ) {
            SheetContent(
                state = state,
                onActionClicked = ::onItemActionClicked,
                onEmojiReactionClicked = ::onEmojiReactionClicked,
                onCustomReactionClicked = ::onCustomReactionClicked,
-                modifier = modifier
+                modifier = Modifier
                    .padding(bottom = 32.dp)
 //                    .navigationBarsPadding() - FIXME after https://issuetracker.google.com/issues/275849044
 //                    .imePadding()
@ -192,7 +191,7 @@ private fun SheetContent(
                        },
                        text = {
                            Text(
-                                text = action.title,
+                                text = stringResource(id = action.titleRes),
                                color = if (action.destructive) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.primary,
                            )
                        },
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/actionlist/model/TimelineItemAction.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/actionlist/model/TimelineItemAction.kt
@ -17,20 +17,22 @@
 package io.element.android.features.messages.impl.actionlist.model

 import androidx.annotation.DrawableRes
+import androidx.annotation.StringRes
 import androidx.compose.runtime.Immutable
 import io.element.android.libraries.designsystem.VectorIcons
+import io.element.android.libraries.ui.strings.CommonStrings

@Immutable
 sealed class TimelineItemAction(
-    val title: String,
+    @StringRes val titleRes: Int,
    @DrawableRes val icon: Int,
    val destructive: Boolean = false
 ) {
-    object Forward : TimelineItemAction("Forward", VectorIcons.Forward)
-    object Copy : TimelineItemAction("Copy", VectorIcons.Copy)
-    object Redact : TimelineItemAction("Redact", VectorIcons.Delete, destructive = true)
-    object Reply : TimelineItemAction("Reply", VectorIcons.Reply)
-    object Edit : TimelineItemAction("Edit", VectorIcons.Edit)
-    object Developer : TimelineItemAction("Developer", VectorIcons.DeveloperMode)
-    object ReportContent : TimelineItemAction("Report content", VectorIcons.ReportContent, destructive = true)
+    object Forward : TimelineItemAction(CommonStrings.action_forward, VectorIcons.Forward)
+    object Copy : TimelineItemAction(CommonStrings.action_copy, VectorIcons.Copy)
+    object Redact : TimelineItemAction(CommonStrings.action_remove, VectorIcons.Delete, destructive = true)
+    object Reply : TimelineItemAction(CommonStrings.action_reply, VectorIcons.Reply)
+    object Edit : TimelineItemAction(CommonStrings.action_edit, VectorIcons.Edit)
+    object Developer : TimelineItemAction(CommonStrings.action_view_source, VectorIcons.DeveloperMode)
+    object ReportContent : TimelineItemAction(CommonStrings.action_report_content, VectorIcons.ReportContent, destructive = true)
 }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewPresenter.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewPresenter.kt
@ -25,9 +25,8 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import io.element.android.features.messages.impl.attachments.Attachment
-import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.architecture.Presenter
-import io.element.android.libraries.architecture.runUpdatingState
+import io.element.android.libraries.matrix.api.core.ProgressCallback
 import io.element.android.libraries.mediaupload.api.MediaSender
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
@ -48,13 +47,13 @@ class AttachmentsPreviewPresenter @AssistedInject constructor(
        val coroutineScope = rememberCoroutineScope()

        val sendActionState = remember {
-            mutableStateOf<Async<Unit>>(Async.Uninitialized)
+            mutableStateOf<SendActionState>(SendActionState.Idle)
        }

        fun handleEvents(attachmentsPreviewEvents: AttachmentsPreviewEvents) {
            when (attachmentsPreviewEvents) {
                AttachmentsPreviewEvents.SendAttachment -> coroutineScope.sendAttachment(attachment, sendActionState)
-                AttachmentsPreviewEvents.ClearSendState -> sendActionState.value = Async.Uninitialized
+                AttachmentsPreviewEvents.ClearSendState -> sendActionState.value = SendActionState.Idle
            }
        }

@ -67,7 +66,7 @@ class AttachmentsPreviewPresenter @AssistedInject constructor(

    private fun CoroutineScope.sendAttachment(
        attachment: Attachment,
-        sendActionState: MutableState<Async<Unit>>,
+        sendActionState: MutableState<SendActionState>,
    ) = launch {
        when (attachment) {
            is Attachment.Media -> {
@ -81,10 +80,26 @@ class AttachmentsPreviewPresenter @AssistedInject constructor(

    private suspend fun sendMedia(
        mediaAttachment: Attachment.Media,
-        sendActionState: MutableState<Async<Unit>>,
+        sendActionState: MutableState<SendActionState>,
    ) {
-        sendActionState.runUpdatingState {
-            mediaSender.sendMedia(mediaAttachment.localMedia.uri, mediaAttachment.localMedia.info.mimeType, mediaAttachment.compressIfPossible)
+        val progressCallback = object : ProgressCallback {
+            override fun onProgress(current: Long, total: Long) {
+                sendActionState.value = SendActionState.Sending.Uploading(current.toFloat() / total.toFloat())
+            }
        }
+        sendActionState.value = SendActionState.Sending.Processing
+        mediaSender.sendMedia(
+            uri = mediaAttachment.localMedia.uri,
+            mimeType = mediaAttachment.localMedia.info.mimeType,
+            compressIfPossible = mediaAttachment.compressIfPossible,
+            progressCallback = progressCallback
+        ).fold(
+            onSuccess = {
+                sendActionState.value = SendActionState.Done
+            },
+            onFailure = {
+                sendActionState.value = SendActionState.Failure(it)
+            }
+        )
    }
 }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewState.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewState.kt
@ -17,10 +17,21 @@
 package io.element.android.features.messages.impl.attachments.preview

 import io.element.android.features.messages.impl.attachments.Attachment
-import io.element.android.libraries.architecture.Async

 data class AttachmentsPreviewState(
    val attachment: Attachment,
-    val sendActionState: Async<Unit>,
+    val sendActionState: SendActionState,
    val eventSink: (AttachmentsPreviewEvents) -> Unit
 )
+
+sealed interface SendActionState {
+    object Idle : SendActionState
+    sealed interface Sending : SendActionState {
+        object Processing : Sending
+        data class Uploading(val progress: Float) : Sending
+    }
+
+    data class Failure(val error: Throwable) : SendActionState
+    object Done : SendActionState
+}
+
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewStateProvider.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewStateProvider.kt
@ -22,23 +22,21 @@ import io.element.android.features.messages.impl.attachments.Attachment
 import io.element.android.features.messages.impl.media.local.LocalMedia
 import io.element.android.features.messages.impl.media.local.MediaInfo
 import io.element.android.features.messages.impl.media.local.aFileInfo
-import io.element.android.features.messages.impl.media.local.aVideoInfo
 import io.element.android.features.messages.impl.media.local.anImageInfo
-import io.element.android.libraries.architecture.Async

 open class AttachmentsPreviewStateProvider : PreviewParameterProvider<AttachmentsPreviewState> {
    override val values: Sequence<AttachmentsPreviewState>
        get() = sequenceOf(
            anAttachmentsPreviewState(),
            anAttachmentsPreviewState(mediaInfo = aFileInfo()),
-            anAttachmentsPreviewState(sendActionState = Async.Loading()),
-            anAttachmentsPreviewState(sendActionState = Async.Failure(RuntimeException())),
+            anAttachmentsPreviewState(sendActionState = SendActionState.Sending.Uploading(0.5f)),
+            anAttachmentsPreviewState(sendActionState = SendActionState.Failure(RuntimeException())),
        )
 }

 fun anAttachmentsPreviewState(
    mediaInfo: MediaInfo = anImageInfo(),
-    sendActionState: Async<Unit> = Async.Uninitialized) = AttachmentsPreviewState(
+    sendActionState: SendActionState = SendActionState.Idle) = AttachmentsPreviewState(
    attachment = Attachment.Media(
        localMedia = LocalMedia("file://path".toUri(), mediaInfo),
        compressIfPossible = true
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/attachments/preview/AttachmentsPreviewView.kt
@ -33,9 +33,9 @@ import androidx.compose.ui.unit.dp
 import io.element.android.features.messages.impl.attachments.Attachment
 import io.element.android.features.messages.impl.attachments.preview.error.sendAttachmentError
 import io.element.android.features.messages.impl.media.local.LocalMediaView
-import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.designsystem.atomic.molecules.ButtonRowMolecule
 import io.element.android.libraries.designsystem.components.ProgressDialog
+import io.element.android.libraries.designsystem.components.ProgressDialogType
 import io.element.android.libraries.designsystem.components.dialogs.RetryDialog
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.theme.components.Scaffold
@ -58,7 +58,7 @@ fun AttachmentsPreviewView(
        state.eventSink(AttachmentsPreviewEvents.ClearSendState)
    }

-    if (state.sendActionState is Async.Success) {
+    if (state.sendActionState is SendActionState.Done) {
        LaunchedEffect(state.sendActionState) {
            onDismiss()
        }
@ -78,26 +78,32 @@ fun AttachmentsPreviewView(
    }
    AttachmentSendStateView(
        sendActionState = state.sendActionState,
-        onRetryClicked = ::postSendAttachment,
-        onRetryDismissed = ::postClearSendState
+        onDismissClicked = ::postClearSendState,
+        onRetryClicked = ::postSendAttachment
    )
 }

@Composable
 private fun AttachmentSendStateView(
-    sendActionState: Async<Unit>,
-    onRetryDismissed: () -> Unit,
+    sendActionState: SendActionState,
+    onDismissClicked: () -> Unit,
    onRetryClicked: () -> Unit
 ) {
-    when (sendActionState) {
-        is Async.Loading -> {
-            ProgressDialog(text = stringResource(id = CommonStrings.common_loading))
-        }

-        is Async.Failure -> {
+    when (sendActionState) {
+        is SendActionState.Sending -> {
+            ProgressDialog(
+                type = when (sendActionState) {
+                    is SendActionState.Sending.Uploading -> ProgressDialogType.Determinate(sendActionState.progress)
+                    SendActionState.Sending.Processing -> ProgressDialogType.Indeterminate
+                },
+                text = stringResource(id = CommonStrings.common_sending)
+            )
+        }
+        is SendActionState.Failure -> {
            RetryDialog(
                content = stringResource(sendAttachmentError(sendActionState.error)),
-                onDismiss = onRetryDismissed,
+                onDismiss = onDismissClicked,
                onRetry = onRetryClicked
            )
        }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/AttachmentsBottomSheet.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/AttachmentsBottomSheet.kt
@ -25,6 +25,7 @@ import androidx.compose.material.ListItem
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.AttachFile
 import androidx.compose.material.icons.filled.Collections
+import androidx.compose.material.icons.filled.LocationOn
 import androidx.compose.material.icons.filled.PhotoCamera
 import androidx.compose.material.icons.filled.Videocam
 import androidx.compose.material3.ExperimentalMaterial3Api
@ -48,6 +49,7 @@ import io.element.android.libraries.designsystem.theme.components.Text
@Composable
 internal fun AttachmentsBottomSheet(
    state: MessageComposerState,
+    onSendLocationClicked: () -> Unit,
    modifier: Modifier = Modifier,
 ) {
    val localView = LocalView.current
@ -78,7 +80,10 @@ internal fun AttachmentsBottomSheet(
            modifier = modifier,
            onDismissRequest = { isVisible = false }
        ) {
-            AttachmentSourcePickerMenu(eventSink = state.eventSink)
+            AttachmentSourcePickerMenu(
+                eventSink = state.eventSink,
+                onSendLocationClicked = onSendLocationClicked,
+            )
        }
    }
 }
@ -87,6 +92,7 @@ internal fun AttachmentsBottomSheet(
@Composable
 internal fun AttachmentSourcePickerMenu(
    eventSink: (MessageComposerEvents) -> Unit,
+    onSendLocationClicked: () -> Unit,
    modifier: Modifier = Modifier,
 ) {
    Column(
@ -113,5 +119,13 @@ internal fun AttachmentSourcePickerMenu(
            icon = { Icon(Icons.Default.Videocam, null) },
            text = { Text(stringResource(R.string.screen_room_attachment_source_camera_video)) },
        )
+        ListItem(
+            modifier = Modifier.clickable {
+                eventSink(MessageComposerEvents.PickAttachmentSource.Location)
+                onSendLocationClicked()
+            },
+            icon = { Icon(Icons.Default.LocationOn, null) },
+            text = { Text(stringResource(R.string.screen_room_attachment_source_location)) },
+        )
    }
 }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerEvents.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerEvents.kt
@ -34,5 +34,6 @@ sealed interface MessageComposerEvents {
        object FromFiles : PickAttachmentSource
        object PhotoFromCamera : PickAttachmentSource
        object VideoFromCamera : PickAttachmentSource
+        object Location : PickAttachmentSource
    }
 }
--- 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
@ -42,6 +42,7 @@ import io.element.android.libraries.di.RoomScope
 import io.element.android.libraries.di.SingleIn
 import io.element.android.libraries.featureflag.api.FeatureFlagService
 import io.element.android.libraries.featureflag.api.FeatureFlags
+import io.element.android.libraries.matrix.api.core.ProgressCallback
 import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.mediapickers.api.PickerProvider
 import io.element.android.libraries.mediaupload.api.MediaSender
@ -110,7 +111,7 @@ class MessageComposerPresenter @Inject constructor(

        LaunchedEffect(attachmentsState.value) {
            when (val attachmentStateValue = attachmentsState.value) {
-                is AttachmentsState.Sending -> localCoroutineScope.sendAttachment(attachmentStateValue.attachments.first(), attachmentsState)
+                is AttachmentsState.Sending.Processing -> localCoroutineScope.sendAttachment(attachmentStateValue.attachments.first(), attachmentsState)
                else -> Unit
            }
        }
@ -158,6 +159,10 @@ class MessageComposerPresenter @Inject constructor(
                    showAttachmentSourcePicker = false
                    cameraVideoPicker.launch()
                }
+                MessageComposerEvents.PickAttachmentSource.Location -> {
+                    showAttachmentSourcePicker = false
+                    // Navigation to the location picker screen is done at the view layer
+                }
            }
        }

@ -245,7 +250,7 @@ class MessageComposerPresenter @Inject constructor(
        attachmentsState.value = if (isPreviewable) {
            AttachmentsState.Previewing(persistentListOf(mediaAttachment))
        } else {
-            AttachmentsState.Sending(persistentListOf(mediaAttachment))
+            AttachmentsState.Sending.Processing(persistentListOf(mediaAttachment))
        }
    }

@ -254,7 +259,12 @@ class MessageComposerPresenter @Inject constructor(
        mimeType: String,
        attachmentState: MutableState<AttachmentsState>,
    ) {
-        mediaSender.sendMedia(uri, mimeType, compressIfPossible = false)
+        val progressCallback = object : ProgressCallback {
+            override fun onProgress(current: Long, total: Long) {
+                attachmentState.value = AttachmentsState.Sending.Uploading(current.toFloat() / total.toFloat())
+            }
+        }
+        mediaSender.sendMedia(uri, mimeType, compressIfPossible = false, progressCallback)
            .onSuccess {
                attachmentState.value = AttachmentsState.None
            }.onFailure {
--- 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
@ -39,5 +39,8 @@ data class MessageComposerState(
 sealed interface AttachmentsState {
    object None : AttachmentsState
    data class Previewing(val attachments: ImmutableList<Attachment>) : AttachmentsState
-    data class Sending(val attachments: ImmutableList<Attachment>) : AttachmentsState
+    sealed interface Sending : AttachmentsState {
+        data class Processing(val attachments: ImmutableList<Attachment>) : Sending
+        data class Uploading(val progress: Float) : Sending
+    }
 }
--- 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
@ -28,6 +28,7 @@ import io.element.android.libraries.textcomposer.TextComposer
@Composable
 fun MessageComposerView(
    state: MessageComposerState,
+    onSendLocationClicked: () -> Unit,
    modifier: Modifier = Modifier,
 ) {
    fun onFullscreenToggle() {
@ -55,7 +56,10 @@ fun MessageComposerView(
    }

    Box {
-        AttachmentsBottomSheet(state = state)
+        AttachmentsBottomSheet(
+            state = state,
+            onSendLocationClicked = onSendLocationClicked,
+        )

        TextComposer(
            onSendMessage = ::sendMessage,
@ -83,5 +87,8 @@ internal fun MessageComposerViewDarkPreview(@PreviewParameter(MessageComposerSta

@Composable
 private fun ContentToPreview(state: MessageComposerState) {
-    MessageComposerView(state)
+    MessageComposerView(
+        state = state,
+        onSendLocationClicked = {}
+    )
 }
--- 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
@ -59,21 +59,16 @@ class TimelinePresenter @Inject constructor(
        var lastReadMarkerIndex by rememberSaveable { mutableStateOf(Int.MAX_VALUE) }
        var lastReadMarkerId by rememberSaveable { mutableStateOf<EventId?>(null) }

-        val timelineItems = timelineItemsFactory
-            .flow()
-            .collectAsState()
-
-        val paginationState = timeline
-            .paginationState()
-            .collectAsState()
+        val timelineItems by timelineItemsFactory.collectItemsAsState()
+        val paginationState by timeline.paginationState.collectAsState()

        fun handleEvents(event: TimelineEvents) {
            when (event) {
-                TimelineEvents.LoadMore -> localCoroutineScope.loadMore(paginationState.value)
+                TimelineEvents.LoadMore -> localCoroutineScope.loadMore(paginationState)
                is TimelineEvents.SetHighlightedEvent -> highlightedEventId.value = event.eventId
                is TimelineEvents.OnScrollFinished -> {
                    // Get last valid EventId seen by the user, as the first index might refer to a Virtual item
-                    val eventId = getLastEventIdBeforeOrAt(event.firstIndex, timelineItems.value) ?: return
+                    val eventId = getLastEventIdBeforeOrAt(event.firstIndex, timelineItems) ?: return
                    if (event.firstIndex <= lastReadMarkerIndex && eventId != lastReadMarkerId) {
                        lastReadMarkerIndex = event.firstIndex
                        lastReadMarkerId = eventId
@ -85,11 +80,11 @@ class TimelinePresenter @Inject constructor(

        LaunchedEffect(Unit) {
            timeline
-                .timelineItems()
+                .timelineItems
                .onEach(timelineItemsFactory::replaceWith)
                .onEach { timelineItems ->
                    if (timelineItems.isEmpty()) {
-                        loadMore(paginationState.value)
+                        loadMore(paginationState)
                    }
                }
                .launchIn(this)
@ -97,8 +92,8 @@ class TimelinePresenter @Inject constructor(

        return TimelineState(
            highlightedEventId = highlightedEventId.value,
-            paginationState = paginationState.value,
-            timelineItems = timelineItems.value,
+            paginationState = paginationState,
+            timelineItems = timelineItems,
            eventSink = ::handleEvents
        )
    }
--- 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
@ -39,7 +39,6 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.pluralStringResource
@ -62,7 +61,6 @@ import io.element.android.libraries.designsystem.theme.components.Icon
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.UserId
 import kotlinx.collections.immutable.ImmutableList
-import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch

@Composable
@ -123,8 +121,7 @@ fun TimelineView(

        TimelineScrollHelper(
            lazyListState = lazyListState,
-            timelineItems = state.timelineItems,
-            onLoadMore = ::onReachedLoadMore
+            timelineItems = state.timelineItems
        )
    }
 }
@ -222,7 +219,6 @@ fun TimelineItemRow(
 internal fun BoxScope.TimelineScrollHelper(
    lazyListState: LazyListState,
    timelineItems: ImmutableList<TimelineItem>,
-    onLoadMore: () -> Unit = {},
 ) {
    val coroutineScope = rememberCoroutineScope()
    val firstVisibleItemIndex by remember { derivedStateOf { lazyListState.firstVisibleItemIndex } }
@ -236,24 +232,6 @@ internal fun BoxScope.TimelineScrollHelper(
        }
    }

-    // Handle load more preloading
-    val loadMore by remember {
-        derivedStateOf {
-            val layoutInfo = lazyListState.layoutInfo
-            val totalItemsNumber = layoutInfo.totalItemsCount
-            val lastVisibleItemIndex = (layoutInfo.visibleItemsInfo.lastOrNull()?.index ?: 0) + 1
-            lastVisibleItemIndex > (totalItemsNumber - 30)
-        }
-    }
-
-    LaunchedEffect(loadMore) {
-        snapshotFlow { loadMore }
-            .distinctUntilChanged()
-            .collect {
-                onLoadMore()
-            }
-    }
-
    // Jump to bottom button
    if (firstVisibleItemIndex > 2) {
        FloatingActionButton(
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/MessageEventBubble.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/MessageEventBubble.kt
@ -44,6 +44,8 @@ import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
 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.messageFromMeBackground
+import io.element.android.libraries.designsystem.theme.messageFromOtherBackground
 import io.element.android.libraries.theme.ElementTheme

 private val BUBBLE_RADIUS = 12.dp
@ -97,14 +99,11 @@ fun MessageEventBubble(
        }
    }

-    val backgroundBubbleColor = if (state.isHighlighted) {
-        ElementTheme.legacyColors.messageHighlightedBackground
+    // Ignore state.isHighlighted for now, we need a design decision on it.
+    val backgroundBubbleColor = if (state.isMine) {
+        ElementTheme.colors.messageFromMeBackground
    } else {
-        if (state.isMine) {
-            ElementTheme.legacyColors.messageFromMeBackground
-        } else {
-            ElementTheme.legacyColors.messageFromOtherBackground
-        }
+        ElementTheme.colors.messageFromOtherBackground
    }
    val bubbleShape = bubbleShape()
    Box(
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/MessageStateEventContainer.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/MessageStateEventContainer.kt
@ -41,18 +41,15 @@ private val CORNER_RADIUS = 8.dp
@OptIn(ExperimentalFoundationApi::class)
@Composable
 fun MessageStateEventContainer(
-    isHighlighted: Boolean,
+    @Suppress("UNUSED_PARAMETER") isHighlighted: Boolean,
    interactionSource: MutableInteractionSource,
    modifier: Modifier = Modifier,
    onClick: () -> Unit = {},
    onLongClick: () -> Unit = {},
    content: @Composable () -> Unit = {},
 ) {
-    val backgroundColor = if (isHighlighted) {
-        ElementTheme.legacyColors.messageHighlightedBackground
-    } else {
-        Color.Companion.Transparent
-    }
+    // Ignore isHighlighted for now, we need a design decision on it.
+    val backgroundColor = Color.Transparent
    val shape = RoundedCornerShape(CORNER_RADIUS)
    Surface(
        modifier = modifier
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineEventTimestampView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineEventTimestampView.kt
@ -58,15 +58,19 @@ fun TimelineEventTimestampView(
    val hasMessageSendingFailed = event.sendState is EventSendState.SendingFailed
    val isMessageEdited = (event.content as? TimelineItemTextBasedContent)?.isEdited.orFalse()
    val tint = if (hasMessageSendingFailed) MaterialTheme.colorScheme.error else null
+    val clickModifier = if (hasMessageSendingFailed) {
+        Modifier.combinedClickable(
+            onClick = onClick,
+            onLongClick = onLongClick,
+            indication = rememberRipple(bounded = false),
+            interactionSource = MutableInteractionSource()
+        )
+    } else {
+        Modifier
+    }
    Row(
        modifier = Modifier
-            .combinedClickable(
-                onClick = onClick,
-                onLongClick = onLongClick,
-                enabled = true,
-                indication = rememberRipple(bounded = false),
-                interactionSource = MutableInteractionSource()
-            )
+            .then(clickModifier)
            .padding(start = 16.dp) // Add extra padding for touch target size
            .then(modifier),
        verticalAlignment = Alignment.CenterVertically,
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineItemEventRow.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineItemEventRow.kt
@ -41,7 +41,6 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
@ -60,7 +59,6 @@ import io.element.android.features.messages.impl.timeline.model.event.TimelineIt
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVideoContent
 import io.element.android.features.messages.impl.timeline.model.event.aTimelineItemImageContent
 import io.element.android.features.messages.impl.timeline.model.event.aTimelineItemTextContent
-import io.element.android.libraries.designsystem.ElementTextStyles
 import io.element.android.libraries.designsystem.components.EqualWidthColumn
 import io.element.android.libraries.designsystem.components.avatar.Avatar
 import io.element.android.libraries.designsystem.components.avatar.AvatarData
@ -72,6 +70,8 @@ import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.InReplyTo
+import io.element.android.libraries.matrix.api.timeline.item.event.MessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.TextMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.VideoMessageType
 import io.element.android.libraries.matrix.ui.components.AttachmentThumbnail
 import io.element.android.libraries.matrix.ui.components.AttachmentThumbnailInfo
@ -271,7 +271,7 @@ private fun MessageEventBubbleContent(
            }
        } else {
            Box(modifier) {
-                ContentView(modifier = contentModifier.padding(start = 12.dp, end = 12.dp, top = 8.dp, bottom = 8.dp))
+                ContentView(modifier = contentModifier)
                TimelineEventTimestampView(
                    event = event,
                    onClick = onTimestampClicked,
@ -319,7 +319,11 @@ private fun MessageEventBubbleContent(
            val contentModifier = if (isMediaItem) {
                Modifier.clip(RoundedCornerShape(12.dp))
            } else {
-                Modifier
+                if (inReplyToDetails != null) {
+                    Modifier.padding(start = 12.dp, end = 12.dp, top = 0.dp, bottom = 8.dp)
+                } else {
+                    Modifier.padding(start = 12.dp, end = 12.dp, top = 8.dp, bottom = 8.dp)
+                }
            }

            ContentAndTimestampView(
@ -366,20 +370,19 @@ private fun ReplyToContent(
        }
        Column(verticalArrangement = Arrangement.SpaceBetween) {
            Text(
-                senderName,
-                style = ElementTextStyles.Regular.caption2.copy(fontWeight = FontWeight.Medium),
+                text = senderName,
+                style = ElementTheme.typography.fontBodySmMedium,
                textAlign = TextAlign.Start,
-                color = MaterialTheme.colorScheme.primary,
+                color = ElementTheme.materialColors.primary,
                maxLines = 1,
                overflow = TextOverflow.Ellipsis,
            )
-
            Text(
                text = text.orEmpty(),
-                style = ElementTextStyles.Regular.caption1,
+                style = ElementTheme.typography.fontBodyMdRegular,
                textAlign = TextAlign.Start,
-                color = ElementTheme.legacyColors.placeholder,
-                maxLines = 1,
+                color = ElementTheme.materialColors.secondary,
+                maxLines = 2,
                overflow = TextOverflow.Ellipsis,
            )
        }
@ -458,6 +461,76 @@ private fun ContentToPreview() {
    }
 }

+@Preview
+@Composable
+internal fun TimelineItemEventRowWithReplyLightPreview() =
+    ElementPreviewLight { ContentToPreviewWithReply() }
+
+@Preview
+@Composable
+internal fun TimelineItemEventRowWithReplyDarkPreview() =
+    ElementPreviewDark { ContentToPreviewWithReply() }
+
+@Composable
+private fun ContentToPreviewWithReply() {
+    Column {
+        sequenceOf(false, true).forEach {
+            val replyContent = if(it) {
+                // Short
+                "Message which are being replied."
+            } else {
+                // Long, to test 2 lines and ellipsis)
+                "Message which are being replied, and which was long enough to be displayed on two lines (only!)."
+            }
+            TimelineItemEventRow(
+                event = aTimelineItemEvent(
+                    isMine = it,
+                    content = aTimelineItemTextContent().copy(
+                        body = "A long text which will be displayed on several lines and" +
+                            " hopefully can be manually adjusted to test different behaviors."
+                    ),
+                    inReplyTo = aInReplyToReady(replyContent)
+                ),
+                isHighlighted = false,
+                onClick = {},
+                onLongClick = {},
+                onUserDataClick = {},
+                inReplyToClick = {},
+                onReactionClick = { _, _ -> },
+                onTimestampClicked = {},
+            )
+            TimelineItemEventRow(
+                event = aTimelineItemEvent(
+                    isMine = it,
+                    content = aTimelineItemImageContent().copy(
+                        aspectRatio = 5f
+                    ),
+                    inReplyTo = aInReplyToReady(replyContent)
+                ),
+                isHighlighted = false,
+                onClick = {},
+                onLongClick = {},
+                onUserDataClick = {},
+                inReplyToClick = {},
+                onReactionClick = { _, _ -> },
+                onTimestampClicked = {},
+            )
+        }
+    }
+}
+
+private fun aInReplyToReady(
+    replyContent: String
+): InReplyTo.Ready {
+    return InReplyTo.Ready(
+        eventId = EventId("\$event"),
+        content = MessageContent(replyContent, null, false, TextMessageType(replyContent, null)),
+        senderId = UserId("@Sender:domain"),
+        senderDisplayName = "Sender",
+        senderAvatarUrl = null,
+    )
+}
+
@Preview
@Composable
 internal fun TimelineItemEventRowTimestampLightPreview(@PreviewParameter(TimelineItemEventForTimestampViewProvider::class) event: TimelineItem.Event) =
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineItemStateEventRow.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineItemStateEventRow.kt
@ -19,6 +19,7 @@ package io.element.android.features.messages.impl.timeline.components
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.widthIn
 import androidx.compose.foundation.layout.wrapContentHeight
 import androidx.compose.runtime.Composable
@ -50,6 +51,7 @@ fun TimelineItemStateEventRow(
    Box(
        modifier = modifier
            .fillMaxWidth()
+            .padding(vertical = 8.dp)
            .wrapContentHeight(),
        contentAlignment = Alignment.Center
    ) {
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/customreaction/CustomReactionBottomSheet.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/customreaction/CustomReactionBottomSheet.kt
@ -38,9 +38,7 @@ fun CustomReactionBottomSheet(
    val coroutineScope = rememberCoroutineScope()

    fun onDismiss() {
-        sheetState.hide(coroutineScope) {
-            state.eventSink(CustomReactionEvents.UpdateSelectedEvent(null))
-        }
+        state.eventSink(CustomReactionEvents.UpdateSelectedEvent(null))
    }

    fun onEmojiSelectedDismiss(emoji: Emoji) {
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/event/ExtraPadding.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/event/ExtraPadding.kt
@ -51,3 +51,11 @@ fun TimelineItem.Event.toExtraPadding(): ExtraPadding {
    // A space and a few unbreakable spaces
    return ExtraPadding(" " + "\u00A0".repeat(strLen))
 }
+
+fun ExtraPadding.strBigger(): String {
+    return if (str.isEmpty()) {
+        str
+    } else {
+        str + "\u00A0\u00A0\u00A0"
+    }
+}
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/event/TimelineItemInformativeView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/event/TimelineItemInformativeView.kt
@ -59,7 +59,8 @@ fun TimelineItemInformativeView(
            fontStyle = FontStyle.Italic,
            color = MaterialTheme.colorScheme.secondary,
            fontSize = 14.sp,
-            text = text + extraPadding.str
+            // Since the font size is smaller, add more space to extra padding, to not overlap with the timestamp
+            text = text + extraPadding.strBigger()
        )
    }
 }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/group/GroupHeaderView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/group/GroupHeaderView.kt
@ -38,7 +38,6 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
-import io.element.android.libraries.theme.ElementTheme
 import io.element.android.libraries.designsystem.theme.components.Icon
 import io.element.android.libraries.designsystem.theme.components.Surface
 import io.element.android.libraries.designsystem.theme.components.Text
@ -49,15 +48,12 @@ private val CORNER_RADIUS = 8.dp
 fun GroupHeaderView(
    text: String,
    isExpanded: Boolean,
-    isHighlighted: Boolean,
+    @Suppress("UNUSED_PARAMETER") isHighlighted: Boolean,
    onClick: () -> Unit,
    modifier: Modifier = Modifier
 ) {
-    val backgroundColor = if (isHighlighted) {
-        ElementTheme.legacyColors.messageHighlightedBackground
-    } else {
-        Color.Companion.Transparent
-    }
+    // Ignore isHighlighted for now, we need a design decision on it.
+    val backgroundColor = Color.Companion.Transparent
    val shape = RoundedCornerShape(CORNER_RADIUS)

    Box(
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/retrysendmenu/RetrySendMessageMenu.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/retrysendmenu/RetrySendMessageMenu.kt
@ -25,7 +25,6 @@ import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.ListItem
 import androidx.compose.material3.ListItemDefaults
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.ModalBottomSheet
 import androidx.compose.material3.SheetState
 import androidx.compose.material3.rememberModalBottomSheetState
 import androidx.compose.runtime.Composable
@ -40,6 +39,7 @@ import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
 import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.features.messages.impl.R
+import io.element.android.libraries.designsystem.theme.components.ModalBottomSheet
 import kotlinx.coroutines.launch

@Composable
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/TimelineItemsFactory.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/TimelineItemsFactory.kt
@ -16,6 +16,9 @@

 package io.element.android.features.messages.impl.timeline.factories

+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.State
+import androidx.compose.runtime.collectAsState
 import androidx.recyclerview.widget.DiffUtil
 import io.element.android.features.messages.impl.timeline.diff.CacheInvalidator
 import io.element.android.features.messages.impl.timeline.diff.MatrixTimelineItemsDiffCallback
@ -27,11 +30,8 @@ import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
-import kotlinx.collections.immutable.toImmutableList
 import kotlinx.collections.immutable.toPersistentList
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
@ -55,7 +55,10 @@ class TimelineItemsFactory @Inject constructor(
    private val lock = Mutex()
    private val cacheInvalidator = CacheInvalidator(timelineItemsCache)

-    fun flow(): StateFlow<ImmutableList<TimelineItem>> = timelineItems.asStateFlow()
+    @Composable
+    fun collectItemsAsState(): State<ImmutableList<TimelineItem>> {
+        return timelineItems.collectAsState()
+    }

    suspend fun replaceWith(
        timelineItems: List<MatrixTimelineItem>,
--- a/features/messages/impl/src/test/kotlin/io/element/android/features/messages/attachments/AttachmentsPreviewPresenterTest.kt
+++ b/features/messages/impl/src/test/kotlin/io/element/android/features/messages/attachments/AttachmentsPreviewPresenterTest.kt
@ -27,8 +27,8 @@ import io.element.android.features.messages.fixtures.aLocalMedia
 import io.element.android.features.messages.impl.attachments.Attachment
 import io.element.android.features.messages.impl.attachments.preview.AttachmentsPreviewEvents
 import io.element.android.features.messages.impl.attachments.preview.AttachmentsPreviewPresenter
+import io.element.android.features.messages.impl.attachments.preview.SendActionState
 import io.element.android.features.messages.impl.media.local.LocalMedia
-import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
 import io.element.android.libraries.mediaupload.api.MediaPreProcessor
@ -47,17 +47,26 @@ class AttachmentsPreviewPresenterTest {
    @Test
    fun `present - send media success scenario`() = runTest {
        val room = FakeMatrixRoom()
+        room.givenProgressCallbackValues(
+            listOf(
+                Pair(0, 10),
+                Pair(5, 10),
+                Pair(10, 10)
+            )
+        )
        val presenter = anAttachmentsPreviewPresenter(room = room)
        moleculeFlow(RecompositionClock.Immediate) {
            presenter.present()
        }.test {
            val initialState = awaitItem()
-            assertThat(initialState.sendActionState).isEqualTo(Async.Uninitialized)
+            assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle)
            initialState.eventSink(AttachmentsPreviewEvents.SendAttachment)
-            val loadingState = awaitItem()
-            assertThat(loadingState.sendActionState).isEqualTo(Async.Loading<Unit>())
+            assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Processing)
+            assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Uploading(0f))
+            assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Uploading(0.5f))
+            assertThat(awaitItem().sendActionState).isEqualTo(SendActionState.Sending.Uploading(1f))
            val successState = awaitItem()
-            assertThat(successState.sendActionState).isEqualTo(Async.Success(Unit))
+            assertThat(successState.sendActionState).isEqualTo(SendActionState.Done)
            assertThat(room.sendMediaCount).isEqualTo(1)
        }
    }
@ -72,16 +81,16 @@ class AttachmentsPreviewPresenterTest {
            presenter.present()
        }.test {
            val initialState = awaitItem()
-            assertThat(initialState.sendActionState).isEqualTo(Async.Uninitialized)
+            assertThat(initialState.sendActionState).isEqualTo(SendActionState.Idle)
            initialState.eventSink(AttachmentsPreviewEvents.SendAttachment)
            val loadingState = awaitItem()
-            assertThat(loadingState.sendActionState).isEqualTo(Async.Loading<Unit>())
+            assertThat(loadingState.sendActionState).isEqualTo(SendActionState.Sending.Processing)
            val failureState = awaitItem()
-            assertThat(failureState.sendActionState).isEqualTo(Async.Failure<Unit>(failure))
+            assertThat(failureState.sendActionState).isEqualTo((SendActionState.Failure(failure)))
            assertThat(room.sendMediaCount).isEqualTo(0)
            failureState.eventSink(AttachmentsPreviewEvents.ClearSendState)
            val clearedState = awaitItem()
-            assertThat(clearedState.sendActionState).isEqualTo(Async.Uninitialized)
+            assertThat(clearedState.sendActionState).isEqualTo(SendActionState.Idle)
        }
    }

--- a/features/messages/impl/src/test/kotlin/io/element/android/features/messages/textcomposer/MessageComposerPresenterTest.kt
+++ b/features/messages/impl/src/test/kotlin/io/element/android/features/messages/textcomposer/MessageComposerPresenterTest.kt
@ -368,6 +368,13 @@ class MessageComposerPresenterTest {
    @Test
    fun `present - Pick file from storage`() = runTest {
        val room = FakeMatrixRoom()
+        room.givenProgressCallbackValues(
+            listOf(
+                Pair(0, 10),
+                Pair(5, 10),
+                Pair(10, 10)
+            )
+        )
        val presenter = createPresenter(this, room = room)
        moleculeFlow(RecompositionClock.Immediate) {
            presenter.present()
@ -376,7 +383,10 @@ class MessageComposerPresenterTest {
            initialState.eventSink(MessageComposerEvents.PickAttachmentSource.FromFiles)
            val sendingState = awaitItem()
            assertThat(sendingState.showAttachmentSourcePicker).isFalse()
-            assertThat(sendingState.attachmentsState).isInstanceOf(AttachmentsState.Sending::class.java)
+            assertThat(sendingState.attachmentsState).isInstanceOf(AttachmentsState.Sending.Processing::class.java)
+            assertThat(awaitItem().attachmentsState).isEqualTo(AttachmentsState.Sending.Uploading(0f))
+            assertThat(awaitItem().attachmentsState).isEqualTo(AttachmentsState.Sending.Uploading(0.5f))
+            assertThat(awaitItem().attachmentsState).isEqualTo(AttachmentsState.Sending.Uploading(1f))
            val sentState = awaitItem()
            assertThat(sentState.attachmentsState).isEqualTo(AttachmentsState.None)
            assertThat(room.sendMediaCount).isEqualTo(1)