Move message forwarding out of the flow coordinator. (#2738)

ElementX/Sources/Screens/MessageForwardingScreen/MessageForwardingScreenCoordinator.swift

@@ -18,14 +18,16 @@ import Combine
 import SwiftUI
 
 struct MessageForwardingScreenCoordinatorParameters {
+    let forwardingItem: MessageForwardingItem
+    let clientProxy: ClientProxyProtocol
     let roomSummaryProvider: RoomSummaryProviderProtocol
     let mediaProvider: MediaProviderProtocol
-    let sourceRoomID: String
+    let userIndicatorController: UserIndicatorControllerProtocol
 }
 
 enum MessageForwardingScreenCoordinatorAction {
     case dismiss
-    case send(roomID: String)
+    case sent(roomID: String)
 }
 
 final class MessageForwardingScreenCoordinator: CoordinatorProtocol {
@@ -38,9 +40,11 @@ final class MessageForwardingScreenCoordinator: CoordinatorProtocol {
     }
     
     init(parameters: MessageForwardingScreenCoordinatorParameters) {
-        viewModel = MessageForwardingScreenViewModel(roomSummaryProvider: parameters.roomSummaryProvider,
-                                                     mediaProvider: parameters.mediaProvider,
-                                                     sourceRoomID: parameters.sourceRoomID)
+        viewModel = MessageForwardingScreenViewModel(forwardingItem: parameters.forwardingItem,
+                                                     clientProxy: parameters.clientProxy,
+                                                     roomSummaryProvider: parameters.roomSummaryProvider,
+                                                     userIndicatorController: parameters.userIndicatorController,
+                                                     mediaProvider: parameters.mediaProvider)
     }
     
     func start() {
@@ -48,8 +52,8 @@ final class MessageForwardingScreenCoordinator: CoordinatorProtocol {
             switch action {
             case .dismiss:
                 self?.actionsSubject.send(.dismiss)
-            case .send(let roomID):
-                self?.actionsSubject.send(.send(roomID: roomID))
+            case .sent(let roomID):
+                self?.actionsSubject.send(.sent(roomID: roomID))
             }
         }
         .store(in: &cancellables)

ElementX/Sources/Screens/MessageForwardingScreen/MessageForwardingScreenModels.swift

@@ -15,10 +15,11 @@
 //
 
 import Foundation
+import MatrixRustSDK
 
 enum MessageForwardingScreenViewModelAction {
     case dismiss
-    case send(roomID: String)
+    case sent(roomID: String)
 }
 
 struct MessageForwardingScreenViewState: BindableState {
@@ -45,3 +46,21 @@ struct MessageForwardingRoom: Identifiable, Equatable {
     let alias: String?
     let avatarURL: URL?
 }
+
+struct MessageForwardingItem: Hashable {
+    /// The source item's timeline ID. Only necessary for a rough Hashable conformance.
+    let id: TimelineItemIdentifier
+    /// The source item's room ID.
+    let roomID: String
+    /// The item's content to be forwarded.
+    let content: RoomMessageEventContentWithoutRelation
+    
+    static func == (lhs: MessageForwardingItem, rhs: MessageForwardingItem) -> Bool {
+        lhs.id == rhs.id && lhs.roomID == rhs.roomID
+    }
+    
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(id)
+        hasher.combine(roomID)
+    }
+}

ElementX/Sources/Screens/MessageForwardingScreen/MessageForwardingScreenViewModel.swift

@@ -20,8 +20,10 @@ import SwiftUI
 typealias MessageForwardingScreenViewModelType = StateStoreViewModel<MessageForwardingScreenViewState, MessageForwardingScreenViewAction>
 
 class MessageForwardingScreenViewModel: MessageForwardingScreenViewModelType, MessageForwardingScreenViewModelProtocol {
-    private let roomSummaryProvider: RoomSummaryProviderProtocol?
-    private let sourceRoomID: String
+    private let forwardingItem: MessageForwardingItem
+    private let clientProxy: ClientProxyProtocol
+    private let roomSummaryProvider: RoomSummaryProviderProtocol
+    private let userIndicatorController: UserIndicatorControllerProtocol
     
     private var actionsSubject: PassthroughSubject<MessageForwardingScreenViewModelAction, Never> = .init()
     
@@ -29,11 +31,15 @@ class MessageForwardingScreenViewModel: MessageForwardingScreenViewModelType, Me
         actionsSubject.eraseToAnyPublisher()
     }
 
-    init(roomSummaryProvider: RoomSummaryProviderProtocol,
-         mediaProvider: MediaProviderProtocol,
-         sourceRoomID: String) {
+    init(forwardingItem: MessageForwardingItem,
+         clientProxy: ClientProxyProtocol,
+         roomSummaryProvider: RoomSummaryProviderProtocol,
+         userIndicatorController: UserIndicatorControllerProtocol,
+         mediaProvider: MediaProviderProtocol) {
+        self.forwardingItem = forwardingItem
+        self.clientProxy = clientProxy
         self.roomSummaryProvider = roomSummaryProvider
-        self.sourceRoomID = sourceRoomID
+        self.userIndicatorController = userIndicatorController
         
         super.init(initialViewState: MessageForwardingScreenViewState(), imageProvider: mediaProvider)
         
@@ -49,7 +55,7 @@ class MessageForwardingScreenViewModel: MessageForwardingScreenViewModelType, Me
             .removeDuplicates()
             .sink { [weak self] searchQuery in
                 guard let self else { return }
-                self.roomSummaryProvider?.setFilter(.search(query: searchQuery))
+                self.roomSummaryProvider.setFilter(.search(query: searchQuery))
             }
             .store(in: &cancellables)
         
@@ -60,13 +66,9 @@ class MessageForwardingScreenViewModel: MessageForwardingScreenViewModelType, Me
         switch viewAction {
         case .cancel:
             actionsSubject.send(.dismiss)
-            roomSummaryProvider?.setFilter(.all(filters: []))
+            roomSummaryProvider.setFilter(.all(filters: []))
         case .send:
-            guard let roomID = state.selectedRoomID else {
-                fatalError()
-            }
-            
-            actionsSubject.send(.send(roomID: roomID))
+            Task { await forward() }
         case .selectRoom(let roomID):
             state.selectedRoomID = roomID
         case .reachedTop:
@@ -79,11 +81,6 @@ class MessageForwardingScreenViewModel: MessageForwardingScreenViewModelType, Me
     // MARK: - Private
     
     private func updateRooms() {
-        guard let roomSummaryProvider else {
-            MXLog.error("Room summary provider unavailable")
-            return
-        }
-        
         MXLog.verbose("Updating rooms")
         
         var rooms = [MessageForwardingRoom]()
@@ -93,7 +90,7 @@ class MessageForwardingScreenViewModel: MessageForwardingScreenViewModelType, Me
             case .empty, .invalidated:
                 continue
             case .filled(let details):
-                if details.id == sourceRoomID {
+                if details.id == forwardingItem.roomID {
                     continue
                 }
                 
@@ -114,10 +111,6 @@ class MessageForwardingScreenViewModel: MessageForwardingScreenViewModelType, Me
     /// we just need the respective bounds to be there to trigger a next page load or
     /// a reset to just one page
     private func updateVisibleRange(edge: UIRectEdge) {
-        guard let roomSummaryProvider else {
-            return
-        }
-        
         switch edge {
         case .top:
             roomSummaryProvider.updateVisibleRange(0..<0)
@@ -128,4 +121,25 @@ class MessageForwardingScreenViewModel: MessageForwardingScreenViewModelType, Me
             break
         }
     }
+    
+    private func forward() async {
+        guard let roomID = state.selectedRoomID else {
+            fatalError()
+        }
+        
+        guard let targetRoomProxy = await clientProxy.roomForIdentifier(roomID) else {
+            MXLog.error("Failed retrieving room to forward to with id: \(roomID)")
+            userIndicatorController.submitIndicator(UserIndicator(title: L10n.errorUnknown))
+            return
+        }
+        
+        if case .failure(let error) = await targetRoomProxy.timeline.sendMessageEventContent(forwardingItem.content) {
+            MXLog.error("Failed forwarding message with error: \(error)")
+            userIndicatorController.submitIndicator(UserIndicator(title: L10n.errorUnknown))
+            return
+        }
+        
+        // Timelines are cached - the local echo will be visible when fetching the room by its ID.
+        actionsSubject.send(.sent(roomID: roomID))
+    }
 }

ElementX/Sources/Screens/MessageForwardingScreen/View/MessageForwardingScreen.swift

@@ -104,9 +104,13 @@ private struct MessageForwardingListRow: View {
 struct MessageForwardingScreen_Previews: PreviewProvider, TestablePreview {
     static var previews: some View {
         let summaryProvider = RoomSummaryProviderMock(.init(state: .loaded(.mockRooms)))
-        let viewModel = MessageForwardingScreenViewModel(roomSummaryProvider: summaryProvider,
-                                                         mediaProvider: MockMediaProvider(),
-                                                         sourceRoomID: "")
+        let viewModel = MessageForwardingScreenViewModel(forwardingItem: .init(id: .init(timelineID: ""),
+                                                                               roomID: "",
+                                                                               content: .init(noPointer: .init())),
+                                                         clientProxy: ClientProxyMock(),
+                                                         roomSummaryProvider: summaryProvider,
+                                                         userIndicatorController: UserIndicatorControllerMock(),
+                                                         mediaProvider: MockMediaProvider())
         
         NavigationStack {
             MessageForwardingScreen(context: viewModel.context)

ElementX/Sources/Screens/RoomScreen/RoomScreenCoordinator.swift

@@ -42,7 +42,7 @@ enum RoomScreenCoordinatorAction {
     case presentLocationViewer(body: String, geoURI: GeoURI, description: String?)
     case presentEmojiPicker(itemID: TimelineItemIdentifier, selectedEmojis: Set<String>)
     case presentRoomMemberDetails(userID: String)
-    case presentMessageForwarding(itemID: TimelineItemIdentifier)
+    case presentMessageForwarding(forwardingItem: MessageForwardingItem)
     case presentCallScreen
 }
 
@@ -110,8 +110,8 @@ final class RoomScreenCoordinator: CoordinatorProtocol {
                     actionsSubject.send(.presentMediaUploadPreviewScreen(url))
                 case .displayRoomMemberDetails(userID: let userID):
                     actionsSubject.send(.presentRoomMemberDetails(userID: userID))
-                case .displayMessageForwarding(let itemID):
-                    actionsSubject.send(.presentMessageForwarding(itemID: itemID))
+                case .displayMessageForwarding(let forwardingItem):
+                    actionsSubject.send(.presentMessageForwarding(forwardingItem: forwardingItem))
                 case .displayLocation(let body, let geoURI, let description):
                     actionsSubject.send(.presentLocationViewer(body: body, geoURI: geoURI, description: description))
                 case .composer(let action):

ElementX/Sources/Screens/RoomScreen/RoomScreenModels.swift

@@ -16,7 +16,6 @@
 
 import Combine
 import SwiftUI
-import UIKit
 
 import OrderedCollections
 
@@ -31,7 +30,7 @@ enum RoomScreenViewModelAction {
     case displayPollForm(mode: PollFormMode)
     case displayMediaUploadPreviewScreen(url: URL)
     case displayRoomMemberDetails(userID: String)
-    case displayMessageForwarding(itemID: TimelineItemIdentifier)
+    case displayMessageForwarding(forwardingItem: MessageForwardingItem)
     case displayLocation(body: String, geoURI: GeoURI, description: String?)
     case composer(action: RoomScreenComposerAction)
     case displayCallScreen

ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift

@@ -429,7 +429,7 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
                 case .displayEmojiPicker(let itemID, let selectedEmojis):
                     actionsSubject.send(.displayEmojiPicker(itemID: itemID, selectedEmojis: selectedEmojis))
                 case .displayMessageForwarding(let itemID):
-                    actionsSubject.send(.displayMessageForwarding(itemID: itemID))
+                    Task { await self.forwardMessage(itemID: itemID) }
                 case .displayPollForm(let mode):
                     actionsSubject.send(.displayPollForm(mode: mode))
                 case .displayReportContent(let itemID, let senderID):
@@ -738,6 +738,13 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
         state.bindings.readReceiptsSummaryInfo = .init(orderedReceipts: eventTimelineItem.properties.orderedReadReceipts, id: eventTimelineItem.id)
     }
     
+    // MARK: - Message forwarding
+    
+    private func forwardMessage(itemID: TimelineItemIdentifier) async {
+        guard let content = await timelineController.messageEventContent(for: itemID) else { return }
+        actionsSubject.send(.displayMessageForwarding(forwardingItem: .init(id: itemID, roomID: roomProxy.id, content: content)))
+    }
+    
     // MARK: - User Indicators
     
     private func showFocusLoadingIndicator() {