Update the SDK fixing a few room list bugs. (#3054)

* Update the SDK.

* Handle API break for editing timeline items.

* Handle API break for Element Call

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",
+        "revision" : "dd9e0d89d65be16c3db1a14a121543e0af326536",
-        "version" : "1.0.24"
+        "version" : "1.0.25"
       }
     },
     {

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -10618,15 +10618,15 @@ class RoomProxyMock: RoomProxyProtocol {
     }
     //MARK: - elementCallWidgetDriver
 
-    var elementCallWidgetDriverUnderlyingCallsCount = 0
+    var elementCallWidgetDriverDeviceIDUnderlyingCallsCount = 0
-    var elementCallWidgetDriverCallsCount: Int {
+    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!
@@ -10634,27 +10634,29 @@ class RoomProxyMock: RoomProxyProtocol {
         }
         set {
             if Thread.isMainThread {
-                elementCallWidgetDriverUnderlyingCallsCount = newValue
+                elementCallWidgetDriverDeviceIDUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    elementCallWidgetDriverUnderlyingCallsCount = newValue
+                    elementCallWidgetDriverDeviceIDUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    var elementCallWidgetDriverCalled: Bool {
+    var elementCallWidgetDriverDeviceIDCalled: Bool {
-        return elementCallWidgetDriverCallsCount > 0
+        return elementCallWidgetDriverDeviceIDCallsCount > 0
     }
+    var elementCallWidgetDriverDeviceIDReceivedDeviceID: String?
+    var elementCallWidgetDriverDeviceIDReceivedInvocations: [String] = []
 
-    var elementCallWidgetDriverUnderlyingReturnValue: ElementCallWidgetDriverProtocol!
+    var elementCallWidgetDriverDeviceIDUnderlyingReturnValue: ElementCallWidgetDriverProtocol!
-    var elementCallWidgetDriverReturnValue: 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!
@@ -10662,22 +10664,26 @@ class RoomProxyMock: RoomProxyProtocol {
         }
         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 {
+    func elementCallWidgetDriver(deviceID: String) -> ElementCallWidgetDriverProtocol {
-        elementCallWidgetDriverCallsCount += 1
+        elementCallWidgetDriverDeviceIDCallsCount += 1
-        if let elementCallWidgetDriverClosure = elementCallWidgetDriverClosure {
+        elementCallWidgetDriverDeviceIDReceivedDeviceID = deviceID
-            return elementCallWidgetDriverClosure()
+        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 {
+    func elementCallWidgetDriver(deviceID: String) -> ElementCallWidgetDriverProtocol {
-        ElementCallWidgetDriver(room: room)
+        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>
     

ElementX/Sources/Services/Timeline/TimelineProxy.swift

@@ -158,12 +158,7 @@ final class TimelineProxy: TimelineProxyProtocol {
               intentionalMentions: IntentionalMentions) async -> Result<Void, TimelineProxyError> {
         MXLog.info("Editing timeline item: \(timelineItemID)")
         
-        let editMode: EditMode
+        guard let timelineItem = await timelineProvider.itemProxies.firstEventTimelineItemUsingID(timelineItemID) else {
-        if let eventID = timelineItemID.eventID {
-            editMode = .remote(eventID: eventID)
-        } else if let eventTimelineItem = await timelineProvider.itemProxies.firstEventTimelineItemUsingID(timelineItemID) {
-            editMode = .local(item: eventTimelineItem)
-        } else {
             MXLog.error("Unknown timeline item: \(timelineItemID)")
             return .failure(.failedEditing)
         }
@@ -173,13 +168,8 @@ final class TimelineProxy: TimelineProxyProtocol {
                                                     intentionalMentions: intentionalMentions.toRustMentions())
         
         do {
-            switch editMode {
+            guard try await timeline.edit(item: timelineItem, newContent: messageContent) == true else {
-            case let .local(item):
+                return .failure(.failedEditing)
-                guard try await timeline.edit(item: item, newContent: messageContent) == true else {
-                    return .failure(.failedEditing)
-                }
-            case let .remote(eventID):
-                try await timeline.editByEventId(eventId: eventID, newContent: messageContent)
             }
             
             MXLog.info("Finished editing timeline item: \(timelineItemID)")
@@ -625,11 +615,3 @@ extension Array where Element == TimelineItemProxy {
         return eventTimelineItemProxy?.item
     }
 }
-
-private enum EditMode {
-    /// edit for a message that is also found locally as a timeline item
-    case local(item: EventTimelineItem)
-    
-    /// edit for a message that was not found locally
-    case remote(eventID: String)
-}

project.yml

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