Fix a bug where the room state wouldn't indicate when a call was in progress.

ElementX.xcodeproj/project.pbxproj

@@ -7822,7 +7822,7 @@
 			repositoryURL = "https://github.com/element-hq/matrix-rust-components-swift";
 			requirement = {
 				kind = exactVersion;
-				version = 1.0.60;
+				version = 1.0.61;
 			};
 		};
 		701C7BEF8F70F7A83E852DCC /* XCRemoteSwiftPackageReference "GZIP" */ = {
@@ -7862,7 +7862,7 @@
 			repositoryURL = "https://github.com/matrix-org/matrix-analytics-events";
 			requirement = {
 				kind = upToNextMinorVersion;
-				minimumVersion = 0.25.0;
+				minimumVersion = 0.27.0;
 			};
 		};
 		C13F55E4518415CB4C278E73 /* XCRemoteSwiftPackageReference "DTCoreText" */ = {

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

@@ -6,8 +6,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/element-hq/compound-design-tokens",
       "state" : {
-        "revision" : "2af7bb571eb30cbfbd67cdda6617500507ef46aa",
-        "version" : "1.8.0"
+        "revision" : "976db67b849775799b4153e7894d61e90fc96888",
+        "version" : "1.9.0"
       }
     },
     {
@@ -131,8 +131,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/matrix-org/matrix-analytics-events",
       "state" : {
-        "revision" : "c9b40120a5f7b8ce1bab3f09f8417fdc9407f006",
-        "version" : "0.25.0"
+        "revision" : "9bd3c57e84f87d56b69862369f3b9da714d1d151",
+        "version" : "0.27.0"
       }
     },
     {
@@ -149,8 +149,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/element-hq/matrix-rust-components-swift",
       "state" : {
-        "revision" : "dc3a2199b0e87824ccf06d1207487d2e49c5e584",
-        "version" : "1.0.60"
+        "revision" : "2e6378514e79a648d436e8faeb8cd8106910cf0b",
+        "version" : "1.0.61"
       }
     },
     {

ElementX/Sources/FlowCoordinators/UserSessionFlowCoordinator.swift

@@ -59,6 +59,7 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
     /// For testing purposes.
     var statePublisher: AnyPublisher<UserSessionFlowCoordinatorStateMachine.State, Never> { stateMachine.statePublisher }
 
+    // swiftlint:disable:next function_body_length
     init(userSession: UserSessionProtocol,
          navigationRootCoordinator: NavigationRootCoordinator,
          appLockService: AppLockServiceProtocol,
@@ -158,9 +159,15 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
 
                 switch info.cause {
                 case .unknown:
-                    analytics.trackError(context: nil, domain: .E2EE, name: .OlmKeysNotSentError, timeToDecryptMillis: timeToDecryptMs)
-                case .membership:
-                    analytics.trackError(context: nil, domain: .E2EE, name: .HistoricalMessage, timeToDecryptMillis: timeToDecryptMs)
+                    analytics.trackError(context: nil, domain: .E2EE, name: .UnknownError, timeToDecryptMillis: timeToDecryptMs)
+                case .unknownDevice:
+                    analytics.trackError(context: nil, domain: .E2EE, name: .ExpectedSentByInsecureDevice, timeToDecryptMillis: timeToDecryptMs)
+                case .unsignedDevice:
+                    analytics.trackError(context: nil, domain: .E2EE, name: .ExpectedSentByInsecureDevice, timeToDecryptMillis: timeToDecryptMs)
+                case .verificationViolation:
+                    analytics.trackError(context: nil, domain: .E2EE, name: .ExpectedVerificationViolation, timeToDecryptMillis: timeToDecryptMs)
+                case .sentBeforeWeJoined:
+                    analytics.trackError(context: nil, domain: .E2EE, name: .ExpectedDueToMembership, timeToDecryptMillis: timeToDecryptMs)
                 }
             }
             .store(in: &cancellables)

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -2837,72 +2837,72 @@ class ClientProxyMock: ClientProxyProtocol {
     }
     //MARK: - knockRoom
 
-    var knockRoomMessageUnderlyingCallsCount = 0
-    var knockRoomMessageCallsCount: Int {
+    var knockRoomViaMessageUnderlyingCallsCount = 0
+    var knockRoomViaMessageCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return knockRoomMessageUnderlyingCallsCount
+                return knockRoomViaMessageUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = knockRoomMessageUnderlyingCallsCount
+                    returnValue = knockRoomViaMessageUnderlyingCallsCount
                 }
 
                 return returnValue!
             }
         }
         set {
             if Thread.isMainThread {
-                knockRoomMessageUnderlyingCallsCount = newValue
+                knockRoomViaMessageUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    knockRoomMessageUnderlyingCallsCount = newValue
+                    knockRoomViaMessageUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    var knockRoomMessageCalled: Bool {
-        return knockRoomMessageCallsCount > 0
+    var knockRoomViaMessageCalled: Bool {
+        return knockRoomViaMessageCallsCount > 0
     }
-    var knockRoomMessageReceivedArguments: (roomID: String, message: String?)?
-    var knockRoomMessageReceivedInvocations: [(roomID: String, message: String?)] = []
+    var knockRoomViaMessageReceivedArguments: (roomID: String, via: [String], message: String?)?
+    var knockRoomViaMessageReceivedInvocations: [(roomID: String, via: [String], message: String?)] = []
 
-    var knockRoomMessageUnderlyingReturnValue: Result<Void, ClientProxyError>!
-    var knockRoomMessageReturnValue: Result<Void, ClientProxyError>! {
+    var knockRoomViaMessageUnderlyingReturnValue: Result<Void, ClientProxyError>!
+    var knockRoomViaMessageReturnValue: Result<Void, ClientProxyError>! {
         get {
             if Thread.isMainThread {
-                return knockRoomMessageUnderlyingReturnValue
+                return knockRoomViaMessageUnderlyingReturnValue
             } else {
                 var returnValue: Result<Void, ClientProxyError>? = nil
                 DispatchQueue.main.sync {
-                    returnValue = knockRoomMessageUnderlyingReturnValue
+                    returnValue = knockRoomViaMessageUnderlyingReturnValue
                 }
 
                 return returnValue!
             }
         }
         set {
             if Thread.isMainThread {
-                knockRoomMessageUnderlyingReturnValue = newValue
+                knockRoomViaMessageUnderlyingReturnValue = newValue
             } else {
                 DispatchQueue.main.sync {
-                    knockRoomMessageUnderlyingReturnValue = newValue
+                    knockRoomViaMessageUnderlyingReturnValue = newValue
                 }
             }
         }
     }
-    var knockRoomMessageClosure: ((String, String?) async -> Result<Void, ClientProxyError>)?
+    var knockRoomViaMessageClosure: ((String, [String], String?) async -> Result<Void, ClientProxyError>)?
 
-    func knockRoom(_ roomID: String, message: String?) async -> Result<Void, ClientProxyError> {
-        knockRoomMessageCallsCount += 1
-        knockRoomMessageReceivedArguments = (roomID: roomID, message: message)
+    func knockRoom(_ roomID: String, via: [String], message: String?) async -> Result<Void, ClientProxyError> {
+        knockRoomViaMessageCallsCount += 1
+        knockRoomViaMessageReceivedArguments = (roomID: roomID, via: via, message: message)
         DispatchQueue.main.async {
-            self.knockRoomMessageReceivedInvocations.append((roomID: roomID, message: message))
+            self.knockRoomViaMessageReceivedInvocations.append((roomID: roomID, via: via, message: message))
         }
-        if let knockRoomMessageClosure = knockRoomMessageClosure {
-            return await knockRoomMessageClosure(roomID, message)
+        if let knockRoomViaMessageClosure = knockRoomViaMessageClosure {
+            return await knockRoomViaMessageClosure(roomID, via, message)
         } else {
-            return knockRoomMessageReturnValue
+            return knockRoomViaMessageReturnValue
         }
     }
     //MARK: - knockRoomAlias

ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift

@@ -2208,76 +2208,76 @@ open class ClientSDKMock: MatrixRustSDK.Client {
 
     //MARK: - knock
 
-    open var knockRoomIdOrAliasThrowableError: Error?
-    var knockRoomIdOrAliasUnderlyingCallsCount = 0
-    open var knockRoomIdOrAliasCallsCount: Int {
+    open var knockRoomIdOrAliasReasonServerNamesThrowableError: Error?
+    var knockRoomIdOrAliasReasonServerNamesUnderlyingCallsCount = 0
+    open var knockRoomIdOrAliasReasonServerNamesCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return knockRoomIdOrAliasUnderlyingCallsCount
+                return knockRoomIdOrAliasReasonServerNamesUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = knockRoomIdOrAliasUnderlyingCallsCount
+                    returnValue = knockRoomIdOrAliasReasonServerNamesUnderlyingCallsCount
                 }
 
                 return returnValue!
             }
         }
         set {
             if Thread.isMainThread {
-                knockRoomIdOrAliasUnderlyingCallsCount = newValue
+                knockRoomIdOrAliasReasonServerNamesUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    knockRoomIdOrAliasUnderlyingCallsCount = newValue
+                    knockRoomIdOrAliasReasonServerNamesUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    open var knockRoomIdOrAliasCalled: Bool {
-        return knockRoomIdOrAliasCallsCount > 0
+    open var knockRoomIdOrAliasReasonServerNamesCalled: Bool {
+        return knockRoomIdOrAliasReasonServerNamesCallsCount > 0
     }
-    open var knockRoomIdOrAliasReceivedRoomIdOrAlias: String?
-    open var knockRoomIdOrAliasReceivedInvocations: [String] = []
+    open var knockRoomIdOrAliasReasonServerNamesReceivedArguments: (roomIdOrAlias: String, reason: String?, serverNames: [String])?
+    open var knockRoomIdOrAliasReasonServerNamesReceivedInvocations: [(roomIdOrAlias: String, reason: String?, serverNames: [String])] = []
 
-    var knockRoomIdOrAliasUnderlyingReturnValue: Room!
-    open var knockRoomIdOrAliasReturnValue: Room! {
+    var knockRoomIdOrAliasReasonServerNamesUnderlyingReturnValue: Room!
+    open var knockRoomIdOrAliasReasonServerNamesReturnValue: Room! {
         get {
             if Thread.isMainThread {
-                return knockRoomIdOrAliasUnderlyingReturnValue
+                return knockRoomIdOrAliasReasonServerNamesUnderlyingReturnValue
             } else {
                 var returnValue: Room? = nil
                 DispatchQueue.main.sync {
-                    returnValue = knockRoomIdOrAliasUnderlyingReturnValue
+                    returnValue = knockRoomIdOrAliasReasonServerNamesUnderlyingReturnValue
                 }
 
                 return returnValue!
             }
         }
         set {
             if Thread.isMainThread {
-                knockRoomIdOrAliasUnderlyingReturnValue = newValue
+                knockRoomIdOrAliasReasonServerNamesUnderlyingReturnValue = newValue
             } else {
                 DispatchQueue.main.sync {
-                    knockRoomIdOrAliasUnderlyingReturnValue = newValue
+                    knockRoomIdOrAliasReasonServerNamesUnderlyingReturnValue = newValue
                 }
             }
         }
     }
-    open var knockRoomIdOrAliasClosure: ((String) async throws -> Room)?
+    open var knockRoomIdOrAliasReasonServerNamesClosure: ((String, String?, [String]) async throws -> Room)?
 
-    open override func knock(roomIdOrAlias: String) async throws -> Room {
-        if let error = knockRoomIdOrAliasThrowableError {
+    open override func knock(roomIdOrAlias: String, reason: String?, serverNames: [String]) async throws -> Room {
+        if let error = knockRoomIdOrAliasReasonServerNamesThrowableError {
             throw error
         }
-        knockRoomIdOrAliasCallsCount += 1
-        knockRoomIdOrAliasReceivedRoomIdOrAlias = roomIdOrAlias
+        knockRoomIdOrAliasReasonServerNamesCallsCount += 1
+        knockRoomIdOrAliasReasonServerNamesReceivedArguments = (roomIdOrAlias: roomIdOrAlias, reason: reason, serverNames: serverNames)
         DispatchQueue.main.async {
-            self.knockRoomIdOrAliasReceivedInvocations.append(roomIdOrAlias)
+            self.knockRoomIdOrAliasReasonServerNamesReceivedInvocations.append((roomIdOrAlias: roomIdOrAlias, reason: reason, serverNames: serverNames))
         }
-        if let knockRoomIdOrAliasClosure = knockRoomIdOrAliasClosure {
-            return try await knockRoomIdOrAliasClosure(roomIdOrAlias)
+        if let knockRoomIdOrAliasReasonServerNamesClosure = knockRoomIdOrAliasReasonServerNamesClosure {
+            return try await knockRoomIdOrAliasReasonServerNamesClosure(roomIdOrAlias, reason, serverNames)
         } else {
-            return knockRoomIdOrAliasReturnValue
+            return knockRoomIdOrAliasReasonServerNamesReturnValue
         }
     }
 

ElementX/Sources/Screens/JoinRoomScreen/JoinRoomScreenViewModel.swift

@@ -195,6 +195,7 @@ class JoinRoomScreenViewModel: JoinRoomScreenViewModelType, JoinRoomScreenViewMo
             }
         } else {
             switch await clientProxy.knockRoom(roomID,
+                                               via: via,
                                                message: state.bindings.knockMessage.isBlank ? nil : state.bindings.knockMessage) {
             case .success:
                 state.mode = .knocked

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -415,9 +415,9 @@ class ClientProxy: ClientProxyProtocol {
         }
     }
 
-    func knockRoom(_ roomID: String, message: String?) async -> Result<Void, ClientProxyError> {
+    func knockRoom(_ roomID: String, via: [String], message: String?) async -> Result<Void, ClientProxyError> {
         do {
-            let _ = try await client.knock(roomIdOrAlias: roomID)
+            let _ = try await client.knock(roomIdOrAlias: roomID, reason: nil, serverNames: via)
             await waitForRoomToSync(roomID: roomID, timeout: .seconds(30))
             return .success(())
         } catch {
@@ -428,7 +428,7 @@ class ClientProxy: ClientProxyProtocol {
 
     func knockRoomAlias(_ roomAlias: String, message: String?) async -> Result<Void, ClientProxyError> {
         do {
-            let room = try await client.knock(roomIdOrAlias: roomAlias)
+            let room = try await client.knock(roomIdOrAlias: roomAlias, reason: nil, serverNames: [])
             await waitForRoomToSync(roomID: room.id(), timeout: .seconds(30))
             return .success(())
         } catch {

ElementX/Sources/Services/Client/ClientProxyProtocol.swift

@@ -136,7 +136,7 @@ protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
 
     func joinRoomAlias(_ roomAlias: String) async -> Result<Void, ClientProxyError>
 
-    func knockRoom(_ roomID: String, message: String?) async -> Result<Void, ClientProxyError>
+    func knockRoom(_ roomID: String, via: [String], message: String?) async -> Result<Void, ClientProxyError>
 
     func knockRoomAlias(_ roomAlias: String, message: String?) async -> Result<Void, ClientProxyError>
 

ElementX/Sources/Services/Room/RoomSummary/RoomEventStringBuilder.swift

@@ -26,7 +26,7 @@ struct RoomEventStringBuilder {
         switch eventItemProxy.content {
         case .unableToDecrypt(let encryptedMessage):
             let errorMessage = switch encryptedMessage {
-            case .megolmV1AesSha2(_, .membership): L10n.commonUnableToDecryptNoAccess
+            case .megolmV1AesSha2(_, .sentBeforeWeJoined): L10n.commonUnableToDecryptNoAccess
             default: L10n.commonWaitingForDecryptionKey
             }
             return prefix(errorMessage, with: displayName)

ElementX/Sources/Services/Timeline/TimelineItemProxy.swift

@@ -83,18 +83,19 @@ class EventTimelineItemProxy {
         }
 
         switch localSendState {
-        case .sendingFailed(_, let isRecoverable):
-            return isRecoverable ? .sending : .sendingFailed(.unknown)
+        case .sendingFailed(let error, let isRecoverable):
+            switch error {
+            case .identityViolations(let users):
+                return .sendingFailed(.verifiedUser(.changedIdentity(users: users)))
+            case .insecureDevices(let userDeviceMap):
+                return .sendingFailed(.verifiedUser(.hasUnsignedDevice(devices: userDeviceMap)))
+            default:
+                return .sendingFailed(.unknown)
+            }
         case .notSentYet:
             return .sending
         case .sent:
             return .sent
-        case .verifiedUserHasUnsignedDevice(devices: let devices):
-            return .sendingFailed(.verifiedUser(.hasUnsignedDevice(devices: devices)))
-        case .verifiedUserChangedIdentity(users: let users):
-            return .sendingFailed(.verifiedUser(.changedIdentity(users: users)))
-        case .crossSigningNotSetup, .sendingFromUnverifiedDevice:
-            return .sendingFailed(.unknown)
         }
     }()
 

ElementX/Sources/Services/Timeline/TimelineItems/RoomTimelineItemFactory.swift

@@ -154,10 +154,10 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
         switch encryptedMessage {
         case .megolmV1AesSha2(let sessionID, let cause):
             switch cause {
-            case .unknown:
+            case .unknown, .verificationViolation, .unsignedDevice, .unknownDevice:
                 encryptionType = .megolmV1AesSha2(sessionID: sessionID, cause: .unknown)
                 errorLabel = L10n.commonWaitingForDecryptionKey
-            case .membership:
+            case .sentBeforeWeJoined:
                 encryptionType = .megolmV1AesSha2(sessionID: sessionID, cause: .membership)
                 errorLabel = L10n.commonUnableToDecryptNoAccess
             }

project.yml

@@ -60,15 +60,15 @@ packages:
   # Element/Matrix dependencies
   MatrixRustSDK:
     url: https://github.com/element-hq/matrix-rust-components-swift
-    exactVersion: 1.0.60
+    exactVersion: 1.0.61
     # path: ../matrix-rust-sdk
   Compound:
     url: https://github.com/element-hq/compound-ios
     revision: e3f9665621872f60d3652579c3f0dc7bf806e72c
     # path: ../compound-ios
   AnalyticsEvents:
     url: https://github.com/matrix-org/matrix-analytics-events
-    minorVersion: 0.25.0
+    minorVersion: 0.27.0
     # path: ../matrix-analytics-events
   Emojibase:
     url: https://github.com/matrix-org/emojibase-bindings