Show recovery instead of verification if this is the last session and recovery is set up

* Show recovery instead of verification if this is the last session and recovery is set up

* Rename `recoveryKeyState` to `recoveryState`

* Remove duplicates on session security state changes.

* Fix missing "Save recovery key" button

* Fix unit tests

* Rename `isLastDevice` to `isOnlyDeviceLeft`

* Address PR comments

ElementX/Sources/FlowCoordinators/UserSessionFlowCoordinator.swift

@@ -361,12 +361,12 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
     private func runLogoutFlow() async {
         let secureBackupController = userSession.clientProxy.secureBackupController
         
-        guard case let .success(isLastSession) = await secureBackupController.isLastSession() else {
+        guard case let .success(isLastDevice) = await userSession.clientProxy.isOnlyDeviceLeft() else {
             ServiceLocator.shared.userIndicatorController.alertInfo = .init(id: .init())
             return
         }
         
-        guard isLastSession else {
+        guard isLastDevice else {
             ServiceLocator.shared.userIndicatorController.alertInfo = .init(id: .init(),
                                                                             title: L10n.screenSignoutConfirmationDialogTitle,
                                                                             message: L10n.screenSignoutConfirmationDialogContent,
@@ -376,7 +376,7 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
             return
         }
         
-        guard secureBackupController.recoveryKeyState.value == .enabled else {
+        guard secureBackupController.recoveryState.value == .enabled else {
             ServiceLocator.shared.userIndicatorController.alertInfo = .init(id: .init(),
                                                                             title: L10n.screenSignoutRecoveryDisabledTitle,
                                                                             message: L10n.screenSignoutRecoveryDisabledSubtitle,

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -2363,11 +2363,11 @@ class RoomTimelineProviderMock: RoomTimelineProviderProtocol {
 
 }
 class SecureBackupControllerMock: SecureBackupControllerProtocol {
-    var recoveryKeyState: CurrentValuePublisher<SecureBackupRecoveryKeyState, Never> {
+    var recoveryState: CurrentValuePublisher<SecureBackupRecoveryState, Never> {
-        get { return underlyingRecoveryKeyState }
+        get { return underlyingRecoveryState }
-        set(value) { underlyingRecoveryKeyState = value }
+        set(value) { underlyingRecoveryState = value }
     }
-    var underlyingRecoveryKeyState: CurrentValuePublisher<SecureBackupRecoveryKeyState, Never>!
+    var underlyingRecoveryState: CurrentValuePublisher<SecureBackupRecoveryState, Never>!
     var keyBackupState: CurrentValuePublisher<SecureBackupKeyBackupState, Never> {
         get { return underlyingKeyBackupState }
         set(value) { underlyingKeyBackupState = value }
@@ -2446,23 +2446,6 @@ class SecureBackupControllerMock: SecureBackupControllerProtocol {
             return confirmRecoveryKeyReturnValue
         }
     }
-    //MARK: - isLastSession
-
-    var isLastSessionCallsCount = 0
-    var isLastSessionCalled: Bool {
-        return isLastSessionCallsCount > 0
-    }
-    var isLastSessionReturnValue: Result<Bool, SecureBackupControllerError>!
-    var isLastSessionClosure: (() async -> Result<Bool, SecureBackupControllerError>)?
-
-    func isLastSession() async -> Result<Bool, SecureBackupControllerError> {
-        isLastSessionCallsCount += 1
-        if let isLastSessionClosure = isLastSessionClosure {
-            return await isLastSessionClosure()
-        } else {
-            return isLastSessionReturnValue
-        }
-    }
     //MARK: - waitForKeyBackupUpload
 
     var waitForKeyBackupUploadCallsCount = 0

ElementX/Sources/Screens/HomeScreen/HomeScreenModels.swift

@@ -75,32 +75,20 @@ enum HomeScreenRoomListMode: CustomStringConvertible {
     }
 }
 
+enum SecurityBannerMode {
+    case none
+    case dismissed
+    case sessionVerification
+    case recoveryKeyConfirmation
+}
+
 struct HomeScreenViewState: BindableState {
     let userID: String
     var userDisplayName: String?
     var userAvatarURL: URL?
     
-    var isSessionVerified: Bool?
+    var securityBannerMode = SecurityBannerMode.none
-    var hasSessionVerificationBannerBeenDismissed = false
+    var requiresExtraAccountSetup = false
-    var showSessionVerificationBanner: Bool {
-        guard let isSessionVerified else {
-            return false
-        }
-        
-        return !isSessionVerified && !hasSessionVerificationBannerBeenDismissed
-    }
-    
-    var requiresSecureBackupSetup = false
-
-    var needsRecoveryKeyConfirmation = false
-    var hasRecoveryKeyConfirmationBannerBeenDismissed = false
-    var showRecoveryKeyConfirmationBanner: Bool {
-        guard let isSessionVerified else {
-            return false
-        }
-        
-        return isSessionVerified && needsRecoveryKeyConfirmation && !hasRecoveryKeyConfirmationBannerBeenDismissed
-    }
         
     var rooms: [HomeScreenRoom] = []
     var roomListMode: HomeScreenRoomListMode = .skeletons

ElementX/Sources/Screens/HomeScreen/HomeScreenViewModel.swift

@@ -61,20 +61,35 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
             .weakAssign(to: \.state.userDisplayName, on: self)
             .store(in: &cancellables)
         
-        userSession.sessionVerificationState
+        userSession.sessionSecurityStatePublisher
             .receive(on: DispatchQueue.main)
-            .weakAssign(to: \.state.isSessionVerified, on: self)
+            .sink { [weak self] securityState in
-            .store(in: &cancellables)
-        
-        userSession.clientProxy.secureBackupController.recoveryKeyState
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] recoveryKeyState in
                 guard let self else { return }
                 
-                let requiresSecureBackupSetup = recoveryKeyState == .disabled || recoveryKeyState == .incomplete
+                switch (securityState.verificationState, securityState.recoveryState) {
-                state.requiresSecureBackupSetup = requiresSecureBackupSetup
+                case (.unverified, _):
+                    state.requiresExtraAccountSetup = true
+                    if state.securityBannerMode != .dismissed {
+                        state.securityBannerMode = .sessionVerification
+                    }
+                case (.unverifiedLastSession, .incomplete):
+                    state.requiresExtraAccountSetup = true
+                    if state.securityBannerMode != .dismissed {
+                        state.securityBannerMode = .recoveryKeyConfirmation
+                    }
+                case (.verified, .disabled):
+                    state.requiresExtraAccountSetup = true
+                    state.securityBannerMode = .none
+                case (.verified, .incomplete):
+                    state.requiresExtraAccountSetup = true
                     
-                state.needsRecoveryKeyConfirmation = recoveryKeyState == .incomplete
+                    if state.securityBannerMode != .dismissed {
+                        state.securityBannerMode = .recoveryKeyConfirmation
+                    }
+                default:
+                    state.securityBannerMode = .none
+                    state.requiresExtraAccountSetup = false
+                }
             }
             .store(in: &cancellables)
         
@@ -149,9 +164,9 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
         case .confirmRecoveryKey:
             actionsSubject.send(.presentSecureBackupSettings)
         case .skipSessionVerification:
-            state.hasSessionVerificationBannerBeenDismissed = true
+            state.securityBannerMode = .dismissed
         case .skipRecoveryKeyConfirmation:
-            state.hasRecoveryKeyConfirmationBannerBeenDismissed = true
+            state.securityBannerMode = .dismissed
         case .updateVisibleItemRange(let range, let isScrolling):
             visibleItemRangePublisher.send((range, isScrolling))
         case .startChat:

ElementX/Sources/Screens/HomeScreen/View/HomeScreenContent.swift

@@ -116,10 +116,13 @@ struct HomeScreenContent: View {
                 filters
             }
             
-            if context.viewState.showSessionVerificationBanner {
+            switch context.viewState.securityBannerMode {
+            case .sessionVerification:
                 HomeScreenSessionVerificationBanner(context: context)
-            } else if context.viewState.showRecoveryKeyConfirmationBanner {
+            case .recoveryKeyConfirmation:
                 HomeScreenRecoveryKeyConfirmationBanner(context: context)
+            default:
+                EmptyView()
             }
             
             if context.viewState.hasPendingInvitations, !context.isSearchFieldFocused {

ElementX/Sources/Screens/HomeScreen/View/HomeScreenUserMenuButton.swift

@@ -29,7 +29,7 @@ struct HomeScreenUserMenuButton: View {
                     Label {
                         Text(L10n.commonSettings)
                     } icon: {
-                        if context.viewState.requiresSecureBackupSetup, context.viewState.isSessionVerified == true {
+                        if context.viewState.requiresExtraAccountSetup {
                             CompoundIcon(asset: Asset.Images.settingsIconWithBadge)
                         } else {
                             CompoundIcon(\.settings)
@@ -50,7 +50,7 @@ struct HomeScreenUserMenuButton: View {
                                 avatarSize: .user(on: .home),
                                 imageProvider: context.imageProvider)
                 .accessibilityIdentifier(A11yIdentifiers.homeScreen.userAvatar)
-                .overlayBadge(10, isBadged: context.viewState.requiresSecureBackupSetup && context.viewState.isSessionVerified == true)
+                .overlayBadge(10, isBadged: context.viewState.requiresExtraAccountSetup)
                 .compositingGroup()
         }
         .accessibilityLabel(L10n.a11yUserMenu)

ElementX/Sources/Screens/SecureBackup/SecureBackupRecoveryKeyScreen/SecureBackupRecoveryKeyScreenViewModel.swift

@@ -32,9 +32,9 @@ class SecureBackupRecoveryKeyScreenViewModel: SecureBackupRecoveryKeyScreenViewM
         self.secureBackupController = secureBackupController
         self.userIndicatorController = userIndicatorController
         
-        super.init(initialViewState: .init(mode: secureBackupController.recoveryKeyState.value.viewMode, bindings: .init()))
+        super.init(initialViewState: .init(mode: secureBackupController.recoveryState.value.viewMode, bindings: .init()))
         
-        secureBackupController.recoveryKeyState
+        secureBackupController.recoveryState
             .receive(on: DispatchQueue.main)
             .sink(receiveValue: { [weak userIndicatorController] state in
                 let loadingIndicatorIdentifier = "SecureBackupRecoveryKeyScreenLoading"
@@ -100,7 +100,7 @@ class SecureBackupRecoveryKeyScreenViewModel: SecureBackupRecoveryKeyScreenViewM
     }
 }
 
-extension SecureBackupRecoveryKeyState {
+extension SecureBackupRecoveryState {
     var viewMode: SecureBackupRecoveryKeyScreenViewMode {
         switch self {
         case .disabled:

ElementX/Sources/Screens/SecureBackup/SecureBackupRecoveryKeyScreen/View/SecureBackupRecoveryKeyScreen.swift

@@ -65,6 +65,20 @@ struct SecureBackupRecoveryKeyScreen: View {
     private var footer: some View {
         switch context.viewState.mode {
         case .setupRecovery, .changeRecovery:
+            recoveryCreatedActionButtons
+        case .fixRecovery:
+            Button {
+                context.send(viewAction: .confirmKey)
+            } label: {
+                Text(L10n.actionConfirm)
+            }
+            .buttonStyle(.compound(.primary))
+            .disabled(context.confirmationRecoveryKey.isEmpty)
+        }
+    }
+    
+    private var recoveryCreatedActionButtons: some View {
+        VStack(spacing: 8.0) {
             if let recoveryKey = context.viewState.recoveryKey {
                 ShareLink(item: recoveryKey) {
                     Label(L10n.screenRecoveryKeySaveAction, icon: \.download)
@@ -82,14 +96,6 @@ struct SecureBackupRecoveryKeyScreen: View {
             }
             .buttonStyle(.compound(.primary))
             .disabled(context.viewState.recoveryKey == nil || context.viewState.doneButtonEnabled == false)
-        case .fixRecovery:
-            Button {
-                context.send(viewAction: .confirmKey)
-            } label: {
-                Text(L10n.actionConfirm)
-            }
-            .buttonStyle(.compound(.primary))
-            .disabled(context.confirmationRecoveryKey.isEmpty)
         }
     }
     
@@ -204,9 +210,9 @@ struct SecureBackupRecoveryKeyScreen: View {
 // MARK: - Previews
 
 struct SecureBackupRecoveryKeyScreen_Previews: PreviewProvider, TestablePreview {
-    static let setupViewModel = viewModel(recoveryKeyState: .enabled)
+    static let setupViewModel = viewModel(recoveryState: .enabled)
-    static let notSetUpViewModel = viewModel(recoveryKeyState: .disabled)
+    static let notSetUpViewModel = viewModel(recoveryState: .disabled)
-    static let incompleteViewModel = viewModel(recoveryKeyState: .incomplete)
+    static let incompleteViewModel = viewModel(recoveryState: .incomplete)
     
     static var previews: some View {
         NavigationStack {
@@ -225,9 +231,9 @@ struct SecureBackupRecoveryKeyScreen_Previews: PreviewProvider, TestablePreview
         .previewDisplayName("Incomplete")
     }
     
-    static func viewModel(recoveryKeyState: SecureBackupRecoveryKeyState) -> SecureBackupRecoveryKeyScreenViewModelType {
+    static func viewModel(recoveryState: SecureBackupRecoveryState) -> SecureBackupRecoveryKeyScreenViewModelType {
         let backupController = SecureBackupControllerMock()
-        backupController.underlyingRecoveryKeyState = CurrentValueSubject<SecureBackupRecoveryKeyState, Never>(recoveryKeyState).asCurrentValuePublisher()
+        backupController.underlyingRecoveryState = CurrentValueSubject<SecureBackupRecoveryState, Never>(recoveryState).asCurrentValuePublisher()
         
         return SecureBackupRecoveryKeyScreenViewModel(secureBackupController: backupController, userIndicatorController: UserIndicatorControllerMock())
     }

ElementX/Sources/Screens/SecureBackup/SecureBackupScreen/SecureBackupScreenModels.swift

@@ -23,7 +23,7 @@ enum SecureBackupScreenViewModelAction {
 
 struct SecureBackupScreenViewState: BindableState {
     let chatBackupDetailsURL: URL
-    var recoveryKeyState = SecureBackupRecoveryKeyState.unknown
+    var recoveryState = SecureBackupRecoveryState.unknown
     var keyBackupState = SecureBackupKeyBackupState.unknown
     var bindings = SecureBackupScreenViewStateBindings()
 }

ElementX/Sources/Screens/SecureBackup/SecureBackupScreen/SecureBackupScreenViewModel.swift

@@ -36,9 +36,9 @@ class SecureBackupScreenViewModel: SecureBackupScreenViewModelType, SecureBackup
         
         super.init(initialViewState: .init(chatBackupDetailsURL: chatBackupDetailsURL))
         
-        secureBackupController.recoveryKeyState
+        secureBackupController.recoveryState
             .receive(on: DispatchQueue.main)
-            .weakAssign(to: \.state.recoveryKeyState, on: self)
+            .weakAssign(to: \.state.recoveryState, on: self)
             .store(in: &cancellables)
         
         secureBackupController.keyBackupState

ElementX/Sources/Screens/SecureBackup/SecureBackupScreen/View/SecureBackupScreen.swift

@@ -25,7 +25,7 @@ struct SecureBackupScreen: View {
         Form {
             // Show recovery options for confirming the recovery key and
             // getting access to secrets and implicitly the key backup
-            if context.viewState.recoveryKeyState == .incomplete {
+            if context.viewState.recoveryState == .incomplete {
                 recoveryKeySection
             } else {
                 keyBackupSection
@@ -93,7 +93,7 @@ struct SecureBackupScreen: View {
     @ViewBuilder
     private var recoveryKeySection: some View {
         Section {
-            switch context.viewState.recoveryKeyState {
+            switch context.viewState.recoveryState {
             case .enabled:
                 ListRow(label: .plain(title: L10n.screenChatBackupRecoveryActionChange),
                         kind: .navigationLink { context.send(viewAction: .recoveryKey) })
@@ -116,7 +116,7 @@ struct SecureBackupScreen: View {
     
     @ViewBuilder
     private var recoveryKeySectionFooter: some View {
-        switch context.viewState.recoveryKeyState {
+        switch context.viewState.recoveryState {
         case .disabled:
             Text(L10n.screenChatBackupRecoveryActionSetupDescription(InfoPlistReader.main.bundleDisplayName))
         case .incomplete:
@@ -130,10 +130,10 @@ struct SecureBackupScreen: View {
 // MARK: - Previews
 
 struct SecureBackupScreen_Previews: PreviewProvider, TestablePreview {
-    static let bothSetupViewModel = viewModel(keyBackupState: .enabled, recoveryKeyState: .enabled)
+    static let bothSetupViewModel = viewModel(keyBackupState: .enabled, recoveryState: .enabled)
-    static let onlyKeyBackupSetUpViewModel = viewModel(keyBackupState: .enabled, recoveryKeyState: .disabled)
+    static let onlyKeyBackupSetUpViewModel = viewModel(keyBackupState: .enabled, recoveryState: .disabled)
-    static let keyBackupDisabledViewModel = viewModel(keyBackupState: .unknown, recoveryKeyState: .disabled)
+    static let keyBackupDisabledViewModel = viewModel(keyBackupState: .unknown, recoveryState: .disabled)
-    static let recoveryIncompleteViewModel = viewModel(keyBackupState: .enabled, recoveryKeyState: .incomplete)
+    static let recoveryIncompleteViewModel = viewModel(keyBackupState: .enabled, recoveryState: .incomplete)
     
     static var previews: some View {
         Group {
@@ -161,10 +161,10 @@ struct SecureBackupScreen_Previews: PreviewProvider, TestablePreview {
     }
     
     static func viewModel(keyBackupState: SecureBackupKeyBackupState,
-                          recoveryKeyState: SecureBackupRecoveryKeyState) -> SecureBackupScreenViewModelType {
+                          recoveryState: SecureBackupRecoveryState) -> SecureBackupScreenViewModelType {
         let backupController = SecureBackupControllerMock()
         backupController.underlyingKeyBackupState = CurrentValueSubject<SecureBackupKeyBackupState, Never>(keyBackupState).asCurrentValuePublisher()
-        backupController.underlyingRecoveryKeyState = CurrentValueSubject<SecureBackupRecoveryKeyState, Never>(recoveryKeyState).asCurrentValuePublisher()
+        backupController.underlyingRecoveryState = CurrentValueSubject<SecureBackupRecoveryState, Never>(recoveryState).asCurrentValuePublisher()
         
         return SecureBackupScreenViewModel(secureBackupController: backupController,
                                            userIndicatorController: UserIndicatorControllerMock(),

ElementX/Sources/Screens/Settings/SettingsScreen/SettingsScreenModels.swift

@@ -34,6 +34,12 @@ enum SettingsScreenViewModelAction {
     case logout
 }
 
+enum SettingsScreenSecuritySectionMode {
+    case none
+    case sessionVerification
+    case secureBackup
+}
+
 struct SettingsScreenViewState: BindableState {
     var deviceID: String?
     var userID: String
@@ -41,9 +47,10 @@ struct SettingsScreenViewState: BindableState {
     var accountSessionsListURL: URL?
     var userAvatarURL: URL?
     var userDisplayName: String?
-    var isSessionVerified: Bool?
-    var showSecureBackupBadge = false
     var showDeveloperOptions: Bool
+    
+    var securitySectionMode = SettingsScreenSecuritySectionMode.none
+    var showSecuritySectionBadge = false
 }
 
 enum SettingsScreenViewAction {

ElementX/Sources/Screens/Settings/SettingsScreen/SettingsScreenViewModel.swift

@@ -44,17 +44,31 @@ class SettingsScreenViewModel: SettingsScreenViewModelType, SettingsScreenViewMo
             .weakAssign(to: \.state.userDisplayName, on: self)
             .store(in: &cancellables)
         
-        userSession.sessionVerificationState
+        userSession.sessionSecurityStatePublisher
             .receive(on: DispatchQueue.main)
-            .weakAssign(to: \.state.isSessionVerified, on: self)
+            .sink { [weak self] securityState in
-            .store(in: &cancellables)
-        
-        userSession.clientProxy.secureBackupController.recoveryKeyState
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] state in
                 guard let self else { return }
                 
-                self.state.showSecureBackupBadge = (state == .incomplete || state == .disabled)
+                switch (securityState.verificationState, securityState.recoveryState) {
+                case (.unverified, _):
+                    state.showSecuritySectionBadge = true
+                    state.securitySectionMode = .sessionVerification
+                case (.unverifiedLastSession, .incomplete):
+                    state.showSecuritySectionBadge = true
+                    state.securitySectionMode = .secureBackup
+                case (.verified, .disabled):
+                    state.showSecuritySectionBadge = true
+                    state.securitySectionMode = .secureBackup
+                case (.verified, .incomplete):
+                    state.showSecuritySectionBadge = true
+                    state.securitySectionMode = .secureBackup
+                case (.unknown, _):
+                    state.showSecuritySectionBadge = false
+                    state.securitySectionMode = .none
+                default:
+                    state.showSecuritySectionBadge = false
+                    state.securitySectionMode = .secureBackup
+                }
             }
             .store(in: &cancellables)
         

ElementX/Sources/Screens/Settings/SettingsScreen/View/SettingsScreen.swift

@@ -80,18 +80,20 @@ struct SettingsScreen: View {
     @ViewBuilder
     private var accountSecuritySection: some View {
         Section {
-            if let isSessionVerified = context.viewState.isSessionVerified {
+            switch context.viewState.securitySectionMode {
-                if !isSessionVerified {
+            case .sessionVerification:
-                    ListRow(label: .default(title: L10n.actionCompleteVerification,
+                ListRow(label: .default(title: L10n.actionCompleteVerification,
-                                            icon: \.checkCircle),
+                                        icon: \.checkCircle),
-                            kind: .button { context.send(viewAction: .sessionVerification) })
+                        details: context.viewState.showSecuritySectionBadge ? .icon(securitySectionBadge) : nil,
-                } else {
+                        kind: .button { context.send(viewAction: .sessionVerification) })
-                    ListRow(label: .default(title: L10n.commonChatBackup,
+            case .secureBackup:
-                                            icon: \.key),
+                ListRow(label: .default(title: L10n.commonChatBackup,
-                            details: context.viewState.showSecureBackupBadge ? .icon(secureBackupBadge) : nil,
+                                        icon: \.key),
-                            kind: .navigationLink { context.send(viewAction: .secureBackup) })
+                        details: context.viewState.showSecuritySectionBadge ? .icon(securitySectionBadge) : nil,
-                        .accessibilityIdentifier(A11yIdentifiers.settingsScreen.secureBackup)
+                        kind: .navigationLink { context.send(viewAction: .secureBackup) })
-                }
+                    .accessibilityIdentifier(A11yIdentifiers.settingsScreen.secureBackup)
+            default:
+                EmptyView()
             }
         }
     }
@@ -210,8 +212,8 @@ struct SettingsScreen: View {
     }
     
     @ViewBuilder
-    private var secureBackupBadge: some View {
+    private var securitySectionBadge: some View {
-        if context.viewState.showSecureBackupBadge {
+        if context.viewState.showSecuritySectionBadge {
             BadgeView(size: 10)
         }
     }

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -167,6 +167,16 @@ class ClientProxy: ClientProxyProtocol {
         return digest.compactMap { String(format: "%02x", $0) }.joined()
     }()
     
+    func isOnlyDeviceLeft() async -> Result<Bool, ClientProxyError> {
+        do {
+            let result = try await client.encryption().isLastDevice()
+            return .success(result)
+        } catch {
+            MXLog.error("Failed checking isLastDevice with error: \(error)")
+            return .failure(.failedCheckingIsLastDevice(error))
+        }
+    }
+
     func startSync() {
         guard !hasEncounteredAuthError else {
             MXLog.warning("Ignoring request, this client has an unknown token.")

ElementX/Sources/Services/Client/ClientProxyProtocol.swift

@@ -49,6 +49,7 @@ enum ClientProxyError: Error {
     case failedSearchingUsers
     case failedGettingUserProfile
     case failedSettingUserAvatar
+    case failedCheckingIsLastDevice(Error?)
 }
 
 enum SlidingSyncConstants {
@@ -96,6 +97,8 @@ protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
     
     var secureBackupController: SecureBackupControllerProtocol { get }
     
+    func isOnlyDeviceLeft() async -> Result<Bool, ClientProxyError>
+    
     func startSync()
 
     func stopSync()

ElementX/Sources/Services/Client/MockClientProxy.swift

@@ -42,9 +42,8 @@ class MockClientProxy: ClientProxyProtocol {
     
     lazy var secureBackupController: SecureBackupControllerProtocol = {
         let secureBackupController = SecureBackupControllerMock()
-        secureBackupController.underlyingRecoveryKeyState = .init(CurrentValueSubject<SecureBackupRecoveryKeyState, Never>(.enabled))
+        secureBackupController.underlyingRecoveryState = .init(CurrentValueSubject<SecureBackupRecoveryState, Never>(.enabled))
         secureBackupController.underlyingKeyBackupState = .init(CurrentValueSubject<SecureBackupKeyBackupState, Never>(.enabled))
-        secureBackupController.isLastSessionReturnValue = .success(false)
         return secureBackupController
     }()
 
@@ -54,6 +53,10 @@ class MockClientProxy: ClientProxyProtocol {
         self.roomSummaryProvider = roomSummaryProvider
     }
     
+    func isOnlyDeviceLeft() async -> Result<Bool, ClientProxyError> {
+        .success(false)
+    }
+    
     func startSync() { }
 
     func stopSync() { }

ElementX/Sources/Services/SecureBackup/SecureBackupController.swift

@@ -21,7 +21,7 @@ import MatrixRustSDK
 class SecureBackupController: SecureBackupControllerProtocol {
     private let encryption: Encryption
     
-    private let recoveryKeyStateSubject = CurrentValueSubject<SecureBackupRecoveryKeyState, Never>(.unknown)
+    private let recoveryStateSubject = CurrentValueSubject<SecureBackupRecoveryState, Never>(.unknown)
     private let keyBackupStateSubject = CurrentValueSubject<SecureBackupKeyBackupState, Never>(.unknown)
     
     // periphery:ignore - retaining purpose
@@ -33,8 +33,8 @@ class SecureBackupController: SecureBackupControllerProtocol {
     /// Used to dedupe remote backup state requests
     @CancellableTask private var remoteBackupStateTask: Task<Void, Error>?
     
-    var recoveryKeyState: CurrentValuePublisher<SecureBackupRecoveryKeyState, Never> {
+    var recoveryState: CurrentValuePublisher<SecureBackupRecoveryState, Never> {
-        recoveryKeyStateSubject.asCurrentValuePublisher()
+        recoveryStateSubject.asCurrentValuePublisher()
     }
     
     var keyBackupState: CurrentValuePublisher<SecureBackupKeyBackupState, Never> {
@@ -76,16 +76,16 @@ class SecureBackupController: SecureBackupControllerProtocol {
             
             switch state {
             case .unknown:
-                recoveryKeyStateSubject.send(.unknown)
+                recoveryStateSubject.send(.unknown)
             case .enabled:
-                recoveryKeyStateSubject.send(.enabled)
+                recoveryStateSubject.send(.enabled)
             case .disabled:
-                recoveryKeyStateSubject.send(.disabled)
+                recoveryStateSubject.send(.disabled)
             case .incomplete:
-                recoveryKeyStateSubject.send(.incomplete)
+                recoveryStateSubject.send(.incomplete)
             }
             
-            MXLog.info("Recovery state changed to: \(state), setting local state to \(recoveryKeyStateSubject.value)")
+            MXLog.info("Recovery state changed to: \(state), setting local state to \(recoveryStateSubject.value)")
         })
         
         updateBackupStateFromRemote()
@@ -120,7 +120,7 @@ class SecureBackupController: SecureBackupControllerProtocol {
     
     func generateRecoveryKey() async -> Result<String, SecureBackupControllerError> {
         do {
-            guard recoveryKeyState.value == .disabled else {
+            guard recoveryState.value == .disabled else {
                 MXLog.info("Resetting recovery key")
                 
                 let key = try await encryption.resetRecoveryKey()
@@ -135,9 +135,9 @@ class SecureBackupController: SecureBackupControllerProtocol {
                 
                 switch state {
                 case .starting, .creatingBackup, .creatingRecoveryKey, .backingUp:
-                    recoveryKeyStateSubject.send(.settingUp)
+                    recoveryStateSubject.send(.settingUp)
                 case .done:
-                    recoveryKeyStateSubject.send(.enabled)
+                    recoveryStateSubject.send(.enabled)
                 case .roomKeyUploadError:
                     MXLog.error("Failed enabling recovery: room key upload error")
                     keyUploadErrored = true
@@ -163,16 +163,6 @@ class SecureBackupController: SecureBackupControllerProtocol {
         }
     }
         
-    func isLastSession() async -> Result<Bool, SecureBackupControllerError> {
-        do {
-            MXLog.info("Checking if last session")
-            return try await .success(encryption.isLastDevice())
-        } catch {
-            MXLog.error("Failed checking if last session with error: \(error)")
-            return .failure(.failedFetchingSessionState)
-        }
-    }
-    
     func waitForKeyBackupUpload() async -> Result<Void, SecureBackupControllerError> {
         do {
             MXLog.info("Waiting for backup upload steady state")

ElementX/Sources/Services/SecureBackup/SecureBackupControllerProtocol.swift

@@ -17,7 +17,7 @@
 import Combine
 import Foundation
 
-enum SecureBackupRecoveryKeyState {
+enum SecureBackupRecoveryState {
     case unknown
     case disabled
     case enabled
@@ -50,7 +50,7 @@ enum SecureBackupControllerError: Error {
 
 // sourcery: AutoMockable
 protocol SecureBackupControllerProtocol {
-    var recoveryKeyState: CurrentValuePublisher<SecureBackupRecoveryKeyState, Never> { get }
+    var recoveryState: CurrentValuePublisher<SecureBackupRecoveryState, Never> { get }
     
     var keyBackupState: CurrentValuePublisher<SecureBackupKeyBackupState, Never> { get }
     
@@ -60,7 +60,5 @@ protocol SecureBackupControllerProtocol {
     func generateRecoveryKey() async -> Result<String, SecureBackupControllerError>
     func confirmRecoveryKey(_ key: String) async -> Result<Void, SecureBackupControllerError>
     
-    func isLastSession() async -> Result<Bool, SecureBackupControllerError>
-    
     func waitForKeyBackupUpload() async -> Result<Void, SecureBackupControllerError>
 }

ElementX/Sources/Services/Session/MockUserSession.swift

@@ -25,5 +25,5 @@ struct MockUserSession: UserSessionProtocol {
     let clientProxy: ClientProxyProtocol
     let mediaProvider: MediaProviderProtocol
     let voiceMessageMediaManager: VoiceMessageMediaManagerProtocol
-    var sessionVerificationState: CurrentValuePublisher<Bool?, Never> = .init(.init(true))
+    var sessionSecurityStatePublisher: AnyPublisher<SessionSecurityState, Never> = CurrentValueSubject<SessionSecurityState, Never>(.init(verificationState: .verified, recoveryState: .enabled)).eraseToAnyPublisher()
 }

ElementX/Sources/Services/Session/UserSession.swift

@@ -18,10 +18,12 @@ import Combine
 import Foundation
 
 class UserSession: UserSessionProtocol {
+    private let sessionVerificationStateSubject: CurrentValueSubject<SessionVerificationState, Never> = .init(.unknown)
+    
     private var cancellables = Set<AnyCancellable>()
     
     private var checkSessionVerificationStateCancellable: AnyCancellable?
-    private var checkSessionVerificationStateTask: Task<Void, Never>?
+    private var retrieveSessionVerificationControllerTask: Task<Void, Never>?
     
     private var authErrorCancellable: AnyCancellable?
     
@@ -40,7 +42,7 @@ class UserSession: UserSessionProtocol {
             sessionVerificationController?.callbacks.sink { [weak self] callback in
                 switch callback {
                 case .finished:
-                    self?.sessionVerificationStateSubject.send(true)
+                    self?.sessionVerificationStateSubject.send(.verified)
                 default:
                     break
                 }
@@ -49,74 +51,31 @@ class UserSession: UserSessionProtocol {
         }
     }
     
-    private var sessionVerificationStateSubject: CurrentValueSubject<Bool?, Never> = .init(nil)
+    let sessionSecurityStatePublisher: AnyPublisher<SessionSecurityState, Never>
-    var sessionVerificationState: CurrentValuePublisher<Bool?, Never> {
-        sessionVerificationStateSubject.asCurrentValuePublisher()
-    }
     
     init(clientProxy: ClientProxyProtocol, mediaProvider: MediaProviderProtocol, voiceMessageMediaManager: VoiceMessageMediaManagerProtocol) {
         self.clientProxy = clientProxy
         self.mediaProvider = mediaProvider
         self.voiceMessageMediaManager = voiceMessageMediaManager
         
-        setupSessionVerificationWatchdog()
+        sessionSecurityStatePublisher = Publishers.CombineLatest(sessionVerificationStateSubject, clientProxy.secureBackupController.recoveryState)
-        setupAuthErrorWatchdog()
+            .map {
-    }
+                MXLog.info("Session security state changed, verificationState: \($0), recoveryState: \($1)")
+                return SessionSecurityState(verificationState: $0, recoveryState: $1)
+            }
+            .removeDuplicates()
+            .receive(on: DispatchQueue.main)
+            .eraseToAnyPublisher()
         
-    // MARK: - Private
+        clientProxy.callbacks
-    
-    private func setupSessionVerificationWatchdog() {
-        checkSessionVerificationStateCancellable = clientProxy.callbacks
             .receive(on: DispatchQueue.main)
             .sink { [weak self] callback in
                 if callback.isSyncUpdate {
-                    self?.attemptSessionVerification()
+                    self?.checkSessionVerificationState()
                 }
             }
-    }
+            .store(in: &cancellables)
         
-    private func attemptSessionVerification() {
-        guard checkSessionVerificationStateTask == nil else {
-            MXLog.info("Session verification state check already in progress")
-            return
-        }
-        
-        MXLog.info("Checking session verification state")
-        
-        checkSessionVerificationStateTask = Task {
-            MXLog.info("Retrieving session verification controller")
-            
-            switch await clientProxy.sessionVerificationControllerProxy() {
-            case .success(let sessionVerificationController):
-                MXLog.info("Retrieving session verification state")
-                
-                guard case let .success(isVerified) = await sessionVerificationController.isVerified() else {
-                    MXLog.error("Failed checking verification state. Will retry on the next sync update.")
-                    return
-                }
-                
-                tearDownSessionVerificationControllerWatchdog()
-                
-                self.sessionVerificationController = sessionVerificationController
-                
-                MXLog.info("Session verified: \(isVerified)")
-                
-                sessionVerificationStateSubject.send(isVerified)
-                
-                checkSessionVerificationStateTask = nil
-            case .failure(let error):
-                MXLog.info("Failed getting session verification controller with error: \(error). Will retry on the next sync update.")
-            }
-        }
-    }
-    
-    private func tearDownSessionVerificationControllerWatchdog() {
-        checkSessionVerificationStateCancellable = nil
-    }
-
-    // MARK: Auth Error Watchdog
-
-    private func setupAuthErrorWatchdog() {
         authErrorCancellable = clientProxy.callbacks
             .receive(on: DispatchQueue.main)
             .sink { [weak self] callback in
@@ -124,14 +83,68 @@ class UserSession: UserSessionProtocol {
                 switch callback {
                 case .receivedAuthError(let isSoftLogout):
                     callbacks.send(.didReceiveAuthError(isSoftLogout: isSoftLogout))
-                    tearDownAuthErrorWatchdog()
+                    authErrorCancellable = nil
                 default:
                     break
                 }
             }
     }
     
-    private func tearDownAuthErrorWatchdog() {
+    // MARK: - Private
-        authErrorCancellable = nil
+        
+    private func checkSessionVerificationState() {
+        guard retrieveSessionVerificationControllerTask == nil else {
+            MXLog.info("Session verification state check already in progress")
+            return
+        }
+        
+        guard sessionVerificationController == nil else {
+            Task {
+                await updateSessionVerificationState()
+            }
+            return
+        }
+        
+        MXLog.info("Retrieving session verification controller")
+        
+        retrieveSessionVerificationControllerTask = Task {
+            switch await clientProxy.sessionVerificationControllerProxy() {
+            case .success(let sessionVerificationController):
+                self.sessionVerificationController = sessionVerificationController
+                await updateSessionVerificationState()
+                
+                retrieveSessionVerificationControllerTask = nil
+            case .failure(let error):
+                MXLog.info("Failed getting session verification controller with error: \(error). Will retry on the next sync update.")
+            }
+        }
+    }
+    
+    private func updateSessionVerificationState() async {
+        guard let sessionVerificationController else {
+            fatalError("This point should never be reached")
+        }
+        
+        MXLog.info("Checking session verification state")
+        
+        guard case let .success(isVerified) = await sessionVerificationController.isVerified() else {
+            MXLog.error("Failed checking verification state. Will retry on the next sync update.")
+            return
+        }
+        
+        if isVerified {
+            sessionVerificationStateSubject.send(.verified)
+        } else {
+            guard case let .success(isLastDevice) = await clientProxy.isOnlyDeviceLeft() else {
+                MXLog.error("Failed checking isLastDevice. Will retry on the next sync update.")
+                return
+            }
+            
+            if isLastDevice {
+                sessionVerificationStateSubject.send(.unverifiedLastSession)
+            } else {
+                sessionVerificationStateSubject.send(.unverified)
+            }
+        }
     }
 }

ElementX/Sources/Services/Session/UserSessionProtocol.swift

@@ -21,6 +21,18 @@ enum UserSessionCallback {
     case didReceiveAuthError(isSoftLogout: Bool)
 }
 
+enum SessionVerificationState {
+    case unknown
+    case verified
+    case unverified
+    case unverifiedLastSession
+}
+
+struct SessionSecurityState: Equatable {
+    let verificationState: SessionVerificationState
+    let recoveryState: SecureBackupRecoveryState
+}
+
 protocol UserSessionProtocol {
     var homeserver: String { get }
     var userID: String { get }
@@ -30,7 +42,7 @@ protocol UserSessionProtocol {
     var mediaProvider: MediaProviderProtocol { get }
     var voiceMessageMediaManager: VoiceMessageMediaManagerProtocol { get }
     
-    var sessionVerificationState: CurrentValuePublisher<Bool?, Never> { get }
+    var sessionSecurityStatePublisher: AnyPublisher<SessionSecurityState, Never> { get }
     var sessionVerificationController: SessionVerificationControllerProxyProtocol? { get }
     
     var callbacks: PassthroughSubject<UserSessionCallback, Never> { get }

UnitTests/Sources/UserSession/UserSessionTests.swift

@@ -32,8 +32,8 @@ final class UserSessionTests: XCTestCase {
 
     func test_whenUserSessionReceivesSyncUpdateAndSessionControllerRetrievedAndSessionNotVerified_sessionVerificationNeededEventReceived() throws {
         let expectation = expectation(description: "SessionVerificationNeeded expectation")
-        userSession.sessionVerificationState.sink { isVerified in
+        userSession.sessionSecurityStatePublisher.sink { securityState in
-            if let isVerified, isVerified == false {
+            if securityState.verificationState == .unverified {
                 expectation.fulfill()
             }
         }