Merge branch 'develop' into feature/fga/media_viewer_actions

2023-06-02 17:22:10 +02:00 · 2023-06-02 17:22:10 +02:00 · 3ee9ba4979
commit 3ee9ba4979
parent 4ab535cf33 341be67f3a
277 changed files with 2204 additions and 1072 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
@ -34,6 +34,7 @@ import io.element.android.features.messages.impl.attachments.Attachment
 import io.element.android.features.messages.impl.attachments.preview.AttachmentsPreviewNode
 import io.element.android.features.messages.impl.media.viewer.MediaViewerNode
 import io.element.android.features.messages.impl.timeline.model.TimelineItem
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemFileContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemImageContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVideoContent
 import io.element.android.libraries.architecture.BackstackNode
@ -134,6 +135,16 @@ class MessagesFlowNode @AssistedInject constructor(
                )
                backstack.push(navTarget)
            }
+            is TimelineItemFileContent -> {
+                val mediaSource = event.content.fileSource
+                val navTarget = NavTarget.MediaViewer(
+                    title = event.content.body,
+                    mediaSource = mediaSource,
+                    thumbnailSource = event.content.thumbnailSource,
+                    mimeType = event.content.mimeType,
+                )
+                backstack.push(navTarget)
+            }
            else -> Unit
        }
    }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesPresenter.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesPresenter.kt
@ -118,6 +118,8 @@ class MessagesPresenter @Inject constructor(
            TimelineItemAction.Redact -> handleActionRedact(targetEvent)
            TimelineItemAction.Edit -> handleActionEdit(targetEvent, composerState)
            TimelineItemAction.Reply -> handleActionReply(targetEvent, composerState)
+            TimelineItemAction.Developer -> notImplementedYet()
+            TimelineItemAction.ReportContent -> notImplementedYet()
        }
    }

--- 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
@ -16,7 +16,6 @@

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

-import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
@ -32,27 +31,22 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.statusBars
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.layout.wrapContentHeight
-import androidx.compose.material.ExperimentalMaterialApi
-import androidx.compose.material.ListItem
-import androidx.compose.material.ModalBottomSheetValue
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.ArrowBack
-import androidx.compose.material.icons.filled.AttachFile
-import androidx.compose.material.icons.filled.Collections
-import androidx.compose.material.icons.filled.PhotoCamera
-import androidx.compose.material.icons.filled.Videocam
-import androidx.compose.material.rememberModalBottomSheetState
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.getValue
+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.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalInspectionMode
 import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
@ -66,9 +60,7 @@ import io.element.android.features.messages.impl.actionlist.ActionListView
 import io.element.android.features.messages.impl.actionlist.model.TimelineItemAction
 import io.element.android.features.messages.impl.attachments.Attachment
 import io.element.android.features.messages.impl.messagecomposer.AttachmentsState
-import io.element.android.features.messages.impl.messagecomposer.MessageComposerEvents
 import io.element.android.features.messages.impl.messagecomposer.MessageComposerView
-import io.element.android.features.messages.impl.timeline.TimelineEvents
 import io.element.android.features.messages.impl.timeline.TimelineView
 import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.features.networkmonitor.api.ui.ConnectivityIndicatorView
@ -80,7 +72,6 @@ import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
 import io.element.android.libraries.designsystem.theme.components.Icon
 import io.element.android.libraries.designsystem.theme.components.IconButton
-import io.element.android.libraries.designsystem.theme.components.ModalBottomSheetLayout
 import io.element.android.libraries.designsystem.theme.components.Scaffold
 import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.designsystem.theme.components.TopAppBar
@ -91,7 +82,7 @@ import kotlinx.coroutines.launch
 import timber.log.Timber
 import io.element.android.libraries.ui.strings.R as StringsR

