Show internet connection warning when uploading keys on log out. (#4027)

* Show the key upload progress when waiting to log out. Add some basic view model tests too. * Show a network suggestion if key upload doesn't report any progress during logout.
2026-11-02 12:07:55 +00:00 · 2025-04-15 16:47:31 +01:00
parent 5ea95913e8
commit c5bb960234
27 changed files with 270 additions and 83 deletions
@@ -13,9 +13,10 @@ enum SecureBackupLogoutConfirmationScreenViewModelAction {
    case logout
 }

-enum SecureBackupLogoutConfirmationScreenViewMode {
+enum SecureBackupLogoutConfirmationScreenViewMode: Equatable {
    case saveRecoveryKey
-    case backupOngoing
+    case waitingToStart(hasStalled: Bool)
+    case backupOngoing(progress: Double)
    case offline
 }

@@ -14,9 +14,13 @@ class SecureBackupLogoutConfirmationScreenViewModel: SecureBackupLogoutConfirmat
    private let secureBackupController: SecureBackupControllerProtocol
    private let appMediator: AppMediatorProtocol
    
+    private let backupUploadStateSubject: CurrentValueSubject<SecureBackupSteadyState, Never> = .init(.waiting)
+    
    // periphery:ignore - auto cancels when reassigned
    @CancellableTask
    private var keyUploadWaitingTask: Task<Void, Never>?
+    @CancellableTask
+    private var keyUploadStalledTask: Task<Void, Error>?
    
    private var actionsSubject: PassthroughSubject<SecureBackupLogoutConfirmationScreenViewModelAction, Never> = .init()
    var actions: AnyPublisher<SecureBackupLogoutConfirmationScreenViewModelAction, Never> {
@@ -29,19 +33,11 @@ class SecureBackupLogoutConfirmationScreenViewModel: SecureBackupLogoutConfirmat
        
        super.init(initialViewState: .init(mode: .saveRecoveryKey))
        
-        appMediator.networkMonitor.reachabilityPublisher
+        backupUploadStateSubject.combineLatest(appMediator.networkMonitor.reachabilityPublisher)
            .receive(on: DispatchQueue.main)
-            .sink { [weak self] reachability in
-                guard let self,
-                      state.mode != .saveRecoveryKey else {
-                    return
-                }
-                
-                if reachability == .reachable {
-                    state.mode = .backupOngoing
-                } else {
-                    state.mode = .offline
-                }
+            .sink { [weak self] backupState, reachability in
+                guard let self, state.mode != .saveRecoveryKey else { return }
+                updateMode(backupState: backupState, reachability: reachability)
            }
            .store(in: &cancellables)
    }
@@ -65,29 +61,56 @@ class SecureBackupLogoutConfirmationScreenViewModel: SecureBackupLogoutConfirmat
    // MARK: - Private
    
    private func attemptLogout() {
-        if state.mode == .saveRecoveryKey {
-            state.mode = appMediator.networkMonitor.reachabilityPublisher.value == .reachable ? .backupOngoing : .offline
+        if case .saveRecoveryKey = state.mode {
+            updateMode(backupState: backupUploadStateSubject.value, reachability: appMediator.networkMonitor.reachabilityPublisher.value)
            
            keyUploadWaitingTask = Task {
-                var result = await secureBackupController.waitForKeyBackupUpload()
+                var result = await secureBackupController.waitForKeyBackupUpload(uploadStateSubject: backupUploadStateSubject)
+                
+                guard !Task.isCancelled else { return }
                
                if case .failure = result {
                    // Retry the upload first, conditions might have changed.
-                    result = await secureBackupController.waitForKeyBackupUpload()
+                    result = await secureBackupController.waitForKeyBackupUpload(uploadStateSubject: backupUploadStateSubject)
                }
                
+                guard !Task.isCancelled else { return }
+                
                guard case .success = result else {
                    MXLog.error("Aborting logout due to failure waiting for backup upload.")
                    state.bindings.alertInfo = .init(id: .backupUploadFailed)
                    return
                }
                
-                guard !Task.isCancelled else { return }
-                
                actionsSubject.send(.logout)
            }
        } else {
            actionsSubject.send(.logout)
        }
    }
+    
+    private func updateMode(backupState: SecureBackupSteadyState, reachability: NetworkMonitorReachability) {
+        switch (backupState, reachability) {
+        case (.waiting, .reachable):
+            state.mode = .waitingToStart(hasStalled: false)
+            showAsStalledAfterTimeout()
+        case (.uploading(let uploadedKeyCount, let totalKeyCount), .reachable):
+            state.mode = .backupOngoing(progress: Double(uploadedKeyCount) / Double(totalKeyCount))
+        case (.error, .reachable):
+            break // Nothing to do here, it will be handled with the result.
+        case (.done, .reachable):
+            state.mode = .backupOngoing(progress: 1.0)
+        case (_, .unreachable):
+            state.mode = .offline
+        }
+    }
+    
+    /// If we stay in the waiting state for more than 2-seconds we ask the user to check their connection.
+    private func showAsStalledAfterTimeout() {
+        keyUploadStalledTask = Task { [weak self] in
+            try await Task.sleep(for: .seconds(2))
+            guard let self, case .waitingToStart(hasStalled: false) = state.mode else { return }
+            state.mode = .waitingToStart(hasStalled: true)
+        }
+    }
 }
@@ -40,16 +40,25 @@ struct SecureBackupLogoutConfirmationScreen: View {
            .font(.compound.bodyMD)
            .multilineTextAlignment(.center)
        
-        if context.viewState.mode == .backupOngoing {
+        if case let .waitingToStart(hasStalled) = context.viewState.mode {
            Spacer()
            ProgressView()
+            
+            if hasStalled {
+                Text(L10n.commonPleaseCheckInternetConnection)
+                    .font(.compound.bodySM)
+                    .foregroundColor(.compound.textPrimary)
+            }
+        } else if case let .backupOngoing(progress) = context.viewState.mode {
+            Spacer()
+            ProgressView(value: progress)
        }
    }
    
    @ViewBuilder
    private var footer: some View {
        VStack(spacing: 16.0) {
-            if context.viewState.mode == .saveRecoveryKey {
+            if case .saveRecoveryKey = context.viewState.mode {
                Button {
                    context.send(viewAction: .settings)
                } label: {
@@ -80,7 +89,7 @@ struct SecureBackupLogoutConfirmationScreen: View {
        switch context.viewState.mode {
        case .saveRecoveryKey:
            return L10n.screenSignoutSaveRecoveryKeyTitle
-        case .backupOngoing:
+        case .waitingToStart, .backupOngoing:
            return L10n.screenSignoutKeyBackupOngoingTitle
        case .offline:
            return L10n.screenSignoutKeyBackupOfflineTitle
@@ -91,7 +100,7 @@ struct SecureBackupLogoutConfirmationScreen: View {
        switch context.viewState.mode {
        case .saveRecoveryKey:
            return L10n.screenSignoutSaveRecoveryKeySubtitle
-        case .backupOngoing:
+        case .waitingToStart, .backupOngoing:
            return L10n.screenSignoutKeyBackupOngoingSubtitle
        case .offline:
            return L10n.screenSignoutKeyBackupOfflineSubtitle
@@ -102,25 +111,69 @@ struct SecureBackupLogoutConfirmationScreen: View {
 // MARK: - Previews

 struct SecureBackupLogoutConfirmationScreen_Previews: PreviewProvider, TestablePreview {
-    static let viewModel = buildViewModel()
+    static let viewModel = makeViewModel(mode: .saveRecoveryKey)
+    static let waitingViewModel = makeViewModel(mode: .waitingToStart(hasStalled: false))
+    static let ongoingViewModel = makeViewModel(mode: .backupOngoing(progress: 0.5))
+    static let offlineViewModel = makeViewModel(mode: .offline)
    
    static var previews: some View {
        NavigationStack {
            SecureBackupLogoutConfirmationScreen(context: viewModel.context)
        }
+        .previewDisplayName("Confirmation")
+        
+        NavigationStack {
+            SecureBackupLogoutConfirmationScreen(context: waitingViewModel.context)
+        }
+        .previewDisplayName("Waiting")
+        .snapshotPreferences(expect: waitingViewModel.context.$viewState.map { $0.mode == .waitingToStart(hasStalled: false) })
+        
+        NavigationStack {
+            SecureBackupLogoutConfirmationScreen(context: ongoingViewModel.context)
+        }
+        .previewDisplayName("Ongoing")
+        .snapshotPreferences(expect: ongoingViewModel.context.$viewState.map { $0.mode == .backupOngoing(progress: 0.5) })
+        
+        // Uses the same view model as Waiting but with a different expectation.
+        NavigationStack {
+            SecureBackupLogoutConfirmationScreen(context: waitingViewModel.context)
+        }
+        .previewDisplayName("Stalled")
+        .snapshotPreferences(expect: waitingViewModel.context.$viewState.map { $0.mode == .waitingToStart(hasStalled: true) })
+        
+        NavigationStack {
+            SecureBackupLogoutConfirmationScreen(context: offlineViewModel.context)
+        }
+        .previewDisplayName("Offline")
+        .snapshotPreferences(expect: offlineViewModel.context.$viewState.map { $0.mode == .offline })
    }
    
-    static func buildViewModel() -> SecureBackupLogoutConfirmationScreenViewModelType {
+    static func makeViewModel(mode: SecureBackupLogoutConfirmationScreenViewMode) -> SecureBackupLogoutConfirmationScreenViewModel {
        let secureBackupController = SecureBackupControllerMock()
        secureBackupController.underlyingKeyBackupState = CurrentValueSubject<SecureBackupKeyBackupState, Never>(.enabled).asCurrentValuePublisher()
        
+        secureBackupController.waitForKeyBackupUploadUploadStateSubjectClosure = { uploadStateSubject in
+            if case .backupOngoing = mode {
+                uploadStateSubject.send(.uploading(uploadedKeyCount: 50, totalKeyCount: 100))
+            }
+            
+            return .success(())
+        }
+        
+        let reachability: NetworkMonitorReachability = mode == .offline ? .unreachable : .reachable
        let networkMonitor = NetworkMonitorMock()
-        networkMonitor.underlyingReachabilityPublisher = CurrentValueSubject<NetworkMonitorReachability, Never>(.reachable).asCurrentValuePublisher()
+        networkMonitor.underlyingReachabilityPublisher = CurrentValueSubject<NetworkMonitorReachability, Never>(reachability).asCurrentValuePublisher()
        
        let appMediator = AppMediatorMock()
        appMediator.underlyingNetworkMonitor = networkMonitor
        
-        return SecureBackupLogoutConfirmationScreenViewModel(secureBackupController: secureBackupController,
-                                                             appMediator: appMediator)
+        let viewModel = SecureBackupLogoutConfirmationScreenViewModel(secureBackupController: secureBackupController,
+                                                                      appMediator: appMediator)
+        
+        if mode != .saveRecoveryKey {
+            viewModel.context.send(viewAction: .logout)
+        }
+        
+        return viewModel
    }
 }