Transition voice messages to the new in thread sending mechanism

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -19610,15 +19610,15 @@ class VoiceMessageRecorderMock: VoiceMessageRecorderProtocol, @unchecked Sendabl
     }
     //MARK: - sendVoiceMessage
 
-    var sendVoiceMessageInRoomAudioConverterThreadRootEventIDUnderlyingCallsCount = 0
-    var sendVoiceMessageInRoomAudioConverterThreadRootEventIDCallsCount: Int {
+    var sendVoiceMessageTimelineControllerAudioConverterUnderlyingCallsCount = 0
+    var sendVoiceMessageTimelineControllerAudioConverterCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return sendVoiceMessageInRoomAudioConverterThreadRootEventIDUnderlyingCallsCount
+                return sendVoiceMessageTimelineControllerAudioConverterUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = sendVoiceMessageInRoomAudioConverterThreadRootEventIDUnderlyingCallsCount
+                    returnValue = sendVoiceMessageTimelineControllerAudioConverterUnderlyingCallsCount
                 }
 
                 return returnValue!
@@ -19626,29 +19626,29 @@ class VoiceMessageRecorderMock: VoiceMessageRecorderProtocol, @unchecked Sendabl
         }
         set {
             if Thread.isMainThread {
-                sendVoiceMessageInRoomAudioConverterThreadRootEventIDUnderlyingCallsCount = newValue
+                sendVoiceMessageTimelineControllerAudioConverterUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    sendVoiceMessageInRoomAudioConverterThreadRootEventIDUnderlyingCallsCount = newValue
+                    sendVoiceMessageTimelineControllerAudioConverterUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    var sendVoiceMessageInRoomAudioConverterThreadRootEventIDCalled: Bool {
-        return sendVoiceMessageInRoomAudioConverterThreadRootEventIDCallsCount > 0
+    var sendVoiceMessageTimelineControllerAudioConverterCalled: Bool {
+        return sendVoiceMessageTimelineControllerAudioConverterCallsCount > 0
     }
-    var sendVoiceMessageInRoomAudioConverterThreadRootEventIDReceivedArguments: (roomProxy: JoinedRoomProxyProtocol, audioConverter: AudioConverterProtocol, threadRootEventID: String?)?
-    var sendVoiceMessageInRoomAudioConverterThreadRootEventIDReceivedInvocations: [(roomProxy: JoinedRoomProxyProtocol, audioConverter: AudioConverterProtocol, threadRootEventID: String?)] = []
+    var sendVoiceMessageTimelineControllerAudioConverterReceivedArguments: (timelineController: TimelineControllerProtocol, audioConverter: AudioConverterProtocol)?
+    var sendVoiceMessageTimelineControllerAudioConverterReceivedInvocations: [(timelineController: TimelineControllerProtocol, audioConverter: AudioConverterProtocol)] = []
 
-    var sendVoiceMessageInRoomAudioConverterThreadRootEventIDUnderlyingReturnValue: Result<Void, VoiceMessageRecorderError>!
-    var sendVoiceMessageInRoomAudioConverterThreadRootEventIDReturnValue: Result<Void, VoiceMessageRecorderError>! {
+    var sendVoiceMessageTimelineControllerAudioConverterUnderlyingReturnValue: Result<Void, VoiceMessageRecorderError>!
+    var sendVoiceMessageTimelineControllerAudioConverterReturnValue: Result<Void, VoiceMessageRecorderError>! {
         get {
             if Thread.isMainThread {
-                return sendVoiceMessageInRoomAudioConverterThreadRootEventIDUnderlyingReturnValue
+                return sendVoiceMessageTimelineControllerAudioConverterUnderlyingReturnValue
             } else {
                 var returnValue: Result<Void, VoiceMessageRecorderError>? = nil
                 DispatchQueue.main.sync {
-                    returnValue = sendVoiceMessageInRoomAudioConverterThreadRootEventIDUnderlyingReturnValue
+                    returnValue = sendVoiceMessageTimelineControllerAudioConverterUnderlyingReturnValue
                 }
 
                 return returnValue!
@@ -19656,26 +19656,26 @@ class VoiceMessageRecorderMock: VoiceMessageRecorderProtocol, @unchecked Sendabl
         }
         set {
             if Thread.isMainThread {
-                sendVoiceMessageInRoomAudioConverterThreadRootEventIDUnderlyingReturnValue = newValue
+                sendVoiceMessageTimelineControllerAudioConverterUnderlyingReturnValue = newValue
             } else {
                 DispatchQueue.main.sync {
-                    sendVoiceMessageInRoomAudioConverterThreadRootEventIDUnderlyingReturnValue = newValue
+                    sendVoiceMessageTimelineControllerAudioConverterUnderlyingReturnValue = newValue
                 }
             }
         }
     }
-    var sendVoiceMessageInRoomAudioConverterThreadRootEventIDClosure: ((JoinedRoomProxyProtocol, AudioConverterProtocol, String?) async -> Result<Void, VoiceMessageRecorderError>)?
+    var sendVoiceMessageTimelineControllerAudioConverterClosure: ((TimelineControllerProtocol, AudioConverterProtocol) async -> Result<Void, VoiceMessageRecorderError>)?
 
-    func sendVoiceMessage(inRoom roomProxy: JoinedRoomProxyProtocol, audioConverter: AudioConverterProtocol, threadRootEventID: String?) async -> Result<Void, VoiceMessageRecorderError> {
-        sendVoiceMessageInRoomAudioConverterThreadRootEventIDCallsCount += 1
-        sendVoiceMessageInRoomAudioConverterThreadRootEventIDReceivedArguments = (roomProxy: roomProxy, audioConverter: audioConverter, threadRootEventID: threadRootEventID)
+    func sendVoiceMessage(timelineController: TimelineControllerProtocol, audioConverter: AudioConverterProtocol) async -> Result<Void, VoiceMessageRecorderError> {
+        sendVoiceMessageTimelineControllerAudioConverterCallsCount += 1
+        sendVoiceMessageTimelineControllerAudioConverterReceivedArguments = (timelineController: timelineController, audioConverter: audioConverter)
         DispatchQueue.main.async {
-            self.sendVoiceMessageInRoomAudioConverterThreadRootEventIDReceivedInvocations.append((roomProxy: roomProxy, audioConverter: audioConverter, threadRootEventID: threadRootEventID))
+            self.sendVoiceMessageTimelineControllerAudioConverterReceivedInvocations.append((timelineController: timelineController, audioConverter: audioConverter))
         }
-        if let sendVoiceMessageInRoomAudioConverterThreadRootEventIDClosure = sendVoiceMessageInRoomAudioConverterThreadRootEventIDClosure {
-            return await sendVoiceMessageInRoomAudioConverterThreadRootEventIDClosure(roomProxy, audioConverter, threadRootEventID)
+        if let sendVoiceMessageTimelineControllerAudioConverterClosure = sendVoiceMessageTimelineControllerAudioConverterClosure {
+            return await sendVoiceMessageTimelineControllerAudioConverterClosure(timelineController, audioConverter)
         } else {
-            return sendVoiceMessageInRoomAudioConverterThreadRootEventIDReturnValue
+            return sendVoiceMessageTimelineControllerAudioConverterReturnValue
         }
     }
 }

ElementX/Sources/Screens/Timeline/TimelineInteractionHandler.swift

@@ -362,9 +362,8 @@ class TimelineInteractionHandler {
 
         actionsSubject.send(.composer(action: .setMode(mode: .previewVoiceMessage(state: audioPlayerState, waveform: .url(recordingURL), isUploading: true))))
         await voiceMessageRecorder.stopPlayback()
-        switch await voiceMessageRecorder.sendVoiceMessage(inRoom: roomProxy,
-                                                           audioConverter: AudioConverter(),
-                                                           threadRootEventID: timelineController.timelineKind.threadRootEventID) {
+        
+        switch await voiceMessageRecorder.sendVoiceMessage(timelineController: timelineController, audioConverter: AudioConverter()) {
         case .success:
             await deleteCurrentVoiceMessage()
         case .failure(let error):

ElementX/Sources/Services/Timeline/TimelineController/MockTimelineController.swift

@@ -18,6 +18,8 @@ class MockTimelineController: TimelineControllerProtocol {
     var incomingItems: [RoomTimelineItemProtocol] = []
     
     var roomProxy: JoinedRoomProxyProtocol?
+    var timelineProxy: TimelineProxyProtocol?
+    
     var roomID: String { roomProxy?.id ?? "MockRoomIdentifier" }
     var timelineKind: TimelineKind
     
@@ -46,9 +48,13 @@ class MockTimelineController: TimelineControllerProtocol {
         return mock
     }
     
-    init(timelineKind: TimelineKind = .live, listenForSignals: Bool = false, timelineItems: [RoomTimelineItemProtocol] = RoomTimelineItemFixtures.default) {
+    init(timelineKind: TimelineKind = .live,
+         listenForSignals: Bool = false,
+         timelineItems: [RoomTimelineItemProtocol] = RoomTimelineItemFixtures.default,
+         timelineProxy: TimelineProxyProtocol? = nil) {
         self.timelineKind = timelineKind
         self.timelineItems = timelineItems
+        self.timelineProxy = timelineProxy
         
         callbacks.send(.paginationState(paginationState))
         callbacks.send(.isLive(true))
@@ -107,6 +113,10 @@ class MockTimelineController: TimelineControllerProtocol {
                      html: String?,
                      inReplyToEventID: String?,
                      intentionalMentions: IntentionalMentions) async { }
+    
+    func sendVoiceMessage(url: URL, audioInfo: AudioInfo, waveform: [UInt16]) async -> Result<Void, TimelineProxyError> {
+        await timelineProxy?.sendVoiceMessage(url: url, audioInfo: audioInfo, waveform: waveform, requestHandle: { _ in }) ?? .success(())
+    }
         
     func toggleReaction(_ reaction: String, to eventID: TimelineItemIdentifier.EventOrTransactionID) async { }
     

ElementX/Sources/Services/Timeline/TimelineController/TimelineController.swift

@@ -145,6 +145,8 @@ class TimelineController: TimelineControllerProtocol {
     
     func processItemDisappearance(_ itemID: TimelineItemIdentifier) { }
     
+    // MARK: - Sending
+    
     func sendMessage(_ message: String,
                      html: String?,
                      inReplyToEventID: String?,
@@ -153,7 +155,6 @@ class TimelineController: TimelineControllerProtocol {
         
         switch await activeTimeline.sendMessage(message,
                                                 html: html,
-                                                threadRootEventID: timelineKind.threadRootEventID,
                                                 inReplyToEventID: inReplyToEventID,
                                                 intentionalMentions: intentionalMentions) {
         case .success:
@@ -164,6 +165,12 @@ class TimelineController: TimelineControllerProtocol {
         }
     }
     
+    func sendVoiceMessage(url: URL, audioInfo: AudioInfo, waveform: [UInt16]) async -> Result<Void, TimelineProxyError> {
+        await activeTimeline.sendVoiceMessage(url: url,
+                                              audioInfo: audioInfo,
+                                              waveform: waveform) { _ in }
+    }
+    
     private func donateSendMessageIntent() async {
         guard let displayName = roomProxy.details.name ?? roomProxy.details.canonicalAlias, !displayName.isEmpty else {
             MXLog.error("Failed donating send message intent, room missing name or alias.")

ElementX/Sources/Services/Timeline/TimelineController/TimelineControllerProtocol.swift

@@ -68,6 +68,8 @@ protocol TimelineControllerProtocol {
                      inReplyToEventID: String?,
                      intentionalMentions: IntentionalMentions) async
     
+    func sendVoiceMessage(url: URL, audioInfo: AudioInfo, waveform: [UInt16]) async -> Result<Void, TimelineProxyError>
+    
     func edit(_ eventOrTransactionID: TimelineItemIdentifier.EventOrTransactionID,
               message: String,
               html: String?,

ElementX/Sources/Services/VoiceMessage/VoiceMessageRecorder.swift

@@ -144,9 +144,8 @@ class VoiceMessageRecorder: VoiceMessageRecorderProtocol {
         return .success(waveformData)
     }
     
-    func sendVoiceMessage(inRoom roomProxy: JoinedRoomProxyProtocol,
-                          audioConverter: AudioConverterProtocol,
-                          threadRootEventID: String?) async -> Result<Void, VoiceMessageRecorderError> {
+    func sendVoiceMessage(timelineController: TimelineControllerProtocol,
+                          audioConverter: AudioConverterProtocol) async -> Result<Void, VoiceMessageRecorderError> {
         guard let url = audioRecorder.audioFileURL else {
             return .failure(VoiceMessageRecorderError.missingRecordingFile)
         }
@@ -178,9 +177,9 @@ class VoiceMessageRecorder: VoiceMessageRecorderProtocol {
             return .failure(.failedSendingVoiceMessage)
         }
         
-        let result = await roomProxy.timeline.sendVoiceMessage(url: oggFile,
+        let result = await timelineController.sendVoiceMessage(url: oggFile,
                                                                audioInfo: audioInfo,
-                                                               waveform: waveform) { _ in }
+                                                               waveform: waveform)
         
         if case .failure(let error) = result {
             MXLog.error("Failed to send the voice message. \(error)")

ElementX/Sources/Services/VoiceMessage/VoiceMessageRecorderProtocol.swift

@@ -38,9 +38,8 @@ protocol VoiceMessageRecorderProtocol {
     func seekPlayback(to progress: Double) async
     func deleteRecording() async
     
-    func sendVoiceMessage(inRoom roomProxy: JoinedRoomProxyProtocol,
-                          audioConverter: AudioConverterProtocol,
-                          threadRootEventID: String?) async -> Result<Void, VoiceMessageRecorderError>
+    func sendVoiceMessage(timelineController: TimelineControllerProtocol,
+                          audioConverter: AudioConverterProtocol) async -> Result<Void, VoiceMessageRecorderError>
 }
 
 // sourcery: AutoMockable