Verify Element X with an existing Element Classic account. (#5374)

* Read and import the secrets from ClassicAppAccounts.

* Record snapshots.

* Add some documentation, tidy up tests and fix the dismissal of the backup instructions.

* Workaround flakey tests (the fulfilments weren't always firing).

* Allow a custom Classic App deep link URL to be configured.

ElementX/Sources/Screens/Authentication/StartScreen/AuthenticationStartScreenViewModel.swift

@@ -14,6 +14,7 @@ typealias AuthenticationStartScreenViewModelType = StateStoreViewModelV2<Authent
 class AuthenticationStartScreenViewModel: AuthenticationStartScreenViewModelType, AuthenticationStartScreenViewModelProtocol {
     private let authenticationService: AuthenticationServiceProtocol
     private let provisioningParameters: AccountProvisioningParameters?
+    private let appMediator: AppMediatorProtocol
     private let appSettings: AppSettings
     private let userIndicatorController: UserIndicatorControllerProtocol
     
@@ -28,16 +29,21 @@ class AuthenticationStartScreenViewModel: AuthenticationStartScreenViewModelType
     init(authenticationService: AuthenticationServiceProtocol,
          provisioningParameters: AccountProvisioningParameters?,
          isBugReportServiceEnabled: Bool,
+         appMediator: AppMediatorProtocol,
          appSettings: AppSettings,
          mediaProvider: MediaProviderProtocol?,
+         notificationCenter: NotificationCenter = .default,
          userIndicatorController: UserIndicatorControllerProtocol) {
         self.authenticationService = authenticationService
         self.provisioningParameters = provisioningParameters
+        self.appMediator = appMediator
         self.appSettings = appSettings
         self.userIndicatorController = userIndicatorController
         canReportProblem = isBugReportServiceEnabled
         
         let isQRCodeScanningSupported = !ProcessInfo.processInfo.isiOSAppOnMac
+        let classicAppAccountProvider = authenticationService.classicAppAccount?.serverName
+        let isClassicAppAccountAllowed = classicAppAccountProvider.map { appSettings.accountProviders.contains($0) } ?? false
         
         let initialViewState = if !appSettings.allowOtherAccountProviders {
             // We don't show the create account button when custom providers are disallowed.
@@ -45,22 +51,31 @@ class AuthenticationStartScreenViewModel: AuthenticationStartScreenViewModelType
             AuthenticationStartScreenViewState(serverName: appSettings.accountProviders.count == 1 ? appSettings.accountProviders[0] : nil,
                                                showCreateAccountButton: false,
                                                showQRCodeLoginButton: isQRCodeScanningSupported,
+                                               classicAppMode: isClassicAppAccountAllowed ? authenticationService.classicAppAccount.map { .welcomeBack($0) } : nil,
                                                hideBrandChrome: appSettings.hideBrandChrome)
         } else if let provisioningParameters {
             // We only show the "Sign in to …" button when using a provisioning link.
             AuthenticationStartScreenViewState(serverName: provisioningParameters.accountProvider,
                                                showCreateAccountButton: false,
                                                showQRCodeLoginButton: false,
+                                               classicAppMode: nil,
                                                hideBrandChrome: appSettings.hideBrandChrome)
         } else {
             // The default configuration.
             AuthenticationStartScreenViewState(serverName: nil,
                                                showCreateAccountButton: appSettings.showCreateAccountButton,
                                                showQRCodeLoginButton: isQRCodeScanningSupported,
+                                               classicAppMode: authenticationService.classicAppAccount.map { .welcomeBack($0) },
                                                hideBrandChrome: appSettings.hideBrandChrome)
         }
         
         super.init(initialViewState: initialViewState, mediaProvider: mediaProvider)
+        
+        notificationCenter.publisher(for: UIApplication.didBecomeActiveNotification)
+            .sink { [weak self] _ in
+                self?.reloadClassicAppAccount()
+            }
+            .store(in: &cancellables)
     }
     
     override func process(viewAction: AuthenticationStartScreenViewAction) {
@@ -78,29 +93,51 @@ class AuthenticationStartScreenViewModel: AuthenticationStartScreenViewModelType
             if canReportProblem {
                 actionsSubject.send(.reportProblem)
             }
-        case .continueWithClassic, .otherOptions, .closeOtherOptions:
-            break // To follow.
+        case .continueWithClassic(let account):
+            Task { await login(classicAppAccount: account) }
+        case .otherOptions(let account):
+            state.classicAppMode = .otherOptions(account)
+        case .closeOtherOptions(let account):
+            state.classicAppMode = .welcomeBack(account)
+        case .openClassicApp:
+            guard let classicAppDeepLinkURL = InfoPlistReader.main.classicAppDeepLinkURL else { return }
+            appMediator.open(classicAppDeepLinkURL)
         }
     }
     
     // MARK: - Private
     
-    private func login() async {
-        if let serverName = state.serverName {
+    private func login(classicAppAccount: ClassicAppAccount? = nil) async {
+        if let classicAppAccount {
+            if classicAppAccount.state.availableSecrets == .requiresBackup {
+                state.bindings.showClassicAppBackupInstructions = true
+            } else {
+                await configureAccountProvider(classicAppAccount.serverName,
+                                               loginHint: "mxid:\(classicAppAccount.userID)",
+                                               fallbackHomeserverURL: classicAppAccount.homeserverURL)
+            }
+        } else if let serverName = state.serverName {
             await configureAccountProvider(serverName, loginHint: provisioningParameters?.loginHint)
         } else {
             actionsSubject.send(.login) // No need to configure anything here, continue the flow.
         }
     }
     
-    private func configureAccountProvider(_ accountProvider: String, loginHint: String? = nil) async {
+    private func configureAccountProvider(_ accountProvider: String, loginHint: String? = nil, fallbackHomeserverURL: URL? = nil) async {
         startLoading()
         defer { stopLoading() }
         
-        guard case .success = await authenticationService.configure(for: accountProvider, flow: .login) else {
-            // As the server was provisioned, we don't worry about the specifics and show a generic error to the user.
-            displayError()
-            return
+        if case .failure = await authenticationService.configure(for: accountProvider, flow: .login) {
+            // Try the fallback URL before showing an error.
+            if let fallbackHomeserverURL,
+               case .success = await authenticationService.configure(for: fallbackHomeserverURL.absoluteString, flow: .login) {
+                // Fallback succeeded, continue with the flow.
+            } else {
+                // As the server was provisioned, we don't worry about the specifics and show a generic error to the user.
+                // Element Classic accounts aren't shown for unsupported servers either, so nothing to do here.
+                displayError()
+                return
+            }
         }
         
         guard authenticationService.homeserver.value.loginMode.supportsOIDCFlow else {
@@ -121,6 +158,23 @@ class AuthenticationStartScreenViewModel: AuthenticationStartScreenViewModelType
         }
     }
     
+    @CancellableTask private var reloadClassicAppSecretsTask: Task<Void, Never>?
+    private func reloadClassicAppAccount() {
+        guard case let .welcomeBack(classicAppAccount) = state.classicAppMode else { return }
+        
+        reloadClassicAppSecretsTask = Task { [weak self] in
+            await self?.authenticationService.refreshClassicAppAccountState()
+            
+            guard !Task.isCancelled else { return }
+            
+            if let availableSecrets = classicAppAccount.state.availableSecrets, availableSecrets != .requiresBackup {
+                await MainActor.run { self?.state.bindings.showClassicAppBackupInstructions = false }
+            }
+        }
+    }
+    
+    // MARK: - User Indicators
+    
     private let loadingIndicatorID = "\(AuthenticationStartScreenViewModel.self)-Loading"
     
     private func startLoading() {