Merge pull request #3255 from element-hq/feature/fga/pinned_event_feature_flag

WIP Pinned events : add feature flag and pin/unpin actions

Author: ganfra

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

@@ -20,10 +20,12 @@ 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
 import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.produceState
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
@@ -73,12 +75,13 @@ import io.element.android.libraries.matrix.api.room.MatrixRoomInfo
 import io.element.android.libraries.matrix.api.room.MatrixRoomMembersState
 import io.element.android.libraries.matrix.api.room.MessageEventType
 import io.element.android.libraries.matrix.api.room.isDm
+import io.element.android.libraries.matrix.api.room.powerlevels.canPinUnpin
+import io.element.android.libraries.matrix.api.room.powerlevels.canRedactOther
+import io.element.android.libraries.matrix.api.room.powerlevels.canRedactOwn
+import io.element.android.libraries.matrix.api.room.powerlevels.canSendMessage
 import io.element.android.libraries.matrix.ui.messages.reply.map
 import io.element.android.libraries.matrix.ui.model.getAvatarData
 import io.element.android.libraries.matrix.ui.room.canCall
-import io.element.android.libraries.matrix.ui.room.canRedactOtherAsState
-import io.element.android.libraries.matrix.ui.room.canRedactOwnAsState
-import io.element.android.libraries.matrix.ui.room.canSendMessageAsState
 import io.element.android.libraries.textcomposer.model.MessageComposerMode
 import io.element.android.libraries.ui.strings.CommonStrings
 import kotlinx.collections.immutable.toPersistentList
@@ -131,10 +134,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 +213,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 +234,19 @@ class MessagesPresenter @AssistedInject constructor(
         )
     }
 
+    @Composable
+    private fun userEventPermissions(updateKey: Long): State<UserEventPermissions> {
+        return produceState(UserEventPermissions.DEFAULT, key1 = updateKey) {
+            value = UserEventPermissions(
+                canSendMessage = room.canSendMessage(type = MessageEventType.ROOM_MESSAGE).getOrElse { true },
+                canSendReaction = room.canSendMessage(type = MessageEventType.REACTION).getOrElse { true },
+                canRedactOwn = room.canRedactOwn().getOrElse { false },
+                canRedactOther = room.canRedactOther().getOrElse { false },
+                canPinUnpin = room.canPinUnpin().getOrElse { false },
+            )
+        }
+    }
+
     private fun MatrixRoomInfo.avatarData(): AvatarData {
         return AvatarData(
             id = id.value,
@@ -268,6 +280,30 @@ class MessagesPresenter @AssistedInject constructor(
             TimelineItemAction.Forward -> handleForwardAction(targetEvent)
             TimelineItemAction.ReportContent -> handleReportAction(targetEvent)
             TimelineItemAction.EndPoll -> handleEndPollAction(targetEvent, timelineState)
+            TimelineItemAction.Pin -> handlePinAction(targetEvent)
+            TimelineItemAction.Unpin -> handleUnpinAction(targetEvent)
+        }
+    }
+
+    private suspend fun handlePinAction(targetEvent: TimelineItem.Event) {
+        if (targetEvent.eventId == null) return
+        timelineController.invokeOnCurrentTimeline {
+            pinEvent(targetEvent.eventId)
+                .onFailure {
+                    Timber.e(it, "Failed to pin event ${targetEvent.eventId}")
+                    snackbarDispatcher.post(SnackbarMessage(CommonStrings.common_error))
+                }
+        }
+    }
+
+    private suspend fun handleUnpinAction(targetEvent: TimelineItem.Event) {
+        if (targetEvent.eventId == null) return
+        timelineController.invokeOnCurrentTimeline {
+            unpinEvent(targetEvent.eventId)
+                .onFailure {
+                    Timber.e(it, "Failed to unpin event ${targetEvent.eventId}")
+                    snackbarDispatcher.post(SnackbarMessage(CommonStrings.common_error))
+                }
         }
     }
 

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,20 @@ fun aMessagesState(
     eventSink = eventSink,
 )
 
+fun aUserEventPermissions(
+    canRedactOwn: Boolean = false,
+    canRedactOther: Boolean = false,
+    canSendMessage: Boolean = true,
+    canSendReaction: Boolean = true,
+    canPinUnpin: Boolean = false,
+) = UserEventPermissions(
+    canRedactOwn = canRedactOwn,
+    canRedactOther = canRedactOther,
+    canSendMessage = canSendMessage,
+    canSendReaction = canSendReaction,
+    canPinUnpin = canPinUnpin,
+)
+
 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,39 @@
+/*
+ * 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,
+    val canPinUnpin: Boolean,
+) {
+    companion object {
+        val DEFAULT = UserEventPermissions(
+            canRedactOwn = false,
+            canRedactOther = false,
+            canSendMessage = true,
+            canSendReaction = true,
+            canPinUnpin = false
+        )
+    }
+}

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
 }