Bump the RustSDK to v1.0.11

ElementX/Sources/Application/AppCoordinator.swift

@@ -670,8 +670,6 @@ class AppCoordinator: AppCoordinatorProtocol, AuthenticationFlowCoordinatorDeleg
                 MXLog.info("Reachability changed to \(reachability)")
                 
                 if reachability == .reachable {
-                    self?.userSession?.clientProxy.setSendingQueueEnabled(true)
-                    
                     ServiceLocator.shared.userIndicatorController.retractIndicatorWithId(reachabilityNotificationIdentifier)
                 } else {
                     ServiceLocator.shared.userIndicatorController.submitIndicator(.init(id: reachabilityNotificationIdentifier,

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -3496,45 +3496,6 @@ class ClientProxyMock: ClientProxyProtocol {
             return resolveRoomAliasReturnValue
         }
     }
-    //MARK: - setSendingQueueEnabled
-
-    var setSendingQueueEnabledUnderlyingCallsCount = 0
-    var setSendingQueueEnabledCallsCount: Int {
-        get {
-            if Thread.isMainThread {
-                return setSendingQueueEnabledUnderlyingCallsCount
-            } else {
-                var returnValue: Int? = nil
-                DispatchQueue.main.sync {
-                    returnValue = setSendingQueueEnabledUnderlyingCallsCount
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                setSendingQueueEnabledUnderlyingCallsCount = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    setSendingQueueEnabledUnderlyingCallsCount = newValue
-                }
-            }
-        }
-    }
-    var setSendingQueueEnabledCalled: Bool {
-        return setSendingQueueEnabledCallsCount > 0
-    }
-    var setSendingQueueEnabledReceivedEnabled: Bool?
-    var setSendingQueueEnabledReceivedInvocations: [Bool] = []
-    var setSendingQueueEnabledClosure: ((Bool) -> Void)?
-
-    func setSendingQueueEnabled(_ enabled: Bool) {
-        setSendingQueueEnabledCallsCount += 1
-        setSendingQueueEnabledReceivedEnabled = enabled
-        setSendingQueueEnabledReceivedInvocations.append(enabled)
-        setSendingQueueEnabledClosure?(enabled)
-    }
     //MARK: - ignoreUser
 
     var ignoreUserUnderlyingCallsCount = 0

ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift

@@ -965,17 +965,17 @@ open class ClientSDKMock: MatrixRustSDK.Client {
         }
     }
 
-    //MARK: - enableSendingQueue
+    //MARK: - enableAllSendQueues
 
-    var enableSendingQueueEnableUnderlyingCallsCount = 0
-    open var enableSendingQueueEnableCallsCount: Int {
+    var enableAllSendQueuesEnableUnderlyingCallsCount = 0
+    open var enableAllSendQueuesEnableCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return enableSendingQueueEnableUnderlyingCallsCount
+                return enableAllSendQueuesEnableUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = enableSendingQueueEnableUnderlyingCallsCount
+                    returnValue = enableAllSendQueuesEnableUnderlyingCallsCount
                 }
 
                 return returnValue!
@@ -983,26 +983,26 @@ open class ClientSDKMock: MatrixRustSDK.Client {
         }
         set {
             if Thread.isMainThread {
-                enableSendingQueueEnableUnderlyingCallsCount = newValue
+                enableAllSendQueuesEnableUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    enableSendingQueueEnableUnderlyingCallsCount = newValue
+                    enableAllSendQueuesEnableUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    open var enableSendingQueueEnableCalled: Bool {
-        return enableSendingQueueEnableCallsCount > 0
+    open var enableAllSendQueuesEnableCalled: Bool {
+        return enableAllSendQueuesEnableCallsCount > 0
     }
-    open var enableSendingQueueEnableReceivedEnable: Bool?
-    open var enableSendingQueueEnableReceivedInvocations: [Bool] = []
-    open var enableSendingQueueEnableClosure: ((Bool) -> Void)?
+    open var enableAllSendQueuesEnableReceivedEnable: Bool?
+    open var enableAllSendQueuesEnableReceivedInvocations: [Bool] = []
+    open var enableAllSendQueuesEnableClosure: ((Bool) -> Void)?
 
-    open override func enableSendingQueue(enable: Bool) {
-        enableSendingQueueEnableCallsCount += 1
-        enableSendingQueueEnableReceivedEnable = enable
-        enableSendingQueueEnableReceivedInvocations.append(enable)
-        enableSendingQueueEnableClosure?(enable)
+    open override func enableAllSendQueues(enable: Bool) {
+        enableAllSendQueuesEnableCallsCount += 1
+        enableAllSendQueuesEnableReceivedEnable = enable
+        enableAllSendQueuesEnableReceivedInvocations.append(enable)
+        enableAllSendQueuesEnableClosure?(enable)
     }
 
     //MARK: - encryption
@@ -2993,17 +2993,17 @@ open class ClientSDKMock: MatrixRustSDK.Client {
         }
     }
 
-    //MARK: - subscribeToSendingQueueStatus
+    //MARK: - subscribeToSendQueueStatus
 
-    var subscribeToSendingQueueStatusListenerUnderlyingCallsCount = 0
-    open var subscribeToSendingQueueStatusListenerCallsCount: Int {
+    var subscribeToSendQueueStatusListenerUnderlyingCallsCount = 0
+    open var subscribeToSendQueueStatusListenerCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return subscribeToSendingQueueStatusListenerUnderlyingCallsCount
+                return subscribeToSendQueueStatusListenerUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = subscribeToSendingQueueStatusListenerUnderlyingCallsCount
+                    returnValue = subscribeToSendQueueStatusListenerUnderlyingCallsCount
                 }
 
                 return returnValue!
@@ -3011,29 +3011,29 @@ open class ClientSDKMock: MatrixRustSDK.Client {
         }
         set {
             if Thread.isMainThread {
-                subscribeToSendingQueueStatusListenerUnderlyingCallsCount = newValue
+                subscribeToSendQueueStatusListenerUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    subscribeToSendingQueueStatusListenerUnderlyingCallsCount = newValue
+                    subscribeToSendQueueStatusListenerUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    open var subscribeToSendingQueueStatusListenerCalled: Bool {
-        return subscribeToSendingQueueStatusListenerCallsCount > 0
+    open var subscribeToSendQueueStatusListenerCalled: Bool {
+        return subscribeToSendQueueStatusListenerCallsCount > 0
     }
-    open var subscribeToSendingQueueStatusListenerReceivedListener: SendingQueueStatusListener?
-    open var subscribeToSendingQueueStatusListenerReceivedInvocations: [SendingQueueStatusListener] = []
+    open var subscribeToSendQueueStatusListenerReceivedListener: SendQueueRoomErrorListener?
+    open var subscribeToSendQueueStatusListenerReceivedInvocations: [SendQueueRoomErrorListener] = []
 
-    var subscribeToSendingQueueStatusListenerUnderlyingReturnValue: TaskHandle!
-    open var subscribeToSendingQueueStatusListenerReturnValue: TaskHandle! {
+    var subscribeToSendQueueStatusListenerUnderlyingReturnValue: TaskHandle!
+    open var subscribeToSendQueueStatusListenerReturnValue: TaskHandle! {
         get {
             if Thread.isMainThread {
-                return subscribeToSendingQueueStatusListenerUnderlyingReturnValue
+                return subscribeToSendQueueStatusListenerUnderlyingReturnValue
             } else {
                 var returnValue: TaskHandle? = nil
                 DispatchQueue.main.sync {
-                    returnValue = subscribeToSendingQueueStatusListenerUnderlyingReturnValue
+                    returnValue = subscribeToSendQueueStatusListenerUnderlyingReturnValue
                 }
 
                 return returnValue!
@@ -3041,24 +3041,24 @@ open class ClientSDKMock: MatrixRustSDK.Client {
         }
         set {
             if Thread.isMainThread {
-                subscribeToSendingQueueStatusListenerUnderlyingReturnValue = newValue
+                subscribeToSendQueueStatusListenerUnderlyingReturnValue = newValue
             } else {
                 DispatchQueue.main.sync {
-                    subscribeToSendingQueueStatusListenerUnderlyingReturnValue = newValue
+                    subscribeToSendQueueStatusListenerUnderlyingReturnValue = newValue
                 }
             }
         }
     }
-    open var subscribeToSendingQueueStatusListenerClosure: ((SendingQueueStatusListener) -> TaskHandle)?
+    open var subscribeToSendQueueStatusListenerClosure: ((SendQueueRoomErrorListener) -> TaskHandle)?
 
-    open override func subscribeToSendingQueueStatus(listener: SendingQueueStatusListener) -> TaskHandle {
-        subscribeToSendingQueueStatusListenerCallsCount += 1
-        subscribeToSendingQueueStatusListenerReceivedListener = listener
-        subscribeToSendingQueueStatusListenerReceivedInvocations.append(listener)
-        if let subscribeToSendingQueueStatusListenerClosure = subscribeToSendingQueueStatusListenerClosure {
-            return subscribeToSendingQueueStatusListenerClosure(listener)
+    open override func subscribeToSendQueueStatus(listener: SendQueueRoomErrorListener) -> TaskHandle {
+        subscribeToSendQueueStatusListenerCallsCount += 1
+        subscribeToSendQueueStatusListenerReceivedListener = listener
+        subscribeToSendQueueStatusListenerReceivedInvocations.append(listener)
+        if let subscribeToSendQueueStatusListenerClosure = subscribeToSendQueueStatusListenerClosure {
+            return subscribeToSendQueueStatusListenerClosure(listener)
         } else {
-            return subscribeToSendingQueueStatusListenerReturnValue
+            return subscribeToSendQueueStatusListenerReturnValue
         }
     }
 
@@ -10290,7 +10290,6 @@ open class RoomSDKMock: MatrixRustSDK.Room {
 
     //MARK: - displayName
 
-    open var displayNameThrowableError: Error?
     var displayNameUnderlyingCallsCount = 0
     open var displayNameCallsCount: Int {
         get {
@@ -10319,13 +10318,13 @@ open class RoomSDKMock: MatrixRustSDK.Room {
         return displayNameCallsCount > 0
     }
 
-    var displayNameUnderlyingReturnValue: String!
-    open var displayNameReturnValue: String! {
+    var displayNameUnderlyingReturnValue: String?
+    open var displayNameReturnValue: String? {
         get {
             if Thread.isMainThread {
                 return displayNameUnderlyingReturnValue
             } else {
-                var returnValue: String? = nil
+                var returnValue: String?? = nil
                 DispatchQueue.main.sync {
                     returnValue = displayNameUnderlyingReturnValue
                 }
@@ -10343,20 +10342,57 @@ open class RoomSDKMock: MatrixRustSDK.Room {
             }
         }
     }
-    open var displayNameClosure: (() throws -> String)?
+    open var displayNameClosure: (() -> String?)?
 
-    open override func displayName() throws -> String {
-        if let error = displayNameThrowableError {
-            throw error
-        }
+    open override func displayName() -> String? {
         displayNameCallsCount += 1
         if let displayNameClosure = displayNameClosure {
-            return try displayNameClosure()
+            return displayNameClosure()
         } else {
             return displayNameReturnValue
         }
     }
 
+    //MARK: - enableSendQueue
+
+    var enableSendQueueEnableUnderlyingCallsCount = 0
+    open var enableSendQueueEnableCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return enableSendQueueEnableUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = enableSendQueueEnableUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                enableSendQueueEnableUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    enableSendQueueEnableUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var enableSendQueueEnableCalled: Bool {
+        return enableSendQueueEnableCallsCount > 0
+    }
+    open var enableSendQueueEnableReceivedEnable: Bool?
+    open var enableSendQueueEnableReceivedInvocations: [Bool] = []
+    open var enableSendQueueEnableClosure: ((Bool) -> Void)?
+
+    open override func enableSendQueue(enable: Bool) {
+        enableSendQueueEnableCallsCount += 1
+        enableSendQueueEnableReceivedEnable = enable
+        enableSendQueueEnableReceivedInvocations.append(enable)
+        enableSendQueueEnableClosure?(enable)
+    }
+
     //MARK: - getPowerLevels
 
     open var getPowerLevelsThrowableError: Error?
@@ -10973,6 +11009,71 @@ open class RoomSDKMock: MatrixRustSDK.Room {
         }
     }
 
+    //MARK: - isSendQueueEnabled
+
+    var isSendQueueEnabledUnderlyingCallsCount = 0
+    open var isSendQueueEnabledCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return isSendQueueEnabledUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = isSendQueueEnabledUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                isSendQueueEnabledUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    isSendQueueEnabledUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var isSendQueueEnabledCalled: Bool {
+        return isSendQueueEnabledCallsCount > 0
+    }
+
+    var isSendQueueEnabledUnderlyingReturnValue: Bool!
+    open var isSendQueueEnabledReturnValue: Bool! {
+        get {
+            if Thread.isMainThread {
+                return isSendQueueEnabledUnderlyingReturnValue
+            } else {
+                var returnValue: Bool? = nil
+                DispatchQueue.main.sync {
+                    returnValue = isSendQueueEnabledUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                isSendQueueEnabledUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    isSendQueueEnabledUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var isSendQueueEnabledClosure: (() -> Bool)?
+
+    open override func isSendQueueEnabled() -> Bool {
+        isSendQueueEnabledCallsCount += 1
+        if let isSendQueueEnabledClosure = isSendQueueEnabledClosure {
+            return isSendQueueEnabledClosure()
+        } else {
+            return isSendQueueEnabledReturnValue
+        }
+    }
+
     //MARK: - isSpace
 
     var isSpaceUnderlyingCallsCount = 0
@@ -16352,14 +16453,14 @@ open class SyncServiceBuilderSDKMock: MatrixRustSDK.SyncServiceBuilder {
             }
         }
     }
-    open var withUtdHookDelegateClosure: ((UnableToDecryptDelegate) -> SyncServiceBuilder)?
+    open var withUtdHookDelegateClosure: ((UnableToDecryptDelegate) async -> SyncServiceBuilder)?
 
-    open override func withUtdHook(delegate: UnableToDecryptDelegate) -> SyncServiceBuilder {
+    open override func withUtdHook(delegate: UnableToDecryptDelegate) async -> SyncServiceBuilder {
         withUtdHookDelegateCallsCount += 1
         withUtdHookDelegateReceivedDelegate = delegate
         withUtdHookDelegateReceivedInvocations.append(delegate)
         if let withUtdHookDelegateClosure = withUtdHookDelegateClosure {
-            return withUtdHookDelegateClosure(delegate)
+            return await withUtdHookDelegateClosure(delegate)
         } else {
             return withUtdHookDelegateReturnValue
         }

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -45,7 +45,7 @@ class ClientProxy: ClientProxyProtocol {
     private var verificationStateListenerTaskHandle: TaskHandle?
     
     // periphery:ignore - required for instance retention in the rust codebase
-    private var sendingQueueListenerTaskHandle: TaskHandle?
+    private var sendQueueListenerTaskHandle: TaskHandle?
     
     private var delegateHandle: TaskHandle?
     
@@ -120,7 +120,7 @@ class ClientProxy: ClientProxyProtocol {
         verificationStateSubject.asCurrentValuePublisher()
     }
     
-    private let sendingQueueStatusSubject = CurrentValueSubject<Bool, Never>(false)
+    private let sendQueueStatusSubject = CurrentValueSubject<Bool, Never>(false)
     
     init(client: ClientProtocol,
          networkMonitor: NetworkMonitorProtocol) async {
@@ -164,21 +164,21 @@ class ClientProxy: ClientProxyProtocol {
             self?.updateVerificationState(verificationState)
         })
         
-        sendingQueueListenerTaskHandle = client.subscribeToSendingQueueStatus(listener: SendingQueueStatusListenerProxy { [weak self] enabled in
-            self?.sendingQueueStatusSubject.send(enabled)
+        sendQueueListenerTaskHandle = client.subscribeToSendQueueStatus(listener: SendQueueRoomErrorListenerProxy { [weak self] roomID, error in
+            MXLog.error("Send queue failed in room: \(roomID) with error: \(error)")
+            self?.sendQueueStatusSubject.send(false)
         })
         
-        sendingQueueStatusSubject
+        sendQueueStatusSubject
             .removeDuplicates()
-            .debounce(for: 0.25, scheduler: DispatchQueue.main)
-            .sink { [weak self] enabled in
-                guard let self else { return }
+            .combineLatest(networkMonitor.reachabilityPublisher)
+            .debounce(for: 1.0, scheduler: DispatchQueue.main)
+            .sink { enabled, reachability in
+                MXLog.info("Send queue status changed to enabled: \(enabled)")
                 
-                MXLog.info("Sending queue status changed to enabled: \(enabled)")
-                
-                if enabled == false,
-                   networkMonitor.reachabilityPublisher.value == .reachable {
-                    setSendingQueueEnabled(true)
+                if enabled == false, reachability == .reachable {
+                    MXLog.info("Enabling all send queues")
+                    client.enableAllSendQueues(enable: true)
                 }
             }
             .store(in: &cancellables)
@@ -598,12 +598,7 @@ class ClientProxy: ClientProxyProtocol {
             return .failure(.sdkError(error))
         }
     }
-    
-    func setSendingQueueEnabled(_ enabled: Bool) {
-        MXLog.info("Setting sending queue to enabled: \(enabled)")
-        client.enableSendingQueue(enable: enabled)
-    }
-    
+        
     // MARK: Ignored users
     
     func ignoreUser(_ userID: String) async -> Result<Void, ClientProxyError> {
@@ -946,15 +941,15 @@ private class IgnoredUsersListenerProxy: IgnoredUsersListener {
     }
 }
 
-private class SendingQueueStatusListenerProxy: SendingQueueStatusListener {
-    private let onUpdateClosure: (Bool) -> Void
+private class SendQueueRoomErrorListenerProxy: SendQueueRoomErrorListener {
+    private let onErrorClosure: (String, ClientError) -> Void
     
-    init(onUpdateClosure: @escaping (Bool) -> Void) {
-        self.onUpdateClosure = onUpdateClosure
+    init(onErrorClosure: @escaping (String, ClientError) -> Void) {
+        self.onErrorClosure = onErrorClosure
     }
     
-    func onUpdate(newValue: Bool) {
-        onUpdateClosure(newValue)
+    func onError(roomId: String, error: ClientError) {
+        onErrorClosure(roomId, error)
     }
 }
 

ElementX/Sources/Services/Client/ClientProxyProtocol.swift

@@ -160,8 +160,6 @@ protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
     func roomDirectorySearchProxy() -> RoomDirectorySearchProxyProtocol
     
     func resolveRoomAlias(_ alias: String) async -> Result<ResolvedRoomAlias, ClientProxyError>
-    
-    func setSendingQueueEnabled(_ enabled: Bool)
 
     // MARK: - Ignored users