Adopt the new send queue interfaces

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

@@ -288,6 +288,53 @@ class TimelineController: TimelineControllerProtocol {
         return nil
     }
     
+    func pendingSendTarget(for itemID: TimelineItemIdentifier) -> SendTarget? {
+        for timelineItemProxy in activeTimelineItemProvider.itemProxies {
+            switch timelineItemProxy {
+            case .event(let item):
+                if item.id == itemID {
+                    return item.pendingSend?.target
+                }
+            default:
+                continue
+            }
+        }
+        
+        return nil
+    }
+    
+    func retrySend(_ itemID: TimelineItemIdentifier, target: SendTarget) async {
+        guard let eventOrTransactionID = itemID.eventOrTransactionID else {
+            MXLog.error("Cannot retry sending on \(itemID).")
+            return
+        }
+        
+        MXLog.info("Retry \(target) send in \(roomID)")
+        
+        switch await activeTimeline.retrySend(eventOrTransactionID, target: target) {
+        case .success(let hadPendingSend):
+            MXLog.info("Finished retrying send, had one pending: \(hadPendingSend)")
+        case .failure(let error):
+            MXLog.error("Failed retrying send with error: \(error)")
+        }
+    }
+    
+    func abortSend(_ itemID: TimelineItemIdentifier, target: SendTarget) async {
+        guard let eventOrTransactionID = itemID.eventOrTransactionID else {
+            MXLog.error("Cannot abort sending on \(itemID).")
+            return
+        }
+        
+        MXLog.info("Abort \(target) send in \(roomID)")
+        
+        switch await activeTimeline.abortSend(eventOrTransactionID, target: target) {
+        case .success(let hadPendingSend):
+            MXLog.info("Finished aborting send, had one pending: \(hadPendingSend)")
+        case .failure(let error):
+            MXLog.error("Failed aborting send with error: \(error)")
+        }
+    }
+    
     // MARK: - Sending
     
     func sendMessage(_ message: String,

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

@@ -96,6 +96,12 @@ protocol TimelineControllerProtocol: Sendable {
     
     func sendHandle(for itemID: TimelineItemIdentifier) -> SendHandleProxy?
     
+    func pendingSendTarget(for itemID: TimelineItemIdentifier) -> SendTarget?
+    
+    func retrySend(_ itemID: TimelineItemIdentifier, target: SendTarget) async
+    
+    func abortSend(_ itemID: TimelineItemIdentifier, target: SendTarget) async
+    
     func eventTimestamp(for itemID: TimelineItemIdentifier) -> Date?
     
     // MARK: - Sending

ElementX/Sources/Services/Timeline/TimelineItemProxy.swift

@@ -84,11 +84,11 @@ final nonisolated class EventTimelineItemProxy: Sendable {
     }
     
     var deliveryStatus: TimelineItemDeliveryStatus? {
-        guard let localSendState = item.localSendState else {
+        guard let pendingSend else {
             return nil
         }
         
-        switch localSendState {
+        switch pendingSend.state {
         case .sendingFailed(let error, _):
             switch error {
             case .identityViolations(let users):
@@ -107,6 +107,19 @@ final nonisolated class EventTimelineItemProxy: Sendable {
         }
     }
     
+    /// The item's own pending send or, when it has already gone out, our pending edit or redaction of it.
+    var pendingSend: (target: SendTarget, state: EventSendState)? {
+        if let state = item.localSendState {
+            (.event, state)
+        } else if let state = item.editSendState {
+            (.edit, state)
+        } else if let state = item.redactionSendState {
+            (.redaction, state)
+        } else {
+            nil
+        }
+    }
+    
     var canBeRepliedTo: Bool {
         item.canBeRepliedTo
     }

ElementX/Sources/Services/Timeline/TimelineProxy.swift

@@ -213,6 +213,36 @@ final class TimelineProxy: TimelineProxyProtocol {
         }
     }
     
+    func retrySend(_ eventOrTransactionID: TimelineItemIdentifier.EventOrTransactionID, target: SendTarget) async -> Result<Bool, TimelineProxyError> {
+        MXLog.info("Retrying \(target) send on timeline item: \(eventOrTransactionID)")
+        
+        do {
+            let hadPendingSend = try await timeline.retrySend(itemId: eventOrTransactionID.rustValue, target: target)
+            
+            MXLog.info("Retried \(target) send on timeline item: \(eventOrTransactionID), had one pending: \(hadPendingSend)")
+            
+            return .success(hadPendingSend)
+        } catch {
+            MXLog.error("Failed retrying \(target) send on timeline item: \(eventOrTransactionID) with error: \(error)")
+            return .failure(.sdkError(error))
+        }
+    }
+    
+    func abortSend(_ eventOrTransactionID: TimelineItemIdentifier.EventOrTransactionID, target: SendTarget) async -> Result<Bool, TimelineProxyError> {
+        MXLog.info("Aborting \(target) send on timeline item: \(eventOrTransactionID)")
+        
+        do {
+            let hadPendingSend = try await timeline.abortSend(itemId: eventOrTransactionID.rustValue, target: target)
+            
+            MXLog.info("Aborted \(target) send on timeline item: \(eventOrTransactionID), had one pending: \(hadPendingSend)")
+            
+            return .success(hadPendingSend)
+        } catch {
+            MXLog.error("Failed aborting \(target) send on timeline item: \(eventOrTransactionID) with error: \(error)")
+            return .failure(.sdkError(error))
+        }
+    }
+    
     func getLoadedReplyDetails(eventID: String) async -> Result<InReplyToDetails, TimelineProxyError> {
         do {
             return try await .success(timeline.loadReplyDetails(eventIdStr: eventID))

ElementX/Sources/Services/Timeline/TimelineProxyProtocol.swift

@@ -99,6 +99,12 @@ protocol TimelineProxyProtocol: Sendable {
     func redact(_ eventOrTransactionID: TimelineItemIdentifier.EventOrTransactionID,
                 reason: String?) async -> Result<Void, TimelineProxyError>
     
+    func retrySend(_ eventOrTransactionID: TimelineItemIdentifier.EventOrTransactionID,
+                   target: SendTarget) async -> Result<Bool, TimelineProxyError>
+    
+    func abortSend(_ eventOrTransactionID: TimelineItemIdentifier.EventOrTransactionID,
+                   target: SendTarget) async -> Result<Bool, TimelineProxyError>
+    
     func pin(eventID: String) async -> Result<Bool, TimelineProxyError>
     
     func unpin(eventID: String) async -> Result<Bool, TimelineProxyError>