Update the SDK fixing a few room list bugs.

ElementX.xcodeproj/project.pbxproj

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

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

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

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -10618,66 +10618,72 @@ class RoomProxyMock: RoomProxyProtocol {
     }
     //MARK: - elementCallWidgetDriver
 
-    var elementCallWidgetDriverUnderlyingCallsCount = 0
-    var elementCallWidgetDriverCallsCount: Int {
+    var elementCallWidgetDriverDeviceIDUnderlyingCallsCount = 0
+    var elementCallWidgetDriverDeviceIDCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return elementCallWidgetDriverUnderlyingCallsCount
+                return elementCallWidgetDriverDeviceIDUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = elementCallWidgetDriverUnderlyingCallsCount
+                    returnValue = elementCallWidgetDriverDeviceIDUnderlyingCallsCount
                 }
 
                 return returnValue!
             }
         }
         set {
             if Thread.isMainThread {
-                elementCallWidgetDriverUnderlyingCallsCount = newValue
+                elementCallWidgetDriverDeviceIDUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    elementCallWidgetDriverUnderlyingCallsCount = newValue
+                    elementCallWidgetDriverDeviceIDUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    var elementCallWidgetDriverCalled: Bool {
-        return elementCallWidgetDriverCallsCount > 0
+    var elementCallWidgetDriverDeviceIDCalled: Bool {
+        return elementCallWidgetDriverDeviceIDCallsCount > 0
     }
+    var elementCallWidgetDriverDeviceIDReceivedDeviceID: String?
+    var elementCallWidgetDriverDeviceIDReceivedInvocations: [String] = []
 
-    var elementCallWidgetDriverUnderlyingReturnValue: ElementCallWidgetDriverProtocol!
-    var elementCallWidgetDriverReturnValue: ElementCallWidgetDriverProtocol! {
+    var elementCallWidgetDriverDeviceIDUnderlyingReturnValue: ElementCallWidgetDriverProtocol!
+    var elementCallWidgetDriverDeviceIDReturnValue: ElementCallWidgetDriverProtocol! {
         get {
             if Thread.isMainThread {
-                return elementCallWidgetDriverUnderlyingReturnValue
+                return elementCallWidgetDriverDeviceIDUnderlyingReturnValue
             } else {
                 var returnValue: ElementCallWidgetDriverProtocol? = nil
                 DispatchQueue.main.sync {
-                    returnValue = elementCallWidgetDriverUnderlyingReturnValue
+                    returnValue = elementCallWidgetDriverDeviceIDUnderlyingReturnValue
                 }
 
                 return returnValue!
             }
         }
         set {
             if Thread.isMainThread {
-                elementCallWidgetDriverUnderlyingReturnValue = newValue
+                elementCallWidgetDriverDeviceIDUnderlyingReturnValue = newValue
             } else {
                 DispatchQueue.main.sync {
-                    elementCallWidgetDriverUnderlyingReturnValue = newValue
+                    elementCallWidgetDriverDeviceIDUnderlyingReturnValue = newValue
                 }
             }
         }
     }
-    var elementCallWidgetDriverClosure: (() -> ElementCallWidgetDriverProtocol)?
+    var elementCallWidgetDriverDeviceIDClosure: ((String) -> ElementCallWidgetDriverProtocol)?
 
-    func elementCallWidgetDriver() -> ElementCallWidgetDriverProtocol {
-        elementCallWidgetDriverCallsCount += 1
-        if let elementCallWidgetDriverClosure = elementCallWidgetDriverClosure {
-            return elementCallWidgetDriverClosure()
+    func elementCallWidgetDriver(deviceID: String) -> ElementCallWidgetDriverProtocol {
+        elementCallWidgetDriverDeviceIDCallsCount += 1
+        elementCallWidgetDriverDeviceIDReceivedDeviceID = deviceID
+        DispatchQueue.main.async {
+            self.elementCallWidgetDriverDeviceIDReceivedInvocations.append(deviceID)
+        }
+        if let elementCallWidgetDriverDeviceIDClosure = elementCallWidgetDriverDeviceIDClosure {
+            return elementCallWidgetDriverDeviceIDClosure(deviceID)
         } else {
-            return elementCallWidgetDriverReturnValue
+            return elementCallWidgetDriverDeviceIDReturnValue
         }
     }
     //MARK: - sendCallNotificationIfNeeeded

ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift

@@ -1,4 +1,4 @@
-// Generated using Sourcery 2.2.4 — https://github.com/krzysztofzablocki/Sourcery
+// Generated using Sourcery 2.2.5 — https://github.com/krzysztofzablocki/Sourcery
 // DO NOT EDIT
 
 // swiftlint:disable all
@@ -6337,6 +6337,77 @@ open class EventTimelineItemSDKMock: MatrixRustSDK.EventTimelineItem {
         }
     }
 
+    //MARK: - getShield
+
+    var getShieldStrictUnderlyingCallsCount = 0
+    open var getShieldStrictCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return getShieldStrictUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = getShieldStrictUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                getShieldStrictUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    getShieldStrictUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var getShieldStrictCalled: Bool {
+        return getShieldStrictCallsCount > 0
+    }
+    open var getShieldStrictReceivedStrict: Bool?
+    open var getShieldStrictReceivedInvocations: [Bool] = []
+
+    var getShieldStrictUnderlyingReturnValue: ShieldState?
+    open var getShieldStrictReturnValue: ShieldState? {
+        get {
+            if Thread.isMainThread {
+                return getShieldStrictUnderlyingReturnValue
+            } else {
+                var returnValue: ShieldState?? = nil
+                DispatchQueue.main.sync {
+                    returnValue = getShieldStrictUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                getShieldStrictUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    getShieldStrictUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var getShieldStrictClosure: ((Bool) -> ShieldState?)?
+
+    open override func getShield(strict: Bool) -> ShieldState? {
+        getShieldStrictCallsCount += 1
+        getShieldStrictReceivedStrict = strict
+        DispatchQueue.main.async {
+            self.getShieldStrictReceivedInvocations.append(strict)
+        }
+        if let getShieldStrictClosure = getShieldStrictClosure {
+            return getShieldStrictClosure(strict)
+        } else {
+            return getShieldStrictReturnValue
+        }
+    }
+
     //MARK: - isEditable
 
     var isEditableUnderlyingCallsCount = 0
@@ -10545,6 +10616,52 @@ open class RoomSDKMock: MatrixRustSDK.Room {
         }
     }
 
+    //MARK: - edit
+
+    open var editEventIdNewContentThrowableError: Error?
+    var editEventIdNewContentUnderlyingCallsCount = 0
+    open var editEventIdNewContentCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return editEventIdNewContentUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = editEventIdNewContentUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                editEventIdNewContentUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    editEventIdNewContentUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var editEventIdNewContentCalled: Bool {
+        return editEventIdNewContentCallsCount > 0
+    }
+    open var editEventIdNewContentReceivedArguments: (eventId: String, newContent: RoomMessageEventContentWithoutRelation)?
+    open var editEventIdNewContentReceivedInvocations: [(eventId: String, newContent: RoomMessageEventContentWithoutRelation)] = []
+    open var editEventIdNewContentClosure: ((String, RoomMessageEventContentWithoutRelation) async throws -> Void)?
+
+    open override func edit(eventId: String, newContent: RoomMessageEventContentWithoutRelation) async throws {
+        if let error = editEventIdNewContentThrowableError {
+            throw error
+        }
+        editEventIdNewContentCallsCount += 1
+        editEventIdNewContentReceivedArguments = (eventId: eventId, newContent: newContent)
+        DispatchQueue.main.async {
+            self.editEventIdNewContentReceivedInvocations.append((eventId: eventId, newContent: newContent))
+        }
+        try await editEventIdNewContentClosure?(eventId, newContent)
+    }
+
     //MARK: - enableSendQueue
 
     var enableSendQueueEnableUnderlyingCallsCount = 0
@@ -17603,52 +17720,6 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
         }
     }
 
-    //MARK: - editByEventId
-
-    open var editByEventIdEventIdNewContentThrowableError: Error?
-    var editByEventIdEventIdNewContentUnderlyingCallsCount = 0
-    open var editByEventIdEventIdNewContentCallsCount: Int {
-        get {
-            if Thread.isMainThread {
-                return editByEventIdEventIdNewContentUnderlyingCallsCount
-            } else {
-                var returnValue: Int? = nil
-                DispatchQueue.main.sync {
-                    returnValue = editByEventIdEventIdNewContentUnderlyingCallsCount
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                editByEventIdEventIdNewContentUnderlyingCallsCount = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    editByEventIdEventIdNewContentUnderlyingCallsCount = newValue
-                }
-            }
-        }
-    }
-    open var editByEventIdEventIdNewContentCalled: Bool {
-        return editByEventIdEventIdNewContentCallsCount > 0
-    }
-    open var editByEventIdEventIdNewContentReceivedArguments: (eventId: String, newContent: RoomMessageEventContentWithoutRelation)?
-    open var editByEventIdEventIdNewContentReceivedInvocations: [(eventId: String, newContent: RoomMessageEventContentWithoutRelation)] = []
-    open var editByEventIdEventIdNewContentClosure: ((String, RoomMessageEventContentWithoutRelation) async throws -> Void)?
-
-    open override func editByEventId(eventId: String, newContent: RoomMessageEventContentWithoutRelation) async throws {
-        if let error = editByEventIdEventIdNewContentThrowableError {
-            throw error
-        }
-        editByEventIdEventIdNewContentCallsCount += 1
-        editByEventIdEventIdNewContentReceivedArguments = (eventId: eventId, newContent: newContent)
-        DispatchQueue.main.async {
-            self.editByEventIdEventIdNewContentReceivedInvocations.append((eventId: eventId, newContent: newContent))
-        }
-        try await editByEventIdEventIdNewContentClosure?(eventId, newContent)
-    }
-
     //MARK: - editPoll
 
     open var editPollQuestionAnswersMaxSelectionsPollKindEditItemThrowableError: Error?

ElementX/Sources/Mocks/RoomProxyMock.swift

@@ -145,7 +145,7 @@ extension RoomProxyMock {
 
         widgetDriver.startBaseURLClientIDColorSchemeReturnValue = .success(url)
 
-        elementCallWidgetDriverReturnValue = widgetDriver
+        elementCallWidgetDriverDeviceIDReturnValue = widgetDriver
         sendCallNotificationIfNeeededReturnValue = .success(())
 
         matrixToPermalinkReturnValue = .success(.homeDirectory)

ElementX/Sources/Screens/CallScreen/CallScreenViewModel.swift

@@ -44,10 +44,12 @@ class CallScreenViewModel: CallScreenViewModelType, CallScreenViewModelProtocol
          elementCallBaseURL: URL,
          elementCallBaseURLOverride: URL?,
          colorScheme: ColorScheme) {
+        guard let deviceID = clientProxy.deviceID else { fatalError("Missing device ID for the call.") }
+
         self.elementCallService = elementCallService
         self.roomProxy = roomProxy
 
-        widgetDriver = roomProxy.elementCallWidgetDriver()
+        widgetDriver = roomProxy.elementCallWidgetDriver(deviceID: deviceID)
 
         super.init(initialViewState: CallScreenViewState(messageHandler: Self.eventHandlerName,
                                                          script: Self.eventHandlerInjectionScript))

ElementX/Sources/Screens/CallScreen/View/CallScreen.swift

@@ -185,7 +185,7 @@ struct CallScreen_Previews: PreviewProvider {
         widgetDriver.underlyingActions = PassthroughSubject<ElementCallWidgetDriverAction, Never>().eraseToAnyPublisher()
         widgetDriver.startBaseURLClientIDColorSchemeReturnValue = .success(URL.userDirectory)
 
-        roomProxy.elementCallWidgetDriverReturnValue = widgetDriver
+        roomProxy.elementCallWidgetDriverDeviceIDReturnValue = widgetDriver
 
         return CallScreenViewModel(elementCallService: ElementCallServiceMock(.init()),
                                    clientProxy: clientProxy,

ElementX/Sources/Services/ElementCall/ElementCallWidgetDriver.swift

@@ -39,6 +39,7 @@ private struct ElementCallWidgetMessage: Codable {
 
 class ElementCallWidgetDriver: WidgetCapabilitiesProvider, ElementCallWidgetDriverProtocol {
     private let room: RoomProtocol
+    private let deviceID: String
     private var widgetDriver: WidgetDriverAndHandle?
 
     let widgetID = UUID().uuidString
@@ -49,8 +50,9 @@ class ElementCallWidgetDriver: WidgetCapabilitiesProvider, ElementCallWidgetDriv
         actionsSubject.eraseToAnyPublisher()
     }
 
-    init(room: RoomProtocol) {
+    init(room: RoomProtocol, deviceID: String) {
         self.room = room
+        self.deviceID = deviceID
     }
 
     func start(baseURL: URL, clientID: String, colorScheme: ColorScheme) async -> Result<URL, ElementCallWidgetDriverError> {
@@ -143,7 +145,7 @@ class ElementCallWidgetDriver: WidgetCapabilitiesProvider, ElementCallWidgetDriv
     // MARK: - WidgetCapabilitiesProvider
 
     func acquireCapabilities(capabilities: WidgetCapabilities) -> WidgetCapabilities {
-        getElementCallRequiredPermissions(ownUserId: room.ownUserId())
+        getElementCallRequiredPermissions(ownUserId: room.ownUserId(), ownDeviceId: deviceID)
     }
 
     // MARK: - Private

ElementX/Sources/Services/Room/RoomProxy.swift

@@ -526,8 +526,8 @@ class RoomProxy: RoomProxyProtocol {
         }
     }
 
-    func elementCallWidgetDriver() -> ElementCallWidgetDriverProtocol {
-        ElementCallWidgetDriver(room: room)
+    func elementCallWidgetDriver(deviceID: String) -> ElementCallWidgetDriverProtocol {
+        ElementCallWidgetDriver(room: room, deviceID: deviceID)
     }
 
     func sendCallNotificationIfNeeeded() async -> Result<Void, RoomProxyError> {

ElementX/Sources/Services/Room/RoomProxyProtocol.swift

@@ -129,7 +129,7 @@ protocol RoomProxyProtocol {
     // MARK: - Element Call
 
     func canUserJoinCall(userID: String) async -> Result<Bool, RoomProxyError>
-    func elementCallWidgetDriver() -> ElementCallWidgetDriverProtocol
+    func elementCallWidgetDriver(deviceID: String) -> ElementCallWidgetDriverProtocol
 
     func sendCallNotificationIfNeeeded() async -> Result<Void, RoomProxyError>