[Message Actions] Forward messages (#635)

* Add forwarding messages base

* Make forwarding single-selection

---------

Co-authored-by: ElementBot <benoitm+elementbot@element.io>

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt

@@ -29,6 +29,7 @@ import io.element.android.libraries.matrix.api.createroom.RoomVisibility
 import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
 import io.element.android.libraries.matrix.api.notification.NotificationService
 import io.element.android.libraries.matrix.api.pusher.PushersService
+import io.element.android.libraries.matrix.api.room.ForwardEventException
 import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
 import io.element.android.libraries.matrix.api.room.RoomSummaryDataSource
@@ -40,6 +41,7 @@ import io.element.android.libraries.matrix.impl.core.toProgressWatcher
 import io.element.android.libraries.matrix.impl.media.RustMediaLoader
 import io.element.android.libraries.matrix.impl.notification.RustNotificationService
 import io.element.android.libraries.matrix.impl.pushers.RustPushersService
+import io.element.android.libraries.matrix.impl.room.RoomContentForwarder
 import io.element.android.libraries.matrix.impl.room.RustMatrixRoom
 import io.element.android.libraries.matrix.impl.room.RustRoomSummaryDataSource
 import io.element.android.libraries.matrix.impl.sync.SlidingSyncObserverProxy
@@ -52,6 +54,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
@@ -62,6 +65,7 @@ import kotlinx.coroutines.withTimeout
 import org.matrix.rustcomponents.sdk.Client
 import org.matrix.rustcomponents.sdk.ClientDelegate
 import org.matrix.rustcomponents.sdk.RequiredState
+import org.matrix.rustcomponents.sdk.RoomMessageEventContent
 import org.matrix.rustcomponents.sdk.SlidingSyncList
 import org.matrix.rustcomponents.sdk.SlidingSyncListBuilder
 import org.matrix.rustcomponents.sdk.SlidingSyncListOnceBuilt
@@ -199,6 +203,8 @@ class RustMatrixClient constructor(
 
     private val roomMembershipObserver = RoomMembershipObserver()
 
+    private val roomContentForwarder = RoomContentForwarder(slidingSync)
+
     init {
         client.setDelegate(clientDelegate)
         rustRoomSummaryDataSource.init()
@@ -220,6 +226,7 @@ class RustMatrixClient constructor(
             coroutineScope = coroutineScope,
             coroutineDispatchers = dispatchers,
             clock = clock,
+            roomContentForwarder = roomContentForwarder,
         )
     }
 

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/RoomContentForwarder.kt

@@ -0,0 +1,85 @@
+/*
+ * 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.libraries.matrix.impl.room
+
+import io.element.android.libraries.core.coroutine.parallelMap
+import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.room.ForwardEventException
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.withTimeout
+import org.matrix.rustcomponents.sdk.Room
+import org.matrix.rustcomponents.sdk.SlidingSync
+import org.matrix.rustcomponents.sdk.TimelineDiff
+import org.matrix.rustcomponents.sdk.TimelineListener
+import org.matrix.rustcomponents.sdk.genTransactionId
+import kotlin.time.Duration.Companion.milliseconds
+
+/**
+ * Helper to forward event contents from a room to a set of other rooms.
+ * @param slidingSync the [SlidingSync] to fetch room instances to forward the event to
+ */
+class RoomContentForwarder(
+    private val slidingSync: SlidingSync,
+) {
+
+    /**
+     * Forwards the event with the given [eventId] from the [fromRoom] to the given [toRoomIds].
+     * @param fromRoom the room to forward the event from
+     * @param eventId the id of the event to forward
+     * @param toRoomIds the ids of the rooms to forward the event to
+     * @param timeoutMs the maximum time in milliseconds to wait for the event to be sent to a room
+     */
+    suspend fun forward(
+        fromRoom: Room,
+        eventId: EventId,
+        toRoomIds: List<RoomId>,
+        timeoutMs: Long = 5000L
+    ) {
+        val content = fromRoom.getTimelineEventContentByEventId(eventId.value)
+        val targetSlidingSyncRooms = toRoomIds.mapNotNull { roomId -> slidingSync.getRoom(roomId.value) }
+        val targetRooms = targetSlidingSyncRooms.mapNotNull { slidingSyncRoom -> slidingSyncRoom.use { it.fullRoom() } }
+        val failedForwardingTo = mutableSetOf<RoomId>()
+        targetRooms.parallelMap { room ->
+            room.use { targetRoom ->
+                val result = runCatching {
+                    // Sending a message requires a registered timeline listener
+                    targetRoom.addTimelineListener(NoOpTimelineListener)
+                    withTimeout(timeoutMs.milliseconds) {
+                        targetRoom.send(content, genTransactionId())
+                    }
+                }
+                // After sending, we remove the timeline
+                targetRoom.removeTimeline()
+                result
+            }.onFailure {
+                failedForwardingTo.add(RoomId(room.id()))
+                if (it is CancellationException) {
+                    throw it
+                }
+            }
+        }
+
+        if (failedForwardingTo.isNotEmpty()) {
+            throw ForwardEventException(toRoomIds.toList())
+        }
+    }
+
+    private object NoOpTimelineListener: TimelineListener {
+        override fun onUpdate(diff: TimelineDiff) = Unit
+    }
+}

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/RustMatrixRoom.kt

@@ -50,6 +50,7 @@ import org.matrix.rustcomponents.sdk.SlidingSyncRoom
 import org.matrix.rustcomponents.sdk.UpdateSummary
 import org.matrix.rustcomponents.sdk.genTransactionId
 import org.matrix.rustcomponents.sdk.messageEventContentFromMarkdown
+import timber.log.Timber
 import java.io.File
 
 class RustMatrixRoom(
@@ -60,6 +61,7 @@ class RustMatrixRoom(
     private val coroutineScope: CoroutineScope,
     private val coroutineDispatchers: CoroutineDispatchers,
     private val clock: SystemClock,
+    private val roomContentForwarder: RoomContentForwarder,
 ) : MatrixRoom {
 
     override val membersStateFlow: StateFlow<MatrixRoomMembersState>
@@ -277,6 +279,14 @@ class RustMatrixRoom(
         }
     }
 
+    override suspend fun forwardEvent(eventId: EventId, roomIds: List<RoomId>): Result<Unit> = withContext(coroutineDispatchers.io) {
+        runCatching {
+            roomContentForwarder.forward(fromRoom = innerRoom, eventId = eventId, toRoomIds = roomIds)
+        }.onFailure {
+            Timber.e(it)
+        }
+    }
+
     override suspend fun retrySendMessage(transactionId: String): Result<Unit> =
         withContext(coroutineDispatchers.io) {
             runCatching {

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/RustRoomSummaryDataSource.kt

@@ -75,9 +75,9 @@ internal class RustRoomSummaryDataSource(
                 .launchIn(this)
 
             slidingSyncList.state(this)
-                .onEach { slidingSyncState ->
-                    Timber.v("New sliding sync state: $slidingSyncState")
-                    state.value = slidingSyncState
+                .onEach { SlidingSyncListLoadingState ->
+                    Timber.v("New sliding sync state: $SlidingSyncListLoadingState")
+                    state.value = SlidingSyncListLoadingState
                 }.launchIn(this)
         }