sdk: update to 25.04.14

ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift

@@ -13641,6 +13641,81 @@ open class RoomSDKMock: MatrixRustSDK.Room, @unchecked Sendable {
         }
     }
 
+    //MARK: - memberWithSenderInfo
+
+    open var memberWithSenderInfoUserIdThrowableError: Error?
+    var memberWithSenderInfoUserIdUnderlyingCallsCount = 0
+    open var memberWithSenderInfoUserIdCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return memberWithSenderInfoUserIdUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = memberWithSenderInfoUserIdUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                memberWithSenderInfoUserIdUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    memberWithSenderInfoUserIdUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var memberWithSenderInfoUserIdCalled: Bool {
+        return memberWithSenderInfoUserIdCallsCount > 0
+    }
+    open var memberWithSenderInfoUserIdReceivedUserId: String?
+    open var memberWithSenderInfoUserIdReceivedInvocations: [String] = []
+
+    var memberWithSenderInfoUserIdUnderlyingReturnValue: RoomMemberWithSenderInfo!
+    open var memberWithSenderInfoUserIdReturnValue: RoomMemberWithSenderInfo! {
+        get {
+            if Thread.isMainThread {
+                return memberWithSenderInfoUserIdUnderlyingReturnValue
+            } else {
+                var returnValue: RoomMemberWithSenderInfo? = nil
+                DispatchQueue.main.sync {
+                    returnValue = memberWithSenderInfoUserIdUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                memberWithSenderInfoUserIdUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    memberWithSenderInfoUserIdUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var memberWithSenderInfoUserIdClosure: ((String) async throws -> RoomMemberWithSenderInfo)?
+
+    open override func memberWithSenderInfo(userId: String) async throws -> RoomMemberWithSenderInfo {
+        if let error = memberWithSenderInfoUserIdThrowableError {
+            throw error
+        }
+        memberWithSenderInfoUserIdCallsCount += 1
+        memberWithSenderInfoUserIdReceivedUserId = userId
+        DispatchQueue.main.async {
+            self.memberWithSenderInfoUserIdReceivedInvocations.append(userId)
+        }
+        if let memberWithSenderInfoUserIdClosure = memberWithSenderInfoUserIdClosure {
+            return try await memberWithSenderInfoUserIdClosure(userId)
+        } else {
+            return memberWithSenderInfoUserIdReturnValue
+        }
+    }
+
     //MARK: - members
 
     open var membersThrowableError: Error?
@@ -18625,13 +18700,13 @@ open class RoomPreviewSDKMock: MatrixRustSDK.RoomPreview, @unchecked Sendable {
         return ownMembershipDetailsCallsCount > 0
     }
 
-    var ownMembershipDetailsUnderlyingReturnValue: RoomMembershipDetails?
-    open var ownMembershipDetailsReturnValue: RoomMembershipDetails? {
+    var ownMembershipDetailsUnderlyingReturnValue: RoomMemberWithSenderInfo?
+    open var ownMembershipDetailsReturnValue: RoomMemberWithSenderInfo? {
         get {
             if Thread.isMainThread {
                 return ownMembershipDetailsUnderlyingReturnValue
             } else {
-                var returnValue: RoomMembershipDetails?? = nil
+                var returnValue: RoomMemberWithSenderInfo?? = nil
                 DispatchQueue.main.sync {
                     returnValue = ownMembershipDetailsUnderlyingReturnValue
                 }
@@ -18649,9 +18724,9 @@ open class RoomPreviewSDKMock: MatrixRustSDK.RoomPreview, @unchecked Sendable {
             }
         }
     }
-    open var ownMembershipDetailsClosure: (() async -> RoomMembershipDetails?)?
+    open var ownMembershipDetailsClosure: (() async -> RoomMemberWithSenderInfo?)?
 
-    open override func ownMembershipDetails() async -> RoomMembershipDetails? {
+    open override func ownMembershipDetails() async -> RoomMemberWithSenderInfo? {
         ownMembershipDetailsCallsCount += 1
         if let ownMembershipDetailsClosure = ownMembershipDetailsClosure {
             return await ownMembershipDetailsClosure()

ElementX/Sources/Other/Extensions/ClientBuilder.swift

@@ -21,7 +21,7 @@ extension ClientBuilder {
             .enableOidcRefreshLock()
             .setSessionDelegate(sessionDelegate: sessionDelegate)
             .userAgent(userAgent: UserAgentBuilder.makeASCIIUserAgent())
-            .requestConfig(config: .init(retryLimit: 0, timeout: 30000, maxConcurrentRequests: nil, retryTimeout: nil))
+            .requestConfig(config: .init(retryLimit: 0, timeout: 30000, maxConcurrentRequests: nil, maxRetryTime: nil))
             .useEventCachePersistentStorage(value: true)
         
         builder = switch slidingSync {

ElementX/Sources/Services/Authentication/AuthenticationService.swift

@@ -128,7 +128,7 @@ class AuthenticationService: AuthenticationServiceProtocol {
             }
             
             return await userSession(for: client)
-        } catch let ClientError.MatrixApi(errorKind, _, _) {
+        } catch let ClientError.MatrixApi(errorKind, _, _, _) {
             MXLog.error("Failed logging in with error kind: \(errorKind)")
             switch errorKind {
             case .forbidden:

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -437,7 +437,7 @@ class ClientProxy: ClientProxyProtocol {
             await waitForRoomToSync(roomID: roomID, timeout: .seconds(30))
             
             return .success(())
-        } catch ClientError.MatrixApi(.forbidden, _, _) {
+        } catch ClientError.MatrixApi(.forbidden, _, _, _) {
             MXLog.error("Failed joining roomAlias: \(roomID) forbidden")
             return .failure(.forbiddenAccess)
         } catch {
@@ -453,7 +453,7 @@ class ClientProxy: ClientProxyProtocol {
             await waitForRoomToSync(roomID: room.id(), timeout: .seconds(30))
             
             return .success(())
-        } catch ClientError.MatrixApi(.forbidden, _, _) {
+        } catch ClientError.MatrixApi(.forbidden, _, _, _) {
             MXLog.error("Failed joining roomAlias: \(roomAlias) forbidden")
             return .failure(.forbiddenAccess)
         } catch {
@@ -494,7 +494,7 @@ class ClientProxy: ClientProxyProtocol {
             let data = try Data(contentsOf: media.url)
             let matrixUrl = try await client.uploadMedia(mimeType: mimeType, data: data, progressWatcher: nil)
             return .success(matrixUrl)
-        } catch let ClientError.MatrixApi(errorKind, _, _) {
+        } catch let ClientError.MatrixApi(errorKind, _, _, _) {
             MXLog.error("Failed uploading media with error kind: \(errorKind)")
             return .failure(ClientProxyError.failedUploadingMedia(errorKind))
         } catch {
@@ -526,7 +526,7 @@ class ClientProxy: ClientProxyProtocol {
         do {
             let roomPreview = try await client.getRoomPreviewFromRoomId(roomId: identifier, viaServers: via)
             return try .success(RoomPreviewProxy(roomPreview: roomPreview))
-        } catch ClientError.MatrixApi(.forbidden, _, _) {
+        } catch ClientError.MatrixApi(.forbidden, _, _, _) {
             MXLog.error("Failed retrieving preview for room: \(identifier) is private")
             return .failure(.roomPreviewIsPrivate)
         } catch {

ElementX/Sources/Services/Keychain/KeychainController.swift

@@ -97,7 +97,7 @@ class KeychainController: KeychainControllerProtocol {
     func retrieveSessionFromKeychain(userId: String) throws -> Session {
         MXLog.info("Retrieving an updated Session from the keychain.")
         guard let session = restorationTokenForUsername(userId)?.session else {
-            throw ClientError.Generic(msg: "Failed to find RestorationToken in the Keychain.")
+            throw ClientError.Generic(msg: "Failed to find RestorationToken in the Keychain.", details: nil)
         }
         return session
     }

ElementX/Sources/Services/Notification/Proxy/NotificationItemProxy.swift

@@ -39,6 +39,15 @@ struct NotificationItemProxy: NotificationItemProxyProtocol {
     var isRoomDirect: Bool {
         notificationItem.roomInfo.isDirect
     }
+    
+    var isRoomPrivate: Bool {
+        switch notificationItem.roomInfo.joinRule {
+        case .invite, .knock, .restricted, .knockRestricted:
+            true
+        default:
+            false
+        }
+    }
 
     var roomJoinedMembers: Int {
         Int(notificationItem.roomInfo.joinedMembersCount)
@@ -89,6 +98,8 @@ struct EmptyNotificationItemProxy: NotificationItemProxyProtocol {
     var isNoisy: Bool { false }
 
     var isRoomDirect: Bool { false }
+    
+    var isRoomPrivate: Bool { false }
 
     var senderAvatarMediaSource: MediaSourceProxy? { nil }
 

ElementX/Sources/Services/Notification/Proxy/NotificationItemProxyProtocol.swift

@@ -29,6 +29,8 @@ protocol NotificationItemProxyProtocol {
     var roomJoinedMembers: Int { get }
 
     var isRoomDirect: Bool { get }
+    
+    var isRoomPrivate: Bool { get }
 
     var isNoisy: Bool { get }
 

ElementX/Sources/Services/Room/RoomPreview/RoomPreviewProxy.swift

@@ -24,11 +24,11 @@ final class RoomPreviewProxy: RoomPreviewProxyProtocol {
             }
             
             var senderRoomMember: RoomMemberProxy?
-            if let member = details.senderRoomMember {
+            if let member = details.senderInfo {
                 senderRoomMember = .init(member: member)
             }
             
-            return RoomMembershipDetailsProxy(ownRoomMember: RoomMemberProxy(member: details.ownRoomMember),
+            return RoomMembershipDetailsProxy(ownRoomMember: RoomMemberProxy(member: details.roomMember),
                                               senderRoomMember: senderRoomMember)
         }
     }