-@OptIn(ExperimentalMaterialApi::class, ExperimentalLayoutApi::class)
+@OptIn(ExperimentalLayoutApi::class)
@Composable
 fun MessagesView(
    state: MessagesState,
@ -103,26 +94,11 @@ fun MessagesView(
    modifier: Modifier = Modifier,
 ) {
    LogCompositions(tag = "MessagesScreen", msg = "Root")
-    val itemActionsBottomSheetState = rememberModalBottomSheetState(
-        initialValue = ModalBottomSheetValue.Hidden,
-    )
-    val composerState = state.composerState
-    val initialBottomSheetState = if (LocalInspectionMode.current && composerState.showAttachmentSourcePicker) {
-        ModalBottomSheetValue.Expanded
-    } else {
-        ModalBottomSheetValue.Hidden
-    }
-    val bottomSheetState = rememberModalBottomSheetState(initialValue = initialBottomSheetState)
    val coroutineScope = rememberCoroutineScope()
+    var isMessageActionsBottomSheetVisible by rememberSaveable { mutableStateOf(false) }

    AttachmentStateView(state.composerState.attachmentsState, onPreviewAttachments)

-    BackHandler(enabled = bottomSheetState.isVisible) {
-        coroutineScope.launch {
-            bottomSheetState.hide()
-        }
-    }
-
    val snackbarHostState = remember { SnackbarHostState() }
    val snackbarMessageText = state.snackbarMessage?.let { stringResource(it.messageResId) }
    if (snackbarMessageText != null) {
@ -150,78 +126,57 @@ fun MessagesView(
        Timber.v("OnMessageLongClicked= ${event.id}")
        localView.hideKeyboard()
        state.actionListState.eventSink(ActionListEvents.ComputeForMessage(event))
-        coroutineScope.launch {
-            itemActionsBottomSheetState.show()
-        }
+        isMessageActionsBottomSheetVisible = true
    }

    fun onActionSelected(action: TimelineItemAction, event: TimelineItem.Event) {
+        isMessageActionsBottomSheetVisible = false
        state.eventSink(MessagesEvents.HandleAction(action, event))
    }

-    LaunchedEffect(composerState.showAttachmentSourcePicker) {
-        if (composerState.showAttachmentSourcePicker) {
-            // We need to use this instead of `LocalFocusManager.clearFocus()` to hide the keyboard when focus is on an Android View
-            localView.hideKeyboard()
-            bottomSheetState.show()
-        } else {
-            bottomSheetState.hide()
-        }
+    fun onDismissActionListBottomSheet() {
+        isMessageActionsBottomSheetVisible = false
    }
-    // Send 'DismissAttachmentMenu' event when the bottomsheet was just hidden
-    LaunchedEffect(bottomSheetState.isVisible) {
-        if (!bottomSheetState.isVisible) {
-            composerState.eventSink(MessageComposerEvents.DismissAttachmentMenu)
-        }
-    }
-    ModalBottomSheetLayout(
-        sheetState = bottomSheetState,
-        displayHandle = true,
-        sheetContent = {
-            AttachmentSourcePickerMenu(
-                eventSink = composerState.eventSink
-            )
-        }
-    ) {
-        Scaffold(
-            modifier = modifier,
-            contentWindowInsets = WindowInsets.statusBars,
-            topBar = {
-                Column {
-                    ConnectivityIndicatorView(isOnline = state.hasNetworkConnection)
-                    MessagesViewTopBar(
-                        roomTitle = state.roomName,
-                        roomAvatar = state.roomAvatar,
-                        onBackPressed = onBackPressed,
-                        onRoomDetailsClicked = onRoomDetailsClicked,
-                    )
-                }
-            },
-            content = { padding ->
-                MessagesViewContent(
-                    state = state,
-                    modifier = Modifier
-                        .padding(padding)
-                        .consumeWindowInsets(padding),
-                    onMessageClicked = ::onMessageClicked,
-                    onMessageLongClicked = ::onMessageLongClicked,
-                    onUserDataClicked = onUserDataClicked,
-                )
-            },
-            snackbarHost = {
-                SnackbarHost(
-                    snackbarHostState,
-                    modifier = Modifier.navigationBarsPadding()
-                )
-            },
-        )

-        ActionListView(
-            state = state.actionListState,
-            modalBottomSheetState = itemActionsBottomSheetState,
-            onActionSelected = ::onActionSelected
-        )
-    }
+    Scaffold(
+        modifier = modifier,
+        contentWindowInsets = WindowInsets.statusBars,
+        topBar = {
+            Column {
+                ConnectivityIndicatorView(isOnline = state.hasNetworkConnection)
+                MessagesViewTopBar(
+                    roomTitle = state.roomName,
+                    roomAvatar = state.roomAvatar,
+                    onBackPressed = onBackPressed,
+                    onRoomDetailsClicked = onRoomDetailsClicked,
+                )
+            }
+        },
+        content = { padding ->
+            MessagesViewContent(
+                state = state,
+                modifier = Modifier
+                    .padding(padding)
+                    .consumeWindowInsets(padding),
+                onMessageClicked = ::onMessageClicked,
+                onMessageLongClicked = ::onMessageLongClicked,
+                onUserDataClicked = onUserDataClicked,
+            )
+        },
+        snackbarHost = {
+            SnackbarHost(
+                snackbarHostState,
+                modifier = Modifier.navigationBarsPadding()
+            )
+        },
+    )
+
+    ActionListView(
+        state = state.actionListState,
+        isVisible = isMessageActionsBottomSheetVisible,
+        onDismiss = ::onDismissActionListBottomSheet,
+        onActionSelected = ::onActionSelected
+    )
 }

@Composable
@ -312,36 +267,6 @@ fun MessagesViewTopBar(
    )
 }

-@OptIn(ExperimentalMaterialApi::class)
-@Composable
-internal fun AttachmentSourcePickerMenu(
-    eventSink: (MessageComposerEvents) -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    Column(modifier) {
-        ListItem(
-            modifier = Modifier.clickable { eventSink(MessageComposerEvents.PickAttachmentSource.FromGallery) },
-            icon = { Icon(Icons.Default.Collections, null) },
-            text = { Text(stringResource(R.string.screen_room_attachment_source_gallery)) },
-        )
-        ListItem(
-            modifier = Modifier.clickable { eventSink(MessageComposerEvents.PickAttachmentSource.FromFiles) },
-            icon = { Icon(Icons.Default.AttachFile, null) },
-            text = { Text(stringResource(R.string.screen_room_attachment_source_files)) },
-        )
-        ListItem(
-            modifier = Modifier.clickable { eventSink(MessageComposerEvents.PickAttachmentSource.PhotoFromCamera) },
-            icon = { Icon(Icons.Default.PhotoCamera, null) },
-            text = { Text(stringResource(R.string.screen_room_attachment_source_camera_photo)) },
-        )
-        ListItem(
-            modifier = Modifier.clickable { eventSink(MessageComposerEvents.PickAttachmentSource.VideoFromCamera) },
-            icon = { Icon(Icons.Default.Videocam, null) },
-            text = { Text(stringResource(R.string.screen_room_attachment_source_camera_video)) },
-        )
-    }
-}
-
@Preview
@Composable
 internal fun MessagesViewLightPreview(@PreviewParameter(MessagesStateProvider::class) state: MessagesState) =
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/actionlist/ActionListPresenter.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/actionlist/ActionListPresenter.kt
@ -26,12 +26,15 @@ import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemRedactedContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemStateContent
 import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.core.meta.BuildMeta
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import javax.inject.Inject

-class ActionListPresenter @Inject constructor() : Presenter<ActionListState> {
+class ActionListPresenter @Inject constructor(
+    private val buildMeta: BuildMeta,
+) : Presenter<ActionListState> {

    @Composable
    override fun present(): ActionListState {
@ -60,21 +63,30 @@ class ActionListPresenter @Inject constructor() : Presenter<ActionListState> {
            when (timelineItem.content) {
                is TimelineItemRedactedContent,
                is TimelineItemStateContent -> {
-                    // TODO Add Share action (also) here, and developer options
-                    emptyList()
-                }
-                else -> {
-                    mutableListOf(
-                        TimelineItemAction.Reply,
-                        TimelineItemAction.Forward,
-                        TimelineItemAction.Copy,
-                    ).also {
-                        if (timelineItem.isMine) {
-                            it.add(TimelineItemAction.Edit)
-                            it.add(TimelineItemAction.Redact)
+                    buildList {
+                        add(TimelineItemAction.Copy)
+                        if (buildMeta.isDebuggable) {
+                            add(TimelineItemAction.Developer)
                        }
                    }
                }
+                else -> buildList<TimelineItemAction> {
+                    add(TimelineItemAction.Reply)
+                    add(TimelineItemAction.Forward)
+                    if (timelineItem.isMine) {
+                        add(TimelineItemAction.Edit)
+                    }
+                    add(TimelineItemAction.Copy)
+                    if (buildMeta.isDebuggable) {
+                        add(TimelineItemAction.Developer)
+                    }
+                    if (!timelineItem.isMine) {
+                        add(TimelineItemAction.ReportContent)
+                    }
+                    if (timelineItem.isMine) {
+                        add(TimelineItemAction.Redact)
+                    }
+                }
            }
        target.value = ActionListState.Target.Success(timelineItem, actions.toImmutableList())
    }
--- 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
@ -16,52 +16,81 @@

 package io.element.android.features.messages.impl.actionlist

+import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.imePadding
-import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.ExperimentalMaterialApi
 import androidx.compose.material.ListItem
-import androidx.compose.material.ModalBottomSheetState
-import androidx.compose.material.ModalBottomSheetValue
 import androidx.compose.material.Text
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.AddReaction
+import androidx.compose.material.icons.outlined.Attachment
+import androidx.compose.material.icons.outlined.VideoCameraBack
+import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalDensity
+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
 import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.TextUnit
 import androidx.compose.ui.unit.dp
 import io.element.android.features.messages.impl.actionlist.model.TimelineItemAction
+import io.element.android.features.messages.impl.timeline.components.blurhash.BlurHashAsyncImage
 import io.element.android.features.messages.impl.timeline.model.TimelineItem
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEncryptedContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemFileContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemImageContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemProfileChangeContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemRedactedContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemStateContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemTextBasedContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVideoContent
+import io.element.android.libraries.designsystem.ElementTextStyles
+import io.element.android.libraries.designsystem.components.avatar.Avatar
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.components.Divider
 import io.element.android.libraries.designsystem.theme.components.Icon
-import io.element.android.libraries.designsystem.theme.components.ModalBottomSheetLayout
-import kotlinx.coroutines.flow.filter
-import kotlinx.coroutines.launch
+import io.element.android.libraries.designsystem.theme.components.ModalBottomSheet
+import io.element.android.libraries.matrix.ui.media.MediaRequestData
+import io.element.android.libraries.ui.strings.R as StringR

-@OptIn(ExperimentalMaterialApi::class)
+@OptIn(ExperimentalMaterial3Api::class)
@Composable
 fun ActionListView(
    state: ActionListState,
-    modalBottomSheetState: ModalBottomSheetState,
+    isVisible: Boolean,
    onActionSelected: (action: TimelineItemAction, TimelineItem.Event) -> Unit,
+    onDismiss: () -> Unit,
    modifier: Modifier = Modifier
 ) {
-    val coroutineScope = rememberCoroutineScope()
-    LaunchedEffect(modalBottomSheetState) {
-        snapshotFlow { modalBottomSheetState.currentValue }
-            .filter { it == ModalBottomSheetValue.Hidden }
-            .collect {
-                state.eventSink(ActionListEvents.Clear)
-            }
+    LaunchedEffect(isVisible) {
+        if (!isVisible) {
+            state.eventSink(ActionListEvents.Clear)
+        }
    }

    fun onItemActionClicked(
@ -69,24 +98,22 @@ fun ActionListView(
        targetItem: TimelineItem.Event
    ) {
        onActionSelected(itemAction, targetItem)
-        coroutineScope.launch {
-            modalBottomSheetState.hide()
-        }
    }

-    ModalBottomSheetLayout(
-        modifier = modifier,
-        sheetState = modalBottomSheetState,
-        sheetContent = {
+    if (isVisible) {
+        ModalBottomSheet(
+            onDismissRequest = onDismiss
+        ) {
            SheetContent(
                state = state,
                onActionClicked = ::onItemActionClicked,
-                modifier = Modifier
-                    .navigationBarsPadding()
-                    .imePadding()
+                modifier = modifier
+                    .padding(bottom = 32.dp)
+//                    .navigationBarsPadding() - FIXME after https://issuetracker.google.com/issues/275849044
+//                    .imePadding()
            )
        }
-    )
+    }
 }

@OptIn(ExperimentalMaterialApi::class)
@ -108,6 +135,19 @@ private fun SheetContent(
            LazyColumn(
                modifier = modifier.fillMaxWidth()
            ) {
+                item {
+                    Column {
+                        MessageSummary(event = target.event, modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(horizontal = 16.dp))
+                        Spacer(modifier = Modifier.height(14.dp))
+                        Divider()
+                    }
+                }
+                item {
+                    EmojiReactionsRow(Modifier.fillMaxWidth())
+                    Divider()
+                }
                items(
                    items = actions,
                ) { action ->
@ -135,6 +175,141 @@ private fun SheetContent(
    }
 }

+@Composable
+private fun MessageSummary(event: TimelineItem.Event, modifier: Modifier = Modifier) {
+    val content: @Composable () -> Unit
+    var icon: @Composable () -> Unit = { Avatar(avatarData = event.senderAvatar.copy(size = AvatarSize.SMALL)) }
+    val contentStyle = ElementTextStyles.Regular.bodyMD.copy(color = MaterialTheme.colorScheme.secondary)
+    val imageModifier = Modifier
+        .size(36.dp)
+        .clip(RoundedCornerShape(9.dp))
+
+    @Composable
+    fun ContentForBody(body: String) {
+        Text(body, style = contentStyle, maxLines = 1, overflow = TextOverflow.Ellipsis)
+    }
+
+    when (event.content) {
+        is TimelineItemTextBasedContent -> content = { ContentForBody(event.content.body) }
+        is TimelineItemStateContent -> content = { ContentForBody(event.content.body) }
+        is TimelineItemProfileChangeContent -> content = { ContentForBody(event.content.body) }
+        is TimelineItemEncryptedContent -> content = { ContentForBody(stringResource(StringR.string.common_unable_to_decrypt)) }
+        is TimelineItemRedactedContent -> content = { ContentForBody(stringResource(StringR.string.common_message_removed)) }
+        is TimelineItemUnknownContent -> content = { ContentForBody(stringResource(StringR.string.common_unsupported_event)) }
+        is TimelineItemImageContent -> {
+            icon = {
+                val mediaRequestData = MediaRequestData(
+                    source = event.content.mediaSource,
+                    kind = MediaRequestData.Kind.Thumbnail(32),
+                )
+                BlurHashAsyncImage(
+                    model = mediaRequestData,
+                    blurHash = event.content.blurhash,
+                    contentDescription = stringResource(StringR.string.common_image),
+                    contentScale = ContentScale.Crop,
+                    modifier = imageModifier,
+                )
+            }
+            content = { ContentForBody(event.content.body) }
+        }
+        is TimelineItemVideoContent -> {
+            icon = {
+                val thumbnailSource = event.content.thumbnailSource
+                if (thumbnailSource != null) {
+                    val mediaRequestData = MediaRequestData(
+                        source = event.content.thumbnailSource,
+                        kind = MediaRequestData.Kind.Thumbnail(32),
+                    )
+                    BlurHashAsyncImage(
+                        model = mediaRequestData,
+                        blurHash = event.content.blurHash,
+                        contentDescription = stringResource(StringR.string.common_video),
+                        contentScale = ContentScale.Crop,
+                        modifier = imageModifier,
+                    )
+                } else {
+                    Box(
+                        modifier = imageModifier.background(MaterialTheme.colorScheme.surface),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        Icon(
+                            imageVector = Icons.Outlined.VideoCameraBack,
+                            contentDescription = stringResource(StringR.string.common_video),
+                        )
+                    }
+                }
+            }
+            content = { ContentForBody(event.content.body) }
+        }
+        is TimelineItemFileContent -> {
+            icon = {
+                Box(
+                    modifier = imageModifier.background(MaterialTheme.colorScheme.surface),
+                    contentAlignment = Alignment.Center
+                ) {
+                    Icon(
+                        imageVector = Icons.Outlined.Attachment,
+                        contentDescription = stringResource(StringR.string.common_file),
+                        modifier = Modifier.rotate(-45f)
+                    )
+                }
+            }
+            content = { ContentForBody(event.content.body) }
+        }
+    }
+    Row(modifier = modifier) {
+        icon()
+        Spacer(modifier = Modifier.width(8.dp))
+        Column {
+            Row {
+                if (event.senderDisplayName != null) {
+                    Text(
+                        text = event.senderDisplayName,
+                        style = ElementTextStyles.Bold.caption1,
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+                Text(
+                    event.sentTime,
+                    style = ElementTextStyles.Regular.caption2,
+                    color = MaterialTheme.colorScheme.secondary,
+                    textAlign = TextAlign.End,
+                    modifier = Modifier.weight(1f)
+                )
+            }
+            content()
+        }
+    }
+}
+
+@Composable
+internal fun EmojiReactionsRow(modifier: Modifier = Modifier) {
+    Row(
+        horizontalArrangement = Arrangement.SpaceBetween,
+        modifier = modifier.padding(horizontal = 28.dp, vertical = 16.dp)
+    ) {
+        // TODO use real emojis, have real interaction
+        Text("\uD83D\uDC4D", fontSize = 28.dpToSp())
+        Text("\uD83D\uDC4E", fontSize = 28.dpToSp())
+        Text("\uD83D\uDD25", fontSize = 28.dpToSp())
+        Text("❤\uFE0F", fontSize = 28.dpToSp())
+        Text("\uD83D\uDC4F", fontSize = 28.dpToSp())
+        Icon(
+            imageVector = Icons.Outlined.AddReaction,
+            contentDescription = "Emojis",
+            tint = MaterialTheme.colorScheme.secondary,
+            modifier = Modifier
+                .size(24.dp)
+                .align(Alignment.CenterVertically)
+        )
+    }
+}
+
+@Composable
+private fun Int.dpToSp(): TextUnit = with(LocalDensity.current) {
+    return dp.toSp()
+}
+
@Preview
@Composable
 fun SheetContentLightPreview(@PreviewParameter(ActionListStateProvider::class) state: ActionListState) =
@ -145,14 +320,7 @@ fun SheetContentLightPreview(@PreviewParameter(ActionListStateProvider::class) s
 fun SheetContentDarkPreview(@PreviewParameter(ActionListStateProvider::class) state: ActionListState) =
    ElementPreviewDark { ContentToPreview(state) }

-@OptIn(ExperimentalMaterialApi::class)
@Composable
 private fun ContentToPreview(state: ActionListState) {
-    ActionListView(
-        state = state,
-        modalBottomSheetState = ModalBottomSheetState(
-            initialValue = ModalBottomSheetValue.Expanded
-        ),
-        onActionSelected = { _, _ -> }
-    )
+    SheetContent(state = state)
 }
--- 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
@ -26,9 +26,11 @@ sealed class TimelineItemAction(
    @DrawableRes val icon: Int,
    val destructive: Boolean = false
 ) {
-    object Forward : TimelineItemAction("Forward", VectorIcons.ArrowForward)
+    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)
 }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/LocalMediaView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/LocalMediaView.kt
@ -32,15 +32,20 @@ import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.lifecycle.Lifecycle
 import androidx.media3.common.MediaItem
-import androidx.media3.common.MimeTypes
 import androidx.media3.common.Player
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.ui.AspectRatioFrameLayout
 import androidx.media3.ui.PlayerView
 import io.element.android.features.messages.impl.media.local.exoplayer.ExoPlayerWrapper
+import io.element.android.features.messages.impl.media.local.pdf.PdfViewer
+import io.element.android.features.messages.impl.media.local.pdf.rememberPdfViewerState
+import io.element.android.libraries.core.mimetype.MimeTypes
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeImage
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeVideo
 import io.element.android.libraries.designsystem.R
 import io.element.android.libraries.designsystem.utils.OnLifecycleEvent
 import me.saket.telephoto.zoomable.ZoomSpec
+import me.saket.telephoto.zoomable.ZoomableState
 import me.saket.telephoto.zoomable.coil.ZoomableAsyncImage
 import me.saket.telephoto.zoomable.rememberZoomableImageState
 import me.saket.telephoto.zoomable.rememberZoomableState
@ -53,14 +58,24 @@ fun LocalMediaView(
    mimeType: String? = localMedia?.mimeType,
    onReady: () -> Unit = {},
 ) {
+    val zoomableState = rememberZoomableState(
+        zoomSpec = ZoomSpec(maxZoomFactor = 5f)
+    )
    when {
-        MimeTypes.isImage(mimeType) -> MediaImageView(
+        mimeType.isMimeTypeImage() -> MediaImageView(
+            localMedia = localMedia,
+            zoomableState = zoomableState,
+            onReady = onReady,
+            modifier = modifier
+        )
+        mimeType.isMimeTypeVideo() -> MediaVideoView(
            localMedia = localMedia,
            onReady = onReady,
            modifier = modifier
        )
-        MimeTypes.isVideo(mimeType) -> MediaVideoView(
+        mimeType == MimeTypes.Pdf -> MediaPDFView(
            localMedia = localMedia,
+            zoomableState = zoomableState,
            onReady = onReady,
            modifier = modifier
        )
@ -71,6 +86,7 @@ fun LocalMediaView(
@Composable
 private fun MediaImageView(
    localMedia: LocalMedia?,
+    zoomableState: ZoomableState,
    onReady: () -> Unit,
    modifier: Modifier = Modifier,
 ) {
@ -81,9 +97,6 @@ private fun MediaImageView(
            contentDescription = null,
        )
    } else {
-        val zoomableState = rememberZoomableState(
-            zoomSpec = ZoomSpec(maxZoomFactor = 3f)
-        )
        val zoomableImageState = rememberZoomableImageState(zoomableState)
        LaunchedEffect(zoomableImageState.isImageDisplayed) {
            if (zoomableImageState.isImageDisplayed) {
@ -154,3 +167,22 @@ fun MediaVideoView(
        }
    }
 }
+
+@Composable
+fun MediaPDFView(
+    localMedia: LocalMedia?,
+    zoomableState: ZoomableState,
+    onReady: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val pdfViewerState = rememberPdfViewerState(
+        model = localMedia?.model,
+        zoomableState = zoomableState
+    )
+    LaunchedEffect(pdfViewerState.isLoaded) {
+        if (pdfViewerState.isLoaded) {
+            onReady()
+        }
+    }
+    PdfViewer(pdfViewerState = pdfViewerState, modifier = modifier)
+}
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/ParcelFileDescriptorFactory.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/ParcelFileDescriptorFactory.kt
@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.media.local.pdf
+
+import android.content.Context
+import android.net.Uri
+import android.os.ParcelFileDescriptor
+import java.io.File
+
+class ParcelFileDescriptorFactory(private val context: Context) {
+
+    fun create(model: Any?) = runCatching {
+        when (model) {
+            is File -> ParcelFileDescriptor.open(model, ParcelFileDescriptor.MODE_READ_ONLY)
+            is Uri -> context.contentResolver.openFileDescriptor(model, "r")!!
+            else -> error(RuntimeException("Can't handle this model"))
+        }
+    }
+}
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/PdfPage.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/PdfPage.kt
@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.media.local.pdf
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.pdf.PdfRenderer
+import androidx.compose.runtime.Stable
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+
+@Stable
+class PdfPage(
+    maxWidth: Int,
+    val pageIndex: Int,
+    private val mutex: Mutex,
+    private val pdfRenderer: PdfRenderer,
+    private val coroutineScope: CoroutineScope,
+) {
+
+    sealed interface State {
+        data class Loading(val width: Int, val height: Int) : State
+        data class Loaded(val bitmap: Bitmap) : State
+    }
+
+    private val renderWidth = maxWidth
+    private val renderHeight: Int
+    private var loadJob: Job? = null
+
+    init {
+        // We are just opening and closing the page to extract data so we can build the Loading state with the correct dimensions.
+        pdfRenderer.openPage(pageIndex).use { page ->
+            renderHeight = (page.height * (renderWidth.toFloat() / page.width)).toInt()
+        }
+    }
+
+    private val mutableStateFlow = MutableStateFlow<State>(
+        State.Loading(
+            width = renderWidth,
+            height = renderHeight
+        )
+    )
+    val stateFlow: StateFlow<State> = mutableStateFlow
+
+    fun load() {
+        loadJob = coroutineScope.launch {
+            val bitmap = mutex.withLock {
+                withContext(Dispatchers.IO) {
+                    pdfRenderer.openPageRenderAndClose(pageIndex, renderWidth, renderHeight)
+                }
+            }
+            mutableStateFlow.value = State.Loaded(bitmap)
+        }
+    }
+
+    fun close() {
+        loadJob?.cancel()
+        when (val loadingState = stateFlow.value) {
+            is State.Loading -> return
+            is State.Loaded -> {
+                loadingState.bitmap.recycle()
+                mutableStateFlow.value = State.Loading(
+                    width = renderWidth,
+                    height = renderHeight
+                )
+            }
+        }
+    }
+
+    private fun PdfRenderer.openPageRenderAndClose(index: Int, bitmapWidth: Int, bitmapHeight: Int): Bitmap {
+        fun createBitmap(bitmapWidth: Int, bitmapHeight: Int): Bitmap {
+            val bitmap = Bitmap.createBitmap(
+                bitmapWidth, bitmapHeight, Bitmap.Config.ARGB_8888
+            )
+            val canvas = Canvas(bitmap)
+            canvas.drawColor(Color.WHITE)
+            canvas.drawBitmap(bitmap, 0f, 0f, null)
+            return bitmap
+        }
+        return openPage(index).use { page ->
+            createBitmap(bitmapWidth, bitmapHeight).apply {
+                page.render(this, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+            }
+        }
+    }
+}
+
+
+
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/PdfRendererManager.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/PdfRendererManager.kt
@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.media.local.pdf
+
+import android.graphics.pdf.PdfRenderer
+import android.os.ParcelFileDescriptor
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+
+class PdfRendererManager(
+    private val parcelFileDescriptor: ParcelFileDescriptor,
+    private val width: Int,
+    private val coroutineScope: CoroutineScope,
+) {
+
+    private val mutex = Mutex()
+    private var pdfRenderer: PdfRenderer? = null
+    private val mutablePdfPages = MutableStateFlow<List<PdfPage>>(emptyList())
+    val pdfPages: StateFlow<List<PdfPage>> = mutablePdfPages
+
+    fun open() {
+        coroutineScope.launch {
+            mutex.withLock {
+                withContext(Dispatchers.IO) {
+                    pdfRenderer = PdfRenderer(parcelFileDescriptor).apply {
+                        (0 until pageCount).map { pageIndex ->
+                            PdfPage(width, pageIndex, mutex, this, coroutineScope)
+                        }.also {
+                            mutablePdfPages.value = it
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fun close() {
+        coroutineScope.launch {
+            mutex.withLock {
+                mutablePdfPages.value.forEach { pdfPage ->
+                    pdfPage.close()
+                }
+                pdfRenderer?.close()
+                parcelFileDescriptor.close()
+            }
+        }
+    }
+}
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/PdfViewer.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/PdfViewer.kt
@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.media.local.pdf
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toImmutableList
+import me.saket.telephoto.zoomable.zoomable
+
+@Composable
+fun PdfViewer(
+    pdfViewerState: PdfViewerState,
+    modifier: Modifier = Modifier,
+) {
+    BoxWithConstraints(
+        modifier = modifier.zoomable(pdfViewerState.zoomableState),
+        contentAlignment = Alignment.Center
+    ) {
+        val maxWidthInPx = maxWidth.dpToPx()
+        DisposableEffect(pdfViewerState) {
+            pdfViewerState.openForWidth(maxWidthInPx)
+            onDispose {
+                pdfViewerState.close()
+            }
+        }
+        val pdfPages = pdfViewerState.getPages()
+        PdfPagesView(pdfPages.toImmutableList(), pdfViewerState.lazyListState)
+    }
+}
+
+@Composable
+private fun PdfPagesView(
+    pdfPages: ImmutableList<PdfPage>,
+    lazyListState: LazyListState,
+    modifier: Modifier = Modifier,
+) {
+    LazyColumn(
+        modifier = modifier.fillMaxSize(),
+        state = lazyListState,
+        verticalArrangement = Arrangement.spacedBy(4.dp, Alignment.CenterVertically)
+
+    ) {
+        items(pdfPages.size) { index ->
+            val pdfPage = pdfPages[index]
+            PdfPageView(pdfPage)
+        }
+    }
+}
+
+@Composable
+private fun PdfPageView(
+    pdfPage: PdfPage,
+    modifier: Modifier = Modifier,
+) {
+    val pdfPageState by pdfPage.stateFlow.collectAsState()
+    DisposableEffect(pdfPage) {
+        pdfPage.load()
+        onDispose {
+            pdfPage.close()
+        }
+    }
+    when (val state = pdfPageState) {
+        is PdfPage.State.Loaded -> {
+            Image(
+                bitmap = state.bitmap.asImageBitmap(),
+                contentDescription = "Page ${pdfPage.pageIndex}",
+                contentScale = ContentScale.FillWidth,
+                modifier = modifier.fillMaxWidth()
+            )
+        }
+        is PdfPage.State.Loading -> {
+            Box(
+                modifier = modifier
+                    .fillMaxWidth()
+                    .height(state.height.pxToDp())
+                    .background(color = Color.White)
+            )
+        }
+    }
+}
+
+@Composable
+private fun Int.pxToDp() = with(LocalDensity.current) { this@pxToDp.toDp() }
+
+@Composable
+private fun Dp.dpToPx() = with(LocalDensity.current) { this@dpToPx.roundToPx() }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/PdfViewerState.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/media/local/pdf/PdfViewerState.kt
@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.media.local.pdf
+
+import android.content.Context
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import kotlinx.coroutines.CoroutineScope
+import me.saket.telephoto.zoomable.ZoomableState
+import me.saket.telephoto.zoomable.rememberZoomableState
+
+@Stable
+class PdfViewerState(
+    private val model: Any?,
+    private val coroutineScope: CoroutineScope,
+    private val context: Context,
+    val zoomableState: ZoomableState,
+    val lazyListState: LazyListState,
+) {
+
+    var isLoaded by mutableStateOf(false)
+    private var pdfRendererManager by mutableStateOf<PdfRendererManager?>(null)
+
+    @Composable
+    fun getPages(): List<PdfPage>{
+        return pdfRendererManager?.run {
+            pdfPages.collectAsState().value
+        }?: emptyList()
+    }
+
+    fun openForWidth(maxWidth: Int) {
+        ParcelFileDescriptorFactory(context).create(model)
+            .onSuccess {
+                pdfRendererManager = PdfRendererManager(it, maxWidth, coroutineScope).apply {
+                    open()
+                }
+                isLoaded = true
+            }
+    }
+
+    fun close() {
+        pdfRendererManager?.close()
+        isLoaded = false
+    }
+}
+
+@Composable
+fun rememberPdfViewerState(
+    model: Any?,
+    zoomableState: ZoomableState = rememberZoomableState(),
+    lazyListState: LazyListState = rememberLazyListState(),
+    context: Context = LocalContext.current,
+    coroutineScope: CoroutineScope = rememberCoroutineScope(),
+): PdfViewerState {
+    return remember(model) {
+        PdfViewerState(
+            model = model,
+            coroutineScope = coroutineScope,
+            context = context,
+            zoomableState = zoomableState,
+            lazyListState = lazyListState
+        )
+    }
+}
--- 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
@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.messagecomposer
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.ExperimentalMaterialApi
+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.PhotoCamera
+import androidx.compose.material.icons.filled.Videocam
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import io.element.android.features.messages.impl.R
+import io.element.android.libraries.androidutils.ui.hideKeyboard
+import io.element.android.libraries.designsystem.theme.components.Icon
+import io.element.android.libraries.designsystem.theme.components.ModalBottomSheet
+import io.element.android.libraries.designsystem.theme.components.Text
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+internal fun AttachmentsBottomSheet(
+    state: MessageComposerState,
+    modifier: Modifier = Modifier,
+) {
+    val localView = LocalView.current
+    var isVisible by rememberSaveable { mutableStateOf(state.showAttachmentSourcePicker) }
+
+    BackHandler(enabled = isVisible) {
+        isVisible = false
+    }
+
+    LaunchedEffect(state.showAttachmentSourcePicker) {
+        if (state.showAttachmentSourcePicker) {
+            // We need to use this instead of `LocalFocusManager.clearFocus()` to hide the keyboard when focus is on an Android View
+            localView.hideKeyboard()
+            isVisible = true
+        } else {
+            isVisible = false
+        }
+    }
+    // Send 'DismissAttachmentMenu' event when the bottomsheet was just hidden
+    LaunchedEffect(isVisible) {
+        if (!isVisible) {
+            state.eventSink(MessageComposerEvents.DismissAttachmentMenu)
+        }
+    }
+
+    if (isVisible) {
+        ModalBottomSheet(
+            modifier = modifier,
+            onDismissRequest = { isVisible = false }
+        ) {
+            AttachmentSourcePickerMenu(eventSink = state.eventSink)
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterialApi::class)
+@Composable
+internal fun AttachmentSourcePickerMenu(
+    eventSink: (MessageComposerEvents) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier.padding(bottom = 32.dp)
+//        .navigationBarsPadding() - FIXME after https://issuetracker.google.com/issues/275849044
+    ) {
+        ListItem(
+            modifier = Modifier.clickable { eventSink(MessageComposerEvents.PickAttachmentSource.FromGallery) },
+            icon = { Icon(Icons.Default.Collections, null) },
+            text = { Text(stringResource(R.string.screen_room_attachment_source_gallery)) },
+        )
+        ListItem(
+            modifier = Modifier.clickable { eventSink(MessageComposerEvents.PickAttachmentSource.FromFiles) },
+            icon = { Icon(Icons.Default.AttachFile, null) },
+            text = { Text(stringResource(R.string.screen_room_attachment_source_files)) },
+        )
+        ListItem(
+            modifier = Modifier.clickable { eventSink(MessageComposerEvents.PickAttachmentSource.PhotoFromCamera) },
+            icon = { Icon(Icons.Default.PhotoCamera, null) },
+            text = { Text(stringResource(R.string.screen_room_attachment_source_camera_photo)) },
+        )
+        ListItem(
+            modifier = Modifier.clickable { eventSink(MessageComposerEvents.PickAttachmentSource.VideoFromCamera) },
+            icon = { Icon(Icons.Default.Videocam, null) },
+            text = { Text(stringResource(R.string.screen_room_attachment_source_camera_video)) },
+        )
+    }
+}
--- 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
@ -16,6 +16,7 @@

 package io.element.android.features.messages.impl.messagecomposer

+import androidx.compose.foundation.layout.Box
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.tooling.preview.Preview
@ -46,21 +47,25 @@ fun MessageComposerView(
        state.eventSink(MessageComposerEvents.UpdateText(text))
    }

-    TextComposer(
-        onSendMessage = ::sendMessage,
-        fullscreen = state.isFullScreen,
-        onFullscreenToggle = ::onFullscreenToggle,
-        composerMode = state.mode,
-        onCloseSpecialMode = ::onCloseSpecialMode,
-        onComposerTextChange = ::onComposerTextChange,
-        onAddAttachment = {
-            state.eventSink(MessageComposerEvents.AddAttachment)
-        },
-        composerCanSendMessage = state.isSendButtonVisible,
-        composerText = state.text?.charSequence?.toString(),
-        isInDarkMode = !ElementTheme.colors.isLight,
-        modifier = modifier
-    )
+    Box {
+        AttachmentsBottomSheet(state = state)
+
+        TextComposer(
+            onSendMessage = ::sendMessage,
+            fullscreen = state.isFullScreen,
+            onFullscreenToggle = ::onFullscreenToggle,
+            composerMode = state.mode,
+            onCloseSpecialMode = ::onCloseSpecialMode,
+            onComposerTextChange = ::onComposerTextChange,
+            onAddAttachment = {
+                state.eventSink(MessageComposerEvents.AddAttachment)
+            },
+            composerCanSendMessage = state.isSendButtonVisible,
+            composerText = state.text?.charSequence?.toString(),
+            isInDarkMode = !ElementTheme.colors.isLight,
+            modifier = modifier
+        )
+    }
 }

@Preview
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/event/TimelineItemFileView.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/event/TimelineItemFileView.kt
@ -18,21 +18,24 @@ package io.element.android.features.messages.impl.timeline.components.event

 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Attachment
+import androidx.compose.material.icons.outlined.Attachment
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemFileContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemFileContentProvider
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
@ -47,7 +50,6 @@ fun TimelineItemFileView(
 ) {
    Row(
        modifier = modifier,
-        verticalAlignment = Alignment.CenterVertically
    ) {
        Box(
            modifier = Modifier
@ -57,16 +59,23 @@ fun TimelineItemFileView(
            contentAlignment = Alignment.Center,
        ) {
            Icon(
-                imageVector = Icons.Filled.Attachment,
-                contentDescription = "OpenFile"
+                imageVector = Icons.Outlined.Attachment,
+                contentDescription = "OpenFile",
+                modifier = Modifier.size(16.dp).rotate(-45f),
+            )
+        }
+        Column(modifier = Modifier.padding(horizontal = 8.dp),) {
+            Text(
+                text = content.body,
+                maxLines = 2,
+                fontSize = 16.sp,
+                overflow = TextOverflow.Ellipsis
+            )
+            Text(
+                text = content.fileExtensionAndSize,
+                color = MaterialTheme.colorScheme.secondary,
            )
        }
-        Text(
-            text = content.body,
-            modifier = Modifier.padding(horizontal = 8.dp),
-            maxLines = 1,
-            overflow = TextOverflow.Ellipsis,
-        )
    }
 }

--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentMessageFactory.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentMessageFactory.kt
@ -24,6 +24,7 @@ import io.element.android.features.messages.impl.timeline.model.event.TimelineIt
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemTextContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVideoContent
+import io.element.android.features.messages.impl.timeline.util.FileSizeFormatter
 import io.element.android.features.messages.impl.timeline.util.toHtmlDocument
 import io.element.android.libraries.matrix.api.timeline.item.event.EmoteMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageType
@ -34,7 +35,9 @@ import io.element.android.libraries.matrix.api.timeline.item.event.TextMessageTy
 import io.element.android.libraries.matrix.api.timeline.item.event.VideoMessageType
 import javax.inject.Inject

-class TimelineItemContentMessageFactory @Inject constructor() {
+class TimelineItemContentMessageFactory @Inject constructor(
+    private val fileSizeFormatter: FileSizeFormatter
+) {

    fun create(content: MessageContent): TimelineItemEventContent {
        return when (val messageType = content.type) {
@ -74,7 +77,9 @@ class TimelineItemContentMessageFactory @Inject constructor() {
                thumbnailSource = messageType.info?.thumbnailSource,
                fileSource = messageType.source,
                mimeType = messageType.info?.mimetype,
-                size = messageType.info?.size,
+                formattedFileSize = messageType.info?.size?.let {
+                    fileSizeFormatter.format(it)
+                },
            )
            is NoticeMessageType -> TimelineItemNoticeContent(
                body = messageType.body,
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemFileContent.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemFileContent.kt
@ -22,8 +22,17 @@ data class TimelineItemFileContent(
    val body: String,
    val fileSource: MediaSource,
    val thumbnailSource: MediaSource?,
-    val size: Long?,
+    val formattedFileSize: String?,
    val mimeType: String?,
 ) : TimelineItemEventContent {
    override val type: String = "TimelineItemFileContent"
+
+    private val fileExtension = body.substringAfterLast('.', "").uppercase()
+    val fileExtensionAndSize = buildString {
+        append(fileExtension)
+        if (formattedFileSize != null) {
+            append(' ')
+            append("($formattedFileSize)")
+        }
+    }
 }
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemFileContentProvider.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemFileContentProvider.kt
@ -25,7 +25,7 @@ open class TimelineItemFileContentProvider : PreviewParameterProvider<TimelineIt
        get() = sequenceOf(
            aTimelineItemFileContent("A file.pdf"),
            aTimelineItemFileContent("A bigger name file.pdf"),
-            aTimelineItemFileContent("An even bigger file name which doesn't fit.pdf"),
+            aTimelineItemFileContent("An even bigger bigger bigger bigger bigger bigger bigger file name which doesn't fit .pdf"),
        )
 }

@ -34,5 +34,5 @@ fun aTimelineItemFileContent(fileName: String) = TimelineItemFileContent(
    thumbnailSource = MediaSource(url = ""),
    fileSource = MediaSource(url = ""),
    mimeType = MimeTypes.OctetStream,
-    size = 100
+    formattedFileSize = "100kB"
 )
--- a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/util/FileSizeFormatter.kt
+++ b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/util/FileSizeFormatter.kt
@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.timeline.util
+
+import android.content.Context
+import android.text.format.Formatter
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.ApplicationContext
+import javax.inject.Inject
+
+interface FileSizeFormatter {
+    /**
+     * Formats a content size to be in the form of bytes, kilobytes, megabytes, etc.
+     */
+    fun format(fileSize: Long): String
+}
+
+@ContributesBinding(AppScope::class)
+class AndroidFileSizeFormatter @Inject constructor(@ApplicationContext private val context: Context) : FileSizeFormatter {
+    override fun format(fileSize: Long): String {
+        return Formatter.formatShortFileSize(context, fileSize)
+    }
+}
--- a/features/messages/impl/src/test/kotlin/io/element/android/features/messages/MessagesPresenterTest.kt
+++ b/features/messages/impl/src/test/kotlin/io/element/android/features/messages/MessagesPresenterTest.kt
@ -31,6 +31,8 @@ import io.element.android.features.messages.impl.messagecomposer.MessageComposer
 import io.element.android.features.messages.impl.timeline.TimelinePresenter
 import io.element.android.features.messages.media.FakeLocalMediaFactory
 import io.element.android.features.networkmonitor.test.FakeNetworkMonitor
+import io.element.android.libraries.core.meta.BuildMeta
+import io.element.android.libraries.core.meta.BuildType
 import io.element.android.libraries.designsystem.utils.SnackbarDispatcher
 import io.element.android.libraries.featureflag.test.FakeFeatureFlagService
 import io.element.android.libraries.matrix.api.room.MatrixRoom
@ -132,6 +134,32 @@ class MessagesPresenterTest {
        }
    }

+    @Test
+    fun `present - handle action report content`() = runTest {
+        val presenter = createMessagePresenter()
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(MessagesEvents.HandleAction(TimelineItemAction.ReportContent, aMessageEvent()))
+            // Still a TODO in the code
+        }
+    }
+
+    @Test
+    fun `present - handle action show developer info`() = runTest {
+        val presenter = createMessagePresenter()
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(MessagesEvents.HandleAction(TimelineItemAction.Developer, aMessageEvent()))
+            // Still a TODO in the code
+        }
+    }
+
    private fun TestScope.createMessagePresenter(
        matrixRoom: MatrixRoom = FakeMatrixRoom()
    ): MessagesPresenter {
@ -148,7 +176,20 @@ class MessagesPresenterTest {
            timelineItemsFactory = aTimelineItemsFactory(),
            room = matrixRoom,
        )
-        val actionListPresenter = ActionListPresenter()
+        val buildMeta = BuildMeta(
+            buildType = BuildType.DEBUG,
+            isDebuggable = true,
+            applicationId = "",
+            applicationName = "",
+            lowPrivacyLoggingEnabled = true,
+            versionName = "",
+            gitRevision = "",
+            gitBranchName = "",
+            gitRevisionDate = "",
+            flavorDescription = "",
+            flavorShortDescription = "",
+        )
+        val actionListPresenter = ActionListPresenter(buildMeta = buildMeta)
        return MessagesPresenter(
            room = matrixRoom,
            composerPresenter = messageComposerPresenter,
--- a/features/messages/impl/src/test/kotlin/io/element/android/features/messages/actionlist/ActionListPresenterTest.kt
+++ b/features/messages/impl/src/test/kotlin/io/element/android/features/messages/actionlist/ActionListPresenterTest.kt
@ -29,6 +29,8 @@ import io.element.android.features.messages.impl.timeline.model.TimelineItemReac
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemRedactedContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemTextContent
+import io.element.android.libraries.core.meta.BuildMeta
+import io.element.android.libraries.core.meta.BuildType
 import io.element.android.libraries.designsystem.components.avatar.AvatarData
 import io.element.android.libraries.matrix.api.timeline.item.event.EventSendState
 import io.element.android.libraries.matrix.test.AN_EVENT_ID
@ -42,7 +44,7 @@ import org.junit.Test
 class ActionListPresenterTest {
    @Test
    fun `present - initial state`() = runTest {
-        val presenter = ActionListPresenter()
+        val presenter = anActionListPresenter(isBuildDebuggable = true)
        moleculeFlow(RecompositionClock.Immediate) {
            presenter.present()
        }.test {
@ -53,7 +55,7 @@ class ActionListPresenterTest {

    @Test
    fun `present - compute for message from me redacted`() = runTest {
-        val presenter = ActionListPresenter()
+        val presenter = anActionListPresenter(isBuildDebuggable = true)
        moleculeFlow(RecompositionClock.Immediate) {
            presenter.present()
        }.test {
@ -67,6 +69,8 @@ class ActionListPresenterTest {
                ActionListState.Target.Success(
                    messageEvent,
                    persistentListOf(
+                        TimelineItemAction.Copy,
+                        TimelineItemAction.Developer,
                    )
                )
            )
@ -75,9 +79,10 @@ class ActionListPresenterTest {
        }
    }

+
    @Test
    fun `present - compute for message from others redacted`() = runTest {
-        val presenter = ActionListPresenter()
+        val presenter = anActionListPresenter(isBuildDebuggable = true)
        moleculeFlow(RecompositionClock.Immediate) {
            presenter.present()
        }.test {
@ -91,6 +96,8 @@ class ActionListPresenterTest {
                ActionListState.Target.Success(
                    messageEvent,
                    persistentListOf(
+                        TimelineItemAction.Copy,
+                        TimelineItemAction.Developer,
                    )
                )
            )
@ -101,7 +108,7 @@ class ActionListPresenterTest {

    @Test
    fun `present - compute for others message`() = runTest {
-        val presenter = ActionListPresenter()
+        val presenter = anActionListPresenter(isBuildDebuggable = true)
        moleculeFlow(RecompositionClock.Immediate) {
            presenter.present()
        }.test {
@ -121,6 +128,8 @@ class ActionListPresenterTest {
                        TimelineItemAction.Reply,
                        TimelineItemAction.Forward,
                        TimelineItemAction.Copy,
+                        TimelineItemAction.Developer,
+                        TimelineItemAction.ReportContent,
                    )
                )
            )
@ -131,7 +140,7 @@ class ActionListPresenterTest {

    @Test
    fun `present - compute for my message`() = runTest {
-        val presenter = ActionListPresenter()
+        val presenter = anActionListPresenter(isBuildDebuggable = true)
        moleculeFlow(RecompositionClock.Immediate) {
            presenter.present()
        }.test {
@ -150,8 +159,41 @@ class ActionListPresenterTest {
                    persistentListOf(
                        TimelineItemAction.Reply,
                        TimelineItemAction.Forward,
-                        TimelineItemAction.Copy,
                        TimelineItemAction.Edit,
+                        TimelineItemAction.Copy,
+                        TimelineItemAction.Developer,
+                        TimelineItemAction.Redact,
+                    )
+                )
+            )
+            initialState.eventSink.invoke(ActionListEvents.Clear)
+            assertThat(awaitItem().target).isEqualTo(ActionListState.Target.None)
+        }
+    }
+
+    @Test
+    fun `present - compute message in non-debuggable build`() = runTest {
+        val presenter = anActionListPresenter(isBuildDebuggable = false)
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            val messageEvent = aMessageEvent(
+                isMine = true,
+                content = TimelineItemTextContent(body = A_MESSAGE, htmlDocument = null, isEdited = false)
+            )
+            initialState.eventSink.invoke(ActionListEvents.ComputeForMessage(messageEvent))
+            // val loadingState = awaitItem()
+            // assertThat(loadingState.target).isEqualTo(ActionListState.Target.Loading(messageEvent))
+            val successState = awaitItem()
+            assertThat(successState.target).isEqualTo(
+                ActionListState.Target.Success(
+                    messageEvent,
+                    persistentListOf(
+                        TimelineItemAction.Reply,
+                        TimelineItemAction.Forward,
+                        TimelineItemAction.Edit,
+                        TimelineItemAction.Copy,
                        TimelineItemAction.Redact,
                    )
                )
@ -162,6 +204,34 @@ class ActionListPresenterTest {
    }
 }

+private fun aBuildMeta(
+    buildType: BuildType = BuildType.DEBUG,
+    isDebuggable: Boolean = true,
+    applicationName: String = "",
+    applicationId: String = "",
+    lowPrivacyLoggingEnabled: Boolean = true,
+    versionName: String = "",
+    gitRevision: String = "",
+    gitRevisionDate: String = "",
+    gitBranchName: String = "",
+    flavorDescription: String = "",
+    flavorShortDescription: String = "",
+) = BuildMeta(
+    buildType,
+    isDebuggable,
+    applicationName,
+    applicationId,
+    lowPrivacyLoggingEnabled,
+    versionName,
+    gitRevision,
+    gitRevisionDate,
+    gitBranchName,
+    flavorDescription,
+    flavorShortDescription
+)
+
+private fun anActionListPresenter(isBuildDebuggable: Boolean) = ActionListPresenter(buildMeta = aBuildMeta(isDebuggable = isBuildDebuggable))
+
 private fun aMessageEvent(
    isMine: Boolean,
    content: TimelineItemEventContent,
--- a/features/messages/impl/src/test/kotlin/io/element/android/features/messages/fixtures/timelineItemsFactory.kt
+++ b/features/messages/impl/src/test/kotlin/io/element/android/features/messages/fixtures/timelineItemsFactory.kt
@ -31,6 +31,7 @@ import io.element.android.features.messages.impl.timeline.factories.event.Timeli
 import io.element.android.features.messages.impl.timeline.factories.virtual.TimelineItemDaySeparatorFactory
 import io.element.android.features.messages.impl.timeline.factories.virtual.TimelineItemVirtualFactory
 import io.element.android.features.messages.impl.timeline.groups.TimelineItemGrouper
+import io.element.android.features.messages.timeline.FakeFileSizeFormatter
 import io.element.android.libraries.dateformatter.test.FakeDaySeparatorFormatter
 import io.element.android.libraries.eventformatter.api.TimelineEventFormatter
 import io.element.android.libraries.matrix.api.timeline.item.event.EventTimelineItem
@ -42,7 +43,7 @@ internal fun aTimelineItemsFactory(): TimelineItemsFactory {
        dispatchers = testCoroutineDispatchers(),
        eventItemFactory = TimelineItemEventFactory(
            TimelineItemContentFactory(
-                messageFactory = TimelineItemContentMessageFactory(),
+                messageFactory = TimelineItemContentMessageFactory(FakeFileSizeFormatter()),
                redactedMessageFactory = TimelineItemContentRedactedFactory(),
                stickerFactory = TimelineItemContentStickerFactory(),
                utdFactory = TimelineItemContentUTDFactory(),
--- a/features/messages/impl/src/test/kotlin/io/element/android/features/messages/timeline/FakeFileSizeFormatter.kt
+++ b/features/messages/impl/src/test/kotlin/io/element/android/features/messages/timeline/FakeFileSizeFormatter.kt
@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.timeline
+
+import io.element.android.features.messages.impl.timeline.util.FileSizeFormatter
+
+class FakeFileSizeFormatter : FileSizeFormatter {
+    override fun format(fileSize: Long): String {
+        return "$fileSize Bytes"
+    }
+}