Timeline Action : refactor how it's computed and align with iOS

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

@@ -20,6 +20,7 @@ import android.os.Build
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.State
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
@@ -131,10 +132,9 @@ class MessagesPresenter @AssistedInject constructor(
         val readReceiptBottomSheetState = readReceiptBottomSheetPresenter.present()
 
         val syncUpdateFlow = room.syncUpdateFlow.collectAsState()
-        val userHasPermissionToSendMessage by room.canSendMessageAsState(type = MessageEventType.ROOM_MESSAGE, updateKey = syncUpdateFlow.value)
-        val userHasPermissionToRedactOwn by room.canRedactOwnAsState(updateKey = syncUpdateFlow.value)
-        val userHasPermissionToRedactOther by room.canRedactOtherAsState(updateKey = syncUpdateFlow.value)
-        val userHasPermissionToSendReaction by room.canSendMessageAsState(type = MessageEventType.REACTION, updateKey = syncUpdateFlow.value)
+
+        val userEventPermissions by userEventPermissions(syncUpdateFlow.value)
+
         val roomName: AsyncData<String> by remember {
             derivedStateOf { roomInfo?.name?.let { AsyncData.Success(it) } ?: AsyncData.Uninitialized }
         }
@@ -211,11 +211,8 @@ class MessagesPresenter @AssistedInject constructor(
             roomName = roomName,
             roomAvatar = roomAvatar,
             heroes = heroes,
-            userHasPermissionToSendMessage = userHasPermissionToSendMessage,
-            userHasPermissionToRedactOwn = userHasPermissionToRedactOwn,
-            userHasPermissionToRedactOther = userHasPermissionToRedactOther,
-            userHasPermissionToSendReaction = userHasPermissionToSendReaction,
             composerState = composerState,
+            userEventPermissions = userEventPermissions,
             voiceMessageComposerState = voiceMessageComposerState,
             timelineState = timelineState,
             typingNotificationState = typingNotificationState,
@@ -235,6 +232,24 @@ class MessagesPresenter @AssistedInject constructor(
         )
     }
 
+    @Composable
+    private fun userEventPermissions(updateKey: Long): State<UserEventPermissions> {
+        val userHasPermissionToSendMessage by room.canSendMessageAsState(type = MessageEventType.ROOM_MESSAGE, updateKey = updateKey)
+        val userHasPermissionToRedactOwn by room.canRedactOwnAsState(updateKey = updateKey)
+        val userHasPermissionToRedactOther by room.canRedactOtherAsState(updateKey = updateKey)
+        val userHasPermissionToSendReaction by room.canSendMessageAsState(type = MessageEventType.REACTION, updateKey = updateKey)
+        return remember {
+            derivedStateOf {
+                UserEventPermissions(
+                    canSendMessage = userHasPermissionToSendMessage,
+                    canRedactOwn = userHasPermissionToRedactOwn,
+                    canRedactOther = userHasPermissionToRedactOther,
+                    canSendReaction = userHasPermissionToSendReaction,
+                )
+            }
+        }
+    }
+
     private fun MatrixRoomInfo.avatarData(): AvatarData {
         return AvatarData(
             id = id.value,

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesState.kt

@@ -37,10 +37,7 @@ data class MessagesState(
     val roomName: AsyncData<String>,
     val roomAvatar: AsyncData<AvatarData>,
     val heroes: ImmutableList<AvatarData>,
-    val userHasPermissionToSendMessage: Boolean,
-    val userHasPermissionToRedactOwn: Boolean,
-    val userHasPermissionToRedactOther: Boolean,
-    val userHasPermissionToSendReaction: Boolean,
+    val userEventPermissions: UserEventPermissions,
     val composerState: MessageComposerState,
     val voiceMessageComposerState: VoiceMessageComposerState,
     val timelineState: TimelineState,

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesStateProvider.kt

@@ -53,7 +53,7 @@ open class MessagesStateProvider : PreviewParameterProvider<MessagesState> {
             aMessagesState(),
             aMessagesState(hasNetworkConnection = false),
             aMessagesState(composerState = aMessageComposerState(showAttachmentSourcePicker = true)),
-            aMessagesState(userHasPermissionToSendMessage = false),
+            aMessagesState(userEventPermissions = aUserEventPermissions(canSendMessage = false)),
             aMessagesState(showReinvitePrompt = true),
             aMessagesState(
                 roomName = AsyncData.Uninitialized,
@@ -93,10 +93,7 @@ open class MessagesStateProvider : PreviewParameterProvider<MessagesState> {
 fun aMessagesState(
     roomName: AsyncData<String> = AsyncData.Success("Room name"),
     roomAvatar: AsyncData<AvatarData> = AsyncData.Success(AvatarData("!id:domain", "Room name", size = AvatarSize.TimelineRoom)),
-    userHasPermissionToSendMessage: Boolean = true,
-    userHasPermissionToRedactOwn: Boolean = false,
-    userHasPermissionToRedactOther: Boolean = false,
-    userHasPermissionToSendReaction: Boolean = true,
+    userEventPermissions: UserEventPermissions = aUserEventPermissions(),
     composerState: MessageComposerState = aMessageComposerState(
         textEditorState = TextEditorState.Rich(aRichTextEditorState(initialText = "Hello", initialFocus = true)),
         isFullScreen = false,
@@ -122,10 +119,7 @@ fun aMessagesState(
     roomName = roomName,
     roomAvatar = roomAvatar,
     heroes = persistentListOf(),
-    userHasPermissionToSendMessage = userHasPermissionToSendMessage,
-    userHasPermissionToRedactOwn = userHasPermissionToRedactOwn,
-    userHasPermissionToRedactOther = userHasPermissionToRedactOther,
-    userHasPermissionToSendReaction = userHasPermissionToSendReaction,
+    userEventPermissions = userEventPermissions,
     composerState = composerState,
     voiceMessageComposerState = voiceMessageComposerState,
     typingNotificationState = aTypingNotificationState(),
@@ -145,6 +139,18 @@ fun aMessagesState(
     eventSink = eventSink,
 )
 
+fun aUserEventPermissions(
+    canRedactOwn: Boolean = false,
+    canRedactOther: Boolean = false,
+    canSendMessage: Boolean = true,
+    canSendReaction: Boolean = true,
+) = UserEventPermissions(
+    canRedactOwn = canRedactOwn,
+    canRedactOther = canRedactOther,
+    canSendMessage = canSendMessage,
+    canSendReaction = canSendReaction,
+)
+
 fun aReactionSummaryState(
     target: ReactionSummaryState.Summary? = null,
     eventSink: (ReactionSummaryEvents) -> Unit = {}

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

@@ -154,10 +154,7 @@ fun MessagesView(
         state.actionListState.eventSink(
             ActionListEvents.ComputeForMessage(
                 event = event,
-                canRedactOwn = state.userHasPermissionToRedactOwn,
-                canRedactOther = state.userHasPermissionToRedactOther,
-                canSendMessage = state.userHasPermissionToSendMessage,
-                canSendReaction = state.userHasPermissionToSendReaction,
+                userEventPermissions = state.userEventPermissions,
             )
         )
     }
@@ -408,7 +405,7 @@ private fun MessagesViewComposerBottomSheetContents(
     subcomposing: Boolean,
     state: MessagesState,
 ) {
-    if (state.userHasPermissionToSendMessage) {
+    if (state.userEventPermissions.canSendMessage) {
         Column(modifier = Modifier.fillMaxWidth()) {
             MentionSuggestionsPickerView(
                 modifier = Modifier

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/UserEventPermissions.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2024 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
+ *
+ *     https://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
+
+/**
+ * Represents the permissions a user has in a room.
+ * It's dependent of the user's power level in the room.
+ */
+data class UserEventPermissions(
+    val canRedactOwn: Boolean,
+    val canRedactOther: Boolean,
+    val canSendMessage: Boolean,
+    val canSendReaction: Boolean,
+)

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/actionlist/ActionListEvents.kt

@@ -16,15 +16,13 @@
 
 package io.element.android.features.messages.impl.actionlist
 
+import io.element.android.features.messages.impl.UserEventPermissions
 import io.element.android.features.messages.impl.timeline.model.TimelineItem
 
 sealed interface ActionListEvents {
     data object Clear : ActionListEvents
     data class ComputeForMessage(
         val event: TimelineItem.Event,
-        val canRedactOwn: Boolean,
-        val canRedactOther: Boolean,
-        val canSendMessage: Boolean,
-        val canSendReaction: Boolean,
+        val userEventPermissions: UserEventPermissions,
     ) : ActionListEvents
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/actionlist/ActionListPresenter.kt

@@ -23,15 +23,17 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import io.element.android.features.messages.impl.UserEventPermissions
 import io.element.android.features.messages.impl.actionlist.model.TimelineItemAction
 import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemCallNotifyContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemLegacyCallInviteContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemPollContent
 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.TimelineItemVoiceContent
 import io.element.android.features.messages.impl.timeline.model.event.canBeCopied
+import io.element.android.features.messages.impl.timeline.model.event.canBeForwarded
 import io.element.android.features.messages.impl.timeline.model.event.canReact
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.preferences.api.store.AppPreferencesStore
@@ -58,10 +60,7 @@ class ActionListPresenter @Inject constructor(
                 ActionListEvents.Clear -> target.value = ActionListState.Target.None
                 is ActionListEvents.ComputeForMessage -> localCoroutineScope.computeForMessage(
                     timelineItem = event.event,
-                    userCanRedactOwn = event.canRedactOwn,
-                    userCanRedactOther = event.canRedactOther,
-                    userCanSendMessage = event.canSendMessage,
-                    userCanSendReaction = event.canSendReaction,
+                    usersEventPermissions = event.userEventPermissions,
                     isDeveloperModeEnabled = isDeveloperModeEnabled,
                     target = target,
                 )
@@ -76,136 +75,18 @@ class ActionListPresenter @Inject constructor(
 
     private fun CoroutineScope.computeForMessage(
         timelineItem: TimelineItem.Event,
-        userCanRedactOwn: Boolean,
-        userCanRedactOther: Boolean,
-        userCanSendMessage: Boolean,
-        userCanSendReaction: Boolean,
+        usersEventPermissions: UserEventPermissions,
         isDeveloperModeEnabled: Boolean,
         target: MutableState<ActionListState.Target>
     ) = launch {
         target.value = ActionListState.Target.Loading(timelineItem)
-        val canRedact = timelineItem.isMine && userCanRedactOwn || !timelineItem.isMine && userCanRedactOther
-        val actions =
-            when (timelineItem.content) {
-                is TimelineItemCallNotifyContent -> {
-                    if (isDeveloperModeEnabled) {
-                        listOf(TimelineItemAction.ViewSource)
-                    } else {
-                        emptyList()
-                    }
-                }
-                is TimelineItemRedactedContent -> {
-                    if (isDeveloperModeEnabled) {
-                        listOf(TimelineItemAction.ViewSource)
-                    } else {
-                        emptyList()
-                    }
-                }
-                is TimelineItemStateContent -> {
-                    buildList {
-                        add(TimelineItemAction.Copy)
-                        if (timelineItem.isRemote) {
-                            add(TimelineItemAction.CopyLink)
-                        }
-                        if (isDeveloperModeEnabled) {
-                            add(TimelineItemAction.ViewSource)
-                        }
-                    }
-                }
-                is TimelineItemPollContent -> {
-                    val canEndPoll = timelineItem.isRemote &&
-                        !timelineItem.content.isEnded &&
-                        (timelineItem.isMine || canRedact)
-                    buildList {
-                        if (timelineItem.isRemote) {
-                            // Can only reply or forward messages already uploaded to the server
-                            add(TimelineItemAction.Reply)
-                        }
-                        if (timelineItem.isRemote && timelineItem.isEditable) {
-                            add(TimelineItemAction.Edit)
-                        }
-                        if (canEndPoll) {
-                            add(TimelineItemAction.EndPoll)
-                        }
-                        if (timelineItem.content.canBeCopied()) {
-                            add(TimelineItemAction.Copy)
-                        }
-                        if (timelineItem.isRemote) {
-                            add(TimelineItemAction.CopyLink)
-                        }
-                        if (isDeveloperModeEnabled) {
-                            add(TimelineItemAction.ViewSource)
-                        }
-                        if (!timelineItem.isMine) {
-                            add(TimelineItemAction.ReportContent)
-                        }
-                        if (canRedact) {
-                            add(TimelineItemAction.Redact)
-                        }
-                    }
-                }
-                is TimelineItemVoiceContent -> {
-                    buildList {
-                        if (timelineItem.isRemote) {
-                            add(TimelineItemAction.Reply)
-                            add(TimelineItemAction.Forward)
-                            add(TimelineItemAction.CopyLink)
-                        }
-                        if (isDeveloperModeEnabled) {
-                            add(TimelineItemAction.ViewSource)
-                        }
-                        if (!timelineItem.isMine) {
-                            add(TimelineItemAction.ReportContent)
-                        }
-                        if (canRedact) {
-                            add(TimelineItemAction.Redact)
-                        }
-                    }
-                }
-                is TimelineItemLegacyCallInviteContent -> {
-                    buildList {
-                        if (isDeveloperModeEnabled) {
-                            add(TimelineItemAction.ViewSource)
-                        }
-                    }
-                }
-                else -> buildList<TimelineItemAction> {
-                    if (timelineItem.isRemote) {
-                        // Can only reply or forward messages already uploaded to the server
-                        if (userCanSendMessage) {
-                            if (timelineItem.isThreaded) {
-                                add(TimelineItemAction.ReplyInThread)
-                            } else {
-                                add(TimelineItemAction.Reply)
-                            }
-                        }
-                        // Stickers can't be forwarded (yet) so we don't show the option
-                        // See https://github.com/element-hq/element-x-android/issues/2161
-                        if (!timelineItem.isSticker) {
-                            add(TimelineItemAction.Forward)
-                        }
-                    }
-                    if (timelineItem.isEditable) {
-                        add(TimelineItemAction.Edit)
-                    }
-                    if (timelineItem.content.canBeCopied()) {
-                        add(TimelineItemAction.Copy)
-                    }
-                    if (timelineItem.isRemote) {
-                        add(TimelineItemAction.CopyLink)
-                    }
-                    if (isDeveloperModeEnabled) {
-                        add(TimelineItemAction.ViewSource)
-                    }
-                    if (!timelineItem.isMine) {
-                        add(TimelineItemAction.ReportContent)
-                    }
-                    if (canRedact) {
-                        add(TimelineItemAction.Redact)
-                    }
-                }
-            }
-        val displayEmojiReactions = userCanSendReaction &&
+
+        val actions = buildActions(
+            timelineItem = timelineItem,
+            usersEventPermissions = usersEventPermissions,
+            isDeveloperModeEnabled = isDeveloperModeEnabled,
+        )
+        val displayEmojiReactions = usersEventPermissions.canSendReaction &&
             timelineItem.isRemote &&
             timelineItem.content.canReact()
         if (actions.isNotEmpty() || displayEmojiReactions) {
@@ -219,3 +100,61 @@ class ActionListPresenter @Inject constructor(
         }
     }
 }
+
+private fun buildActions(
+    timelineItem: TimelineItem.Event,
+    usersEventPermissions: UserEventPermissions,
+    isDeveloperModeEnabled: Boolean,
+): List<TimelineItemAction> {
+    val canRedact = timelineItem.isMine && usersEventPermissions.canRedactOwn || !timelineItem.isMine && usersEventPermissions.canRedactOther
+    return buildList {
+        if (timelineItem.canBeRepliedTo && usersEventPermissions.canSendMessage) {
+            if (timelineItem.isThreaded) {
+                add(TimelineItemAction.ReplyInThread)
+            } else {
+                add(TimelineItemAction.Reply)
+            }
+        }
+        if (timelineItem.isRemote && timelineItem.content.canBeForwarded()) {
+            add(TimelineItemAction.Forward)
+        }
+        if (timelineItem.isEditable) {
+            add(TimelineItemAction.Edit)
+        }
+        if (canRedact && timelineItem.content is TimelineItemPollContent && !timelineItem.content.isEnded) {
+            add(TimelineItemAction.EndPoll)
+        }
+        if (timelineItem.content.canBeCopied()) {
+            add(TimelineItemAction.Copy)
+        }
+        if (timelineItem.isRemote) {
+            add(TimelineItemAction.CopyLink)
+        }
+        if (isDeveloperModeEnabled) {
+            add(TimelineItemAction.ViewSource)
+        }
+        if (!timelineItem.isMine) {
+            add(TimelineItemAction.ReportContent)
+        }
+        if (canRedact) {
+            add(TimelineItemAction.Redact)
+        }
+    }.postFilter(timelineItem.content)
+}
+
+/**
+ * Post filter the actions based on the content of the event.
+ */
+private fun List<TimelineItemAction>.postFilter(content: TimelineItemEventContent): List<TimelineItemAction> {
+    return filter { action ->
+        when (content) {
+            is TimelineItemCallNotifyContent,
+            is TimelineItemLegacyCallInviteContent,
+            is TimelineItemStateContent,
+            is TimelineItemRedactedContent -> {
+                action == TimelineItemAction.ViewSource
+            }
+            else -> true
+        }
+    }
+}

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineStateProvider.kt

@@ -127,6 +127,7 @@ internal fun aTimelineItemEvent(
     transactionId: TransactionId? = null,
     isMine: Boolean = false,
     isEditable: Boolean = false,
+    canBeRepliedTo: Boolean = false,
     senderDisplayName: String = "Sender",
     displayNameAmbiguous: Boolean = false,
     content: TimelineItemEventContent = aTimelineItemTextContent(),
@@ -150,6 +151,7 @@ internal fun aTimelineItemEvent(
         sentTime = "12:34",
         isMine = isMine,
         isEditable = isEditable,
+        canBeRepliedTo = canBeRepliedTo,
         senderProfile = aProfileTimelineDetailsReady(
             displayName = senderDisplayName,
             displayNameAmbiguous = displayNameAmbiguous,

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineItemEventRow.kt

@@ -77,7 +77,6 @@ import io.element.android.features.messages.impl.timeline.model.event.TimelineIt
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVoiceContent
 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.features.messages.impl.timeline.model.event.canBeRepliedTo
 import io.element.android.libraries.designsystem.colors.AvatarColorsProvider
 import io.element.android.libraries.designsystem.components.EqualWidthColumn
 import io.element.android.libraries.designsystem.components.avatar.Avatar
@@ -148,7 +147,7 @@ fun TimelineItemEventRow(
         } else {
             Spacer(modifier = Modifier.height(2.dp))
         }
-        val canReply = timelineRoomInfo.userHasPermissionToSendMessage && event.content.canBeRepliedTo()
+        val canReply = timelineRoomInfo.userHasPermissionToSendMessage && event.canBeRepliedTo
         if (canReply) {
             val state: SwipeableActionsState = rememberSwipeableActionsState()
             val offset = state.offset.floatValue

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemEventFactory.kt

@@ -76,6 +76,7 @@ class TimelineItemEventFactory @Inject constructor(
             content = contentFactory.create(currentTimelineItem.event),
             isMine = currentTimelineItem.event.isOwn,
             isEditable = currentTimelineItem.event.isEditable,
+            canBeRepliedTo = currentTimelineItem.event.canBeRepliedTo,
             sentTime = sentTime,
             groupPosition = groupPosition,
             reactionsState = currentTimelineItem.computeReactionsState(),

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/TimelineItem.kt

@@ -18,6 +18,7 @@ package io.element.android.features.messages.impl.timeline.model
 
 import androidx.compose.runtime.Immutable
 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.TimelineItemStickerContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemTextBasedContent
 import io.element.android.features.messages.impl.timeline.model.virtual.TimelineItemVirtualModel
@@ -74,6 +75,7 @@ sealed interface TimelineItem {
         val sentTime: String = "",
         val isMine: Boolean = false,
         val isEditable: Boolean,
+        val canBeRepliedTo: Boolean,
         val groupPosition: TimelineItemGroupPosition = TimelineItemGroupPosition.None,
         val reactionsState: TimelineItemReactions,
         val readReceiptState: TimelineItemReadReceipts,
@@ -94,6 +96,7 @@ sealed interface TimelineItem {
         val isSticker: Boolean = content is TimelineItemStickerContent
 
         val isRemote = eventId != null
+
     }
 
     @Immutable

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemEventContent.kt

@@ -24,27 +24,27 @@ sealed interface TimelineItemEventContent {
 }
 
 /**
- * Only text based content and states can be copied.
+ * Only text based content can be copied.
  */
 fun TimelineItemEventContent.canBeCopied(): Boolean =
-    when (this) {
-        is TimelineItemTextBasedContent,
-        is TimelineItemStateContent,
-        is TimelineItemRedactedContent -> true
-        else -> false
-    }
+    this is TimelineItemTextBasedContent
 
 /**
- * Determine if the event content can be replied to.
- * Note: it should match the logic in [io.element.android.features.messages.impl.actionlist.ActionListPresenter].
+ * Returns true if the event content can be forwarded.
  */
-fun TimelineItemEventContent.canBeRepliedTo(): Boolean =
+fun TimelineItemEventContent.canBeForwarded(): Boolean =
     when (this) {
-        is TimelineItemRedactedContent,
-        is TimelineItemLegacyCallInviteContent,
-        is TimelineItemCallNotifyContent,
-        is TimelineItemStateContent -> false
-        else -> true
+        is TimelineItemTextBasedContent,
+        is TimelineItemImageContent,
+        is TimelineItemFileContent,
+        is TimelineItemAudioContent,
+        is TimelineItemVideoContent,
+        is TimelineItemLocationContent,
+        is TimelineItemVoiceContent -> true
+        // Stickers can't be forwarded (yet) so we don't show the option
+        // See https://github.com/element-hq/element-x-android/issues/2161
+        is TimelineItemStickerContent -> false
+        else -> false
     }
 
 /**