Fix stuck unread indicators.

ElementX.xcodeproj/project.pbxproj

@@ -7424,7 +7424,7 @@
 			repositoryURL = "https://github.com/element-hq/matrix-rust-components-swift";
 			requirement = {
 				kind = exactVersion;
-				version = 1.0.23;
+				version = 1.0.24;
 			};
 		};
 		701C7BEF8F70F7A83E852DCC /* XCRemoteSwiftPackageReference "GZIP" */ = {

ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -148,8 +148,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/element-hq/matrix-rust-components-swift",
       "state" : {
-        "revision" : "683298347d5c9612cdfaebc39b13ad05b1eaa835",
-        "version" : "1.0.23"
+        "revision" : "dc2d7ac4b7293a0dce1d37c3dea8da52be5d6932",
+        "version" : "1.0.24"
       }
     },
     {

ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift

@@ -2185,6 +2185,46 @@ open class ClientSDKMock: MatrixRustSDK.Client {
         try await removeAvatarClosure?()
     }
 
+    //MARK: - resetServerCapabilities
+
+    open var resetServerCapabilitiesThrowableError: Error?
+    var resetServerCapabilitiesUnderlyingCallsCount = 0
+    open var resetServerCapabilitiesCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return resetServerCapabilitiesUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = resetServerCapabilitiesUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                resetServerCapabilitiesUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    resetServerCapabilitiesUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var resetServerCapabilitiesCalled: Bool {
+        return resetServerCapabilitiesCallsCount > 0
+    }
+    open var resetServerCapabilitiesClosure: (() async throws -> Void)?
+
+    open override func resetServerCapabilities() async throws {
+        if let error = resetServerCapabilitiesThrowableError {
+            throw error
+        }
+        resetServerCapabilitiesCallsCount += 1
+        try await resetServerCapabilitiesClosure?()
+    }
+
     //MARK: - resolveRoomAlias
 
     open var resolveRoomAliasRoomAliasThrowableError: Error?
@@ -2789,6 +2829,81 @@ open class ClientSDKMock: MatrixRustSDK.Client {
         try await setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangClosure?(identifiers, kind, appDisplayName, deviceDisplayName, profileTag, lang)
     }
 
+    //MARK: - startSsoLogin
+
+    open var startSsoLoginRedirectUrlIdpIdThrowableError: Error?
+    var startSsoLoginRedirectUrlIdpIdUnderlyingCallsCount = 0
+    open var startSsoLoginRedirectUrlIdpIdCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return startSsoLoginRedirectUrlIdpIdUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = startSsoLoginRedirectUrlIdpIdUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                startSsoLoginRedirectUrlIdpIdUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    startSsoLoginRedirectUrlIdpIdUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var startSsoLoginRedirectUrlIdpIdCalled: Bool {
+        return startSsoLoginRedirectUrlIdpIdCallsCount > 0
+    }
+    open var startSsoLoginRedirectUrlIdpIdReceivedArguments: (redirectUrl: String, idpId: String?)?
+    open var startSsoLoginRedirectUrlIdpIdReceivedInvocations: [(redirectUrl: String, idpId: String?)] = []
+
+    var startSsoLoginRedirectUrlIdpIdUnderlyingReturnValue: SsoHandler!
+    open var startSsoLoginRedirectUrlIdpIdReturnValue: SsoHandler! {
+        get {
+            if Thread.isMainThread {
+                return startSsoLoginRedirectUrlIdpIdUnderlyingReturnValue
+            } else {
+                var returnValue: SsoHandler? = nil
+                DispatchQueue.main.sync {
+                    returnValue = startSsoLoginRedirectUrlIdpIdUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                startSsoLoginRedirectUrlIdpIdUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    startSsoLoginRedirectUrlIdpIdUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var startSsoLoginRedirectUrlIdpIdClosure: ((String, String?) async throws -> SsoHandler)?
+
+    open override func startSsoLogin(redirectUrl: String, idpId: String?) async throws -> SsoHandler {
+        if let error = startSsoLoginRedirectUrlIdpIdThrowableError {
+            throw error
+        }
+        startSsoLoginRedirectUrlIdpIdCallsCount += 1
+        startSsoLoginRedirectUrlIdpIdReceivedArguments = (redirectUrl: redirectUrl, idpId: idpId)
+        DispatchQueue.main.async {
+            self.startSsoLoginRedirectUrlIdpIdReceivedInvocations.append((redirectUrl: redirectUrl, idpId: idpId))
+        }
+        if let startSsoLoginRedirectUrlIdpIdClosure = startSsoLoginRedirectUrlIdpIdClosure {
+            return try await startSsoLoginRedirectUrlIdpIdClosure(redirectUrl, idpId)
+        } else {
+            return startSsoLoginRedirectUrlIdpIdReturnValue
+        }
+    }
+
     //MARK: - subscribeToIgnoredUsers
 
     var subscribeToIgnoredUsersListenerUnderlyingCallsCount = 0
@@ -4482,77 +4597,6 @@ open class ClientBuilderSDKMock: MatrixRustSDK.ClientBuilder {
         }
     }
 
-    //MARK: - serverVersions
-
-    var serverVersionsVersionsUnderlyingCallsCount = 0
-    open var serverVersionsVersionsCallsCount: Int {
-        get {
-            if Thread.isMainThread {
-                return serverVersionsVersionsUnderlyingCallsCount
-            } else {
-                var returnValue: Int? = nil
-                DispatchQueue.main.sync {
-                    returnValue = serverVersionsVersionsUnderlyingCallsCount
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                serverVersionsVersionsUnderlyingCallsCount = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    serverVersionsVersionsUnderlyingCallsCount = newValue
-                }
-            }
-        }
-    }
-    open var serverVersionsVersionsCalled: Bool {
-        return serverVersionsVersionsCallsCount > 0
-    }
-    open var serverVersionsVersionsReceivedVersions: [String]?
-    open var serverVersionsVersionsReceivedInvocations: [[String]] = []
-
-    var serverVersionsVersionsUnderlyingReturnValue: ClientBuilder!
-    open var serverVersionsVersionsReturnValue: ClientBuilder! {
-        get {
-            if Thread.isMainThread {
-                return serverVersionsVersionsUnderlyingReturnValue
-            } else {
-                var returnValue: ClientBuilder? = nil
-                DispatchQueue.main.sync {
-                    returnValue = serverVersionsVersionsUnderlyingReturnValue
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                serverVersionsVersionsUnderlyingReturnValue = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    serverVersionsVersionsUnderlyingReturnValue = newValue
-                }
-            }
-        }
-    }
-    open var serverVersionsVersionsClosure: (([String]) -> ClientBuilder)?
-
-    open override func serverVersions(versions: [String]) -> ClientBuilder {
-        serverVersionsVersionsCallsCount += 1
-        serverVersionsVersionsReceivedVersions = versions
-        DispatchQueue.main.async {
-            self.serverVersionsVersionsReceivedInvocations.append(versions)
-        }
-        if let serverVersionsVersionsClosure = serverVersionsVersionsClosure {
-            return serverVersionsVersionsClosure(versions)
-        } else {
-            return serverVersionsVersionsReturnValue
-        }
-    }
-
     //MARK: - sessionPath
 
     var sessionPathPathUnderlyingCallsCount = 0
@@ -16677,6 +16721,128 @@ open class SpanSDKMock: MatrixRustSDK.Span {
         }
     }
 }
+open class SsoHandlerSDKMock: MatrixRustSDK.SsoHandler {
+    init() {
+        super.init(noPointer: .init())
+    }
+
+    public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        fatalError("init(unsafeFromRawPointer:) has not been implemented")
+    }
+
+    fileprivate var pointer: UnsafeMutableRawPointer!
+
+    //MARK: - finish
+
+    open var finishCallbackUrlThrowableError: Error?
+    var finishCallbackUrlUnderlyingCallsCount = 0
+    open var finishCallbackUrlCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return finishCallbackUrlUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = finishCallbackUrlUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                finishCallbackUrlUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    finishCallbackUrlUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var finishCallbackUrlCalled: Bool {
+        return finishCallbackUrlCallsCount > 0
+    }
+    open var finishCallbackUrlReceivedCallbackUrl: String?
+    open var finishCallbackUrlReceivedInvocations: [String] = []
+    open var finishCallbackUrlClosure: ((String) async throws -> Void)?
+
+    open override func finish(callbackUrl: String) async throws {
+        if let error = finishCallbackUrlThrowableError {
+            throw error
+        }
+        finishCallbackUrlCallsCount += 1
+        finishCallbackUrlReceivedCallbackUrl = callbackUrl
+        DispatchQueue.main.async {
+            self.finishCallbackUrlReceivedInvocations.append(callbackUrl)
+        }
+        try await finishCallbackUrlClosure?(callbackUrl)
+    }
+
+    //MARK: - url
+
+    var urlUnderlyingCallsCount = 0
+    open var urlCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return urlUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = urlUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                urlUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    urlUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var urlCalled: Bool {
+        return urlCallsCount > 0
+    }
+
+    var urlUnderlyingReturnValue: String!
+    open var urlReturnValue: String! {
+        get {
+            if Thread.isMainThread {
+                return urlUnderlyingReturnValue
+            } else {
+                var returnValue: String? = nil
+                DispatchQueue.main.sync {
+                    returnValue = urlUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                urlUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    urlUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var urlClosure: (() -> String)?
+
+    open override func url() -> String {
+        urlCallsCount += 1
+        if let urlClosure = urlClosure {
+            return urlClosure()
+        } else {
+            return urlReturnValue
+        }
+    }
+}
 open class SyncServiceSDKMock: MatrixRustSDK.SyncService {
     init() {
         super.init(noPointer: .init())

ElementX/Sources/Other/Extensions/ClientBuilder.swift

@@ -24,7 +24,6 @@ extension ClientBuilder {
             .slidingSyncProxy(slidingSyncProxy: slidingSyncProxy?.absoluteString)
             .enableCrossProcessRefreshLock(processId: InfoPlistReader.main.bundleIdentifier, sessionDelegate: sessionDelegate)
             .userAgent(userAgent: UserAgentBuilder.makeASCIIUserAgent())
-            .serverVersions(versions: ["v1.0", "v1.1", "v1.2", "v1.3", "v1.4", "v1.5"]) // FIXME: Quick and dirty fix for stopping version requests on startup https://github.com/matrix-org/matrix-rust-sdk/pull/1376
 
         if setupEncryption {
             builder = builder

project.yml

@@ -60,7 +60,7 @@ packages:
   # Element/Matrix dependencies
   MatrixRustSDK:
     url: https://github.com/element-hq/matrix-rust-components-swift
-    exactVersion: 1.0.23
+    exactVersion: 1.0.24
     # path: ../matrix-rust-sdk
   Compound:
     url: https://github.com/element-hq/compound-ios