issue 1111 only initialize Realm and KeyChainService once

FlowCrypt/App/AppContext.swift

@@ -0,0 +1,114 @@
+//
+//  AppContext.swift
+//  FlowCrypt
+//
+//  Created by Tom on 30.11.2021
+//  Copyright © 2017-present FlowCrypt a. s. All rights reserved.
+//
+
+import Foundation
+
+class AppContext {
+
+    let globalRouter: GlobalRouter
+    let encryptedStorage: EncryptedStorageType
+    let session: SessionType?
+    // todo - should be called sessionService
+    // also should have maybe `.currentSession` on it, then we don't have to have `session` above?
+    let userAccountService: UserAccountServiceType
+    let dataService: DataServiceType
+    let keyStorage: KeyStorageType
+    let keyService: KeyServiceType
+    let passPhraseService: PassPhraseServiceType
+    let clientConfigurationService: ClientConfigurationServiceType
+
+    private init(
+        encryptedStorage: EncryptedStorageType,
+        session: SessionType?,
+        userAccountService: UserAccountServiceType,
+        dataService: DataServiceType,
+        keyStorage: KeyStorageType,
+        keyService: KeyServiceType,
+        passPhraseService: PassPhraseServiceType,
+        clientConfigurationService: ClientConfigurationServiceType,
+        globalRouter: GlobalRouter
+    ) {
+        self.encryptedStorage = encryptedStorage
+        self.session = session
+        self.userAccountService = userAccountService
+        self.dataService = dataService
+        self.keyStorage = keyStorage // todo - keyStorage and keyService should be the same
+        self.keyService = keyService
+        self.passPhraseService = passPhraseService
+        self.clientConfigurationService = clientConfigurationService
+        self.globalRouter = globalRouter
+    }
+
+    @MainActor
+    static func setUpAppContext(globalRouter: GlobalRouter) throws -> AppContext {
+        let keyChainService = KeyChainService()
+        let encryptedStorage = EncryptedStorage(
+            storageEncryptionKey: try keyChainService.getStorageEncryptionKey()
+        )
+        let dataService = DataService(encryptedStorage: encryptedStorage)
+        let passPhraseService = PassPhraseService(encryptedStorage: encryptedStorage)
+        let keyStorage = KeyDataStorage(encryptedStorage: encryptedStorage)
+        let keyService = KeyService(
+            storage: keyStorage,
+            passPhraseService: passPhraseService,
+            currentUserEmail: { dataService.email }
+        )
+        let clientConfigurationService = ClientConfigurationService(
+            local: LocalClientConfiguration(
+                encryptedStorage: encryptedStorage
+            )
+        )
+        return AppContext(
+            encryptedStorage: encryptedStorage,
+            session: nil, // will be set later. But would be nice to already set here, if available
+            userAccountService: UserAccountService(
+                encryptedStorage: encryptedStorage,
+                dataService: dataService
+            ),
+            dataService: dataService,
+            keyStorage: keyStorage,
+            keyService: keyService,
+            passPhraseService: passPhraseService,
+            clientConfigurationService: clientConfigurationService,
+            globalRouter: globalRouter
+        )
+    }
+
+    func withSession(_ session: SessionType?) -> AppContext {
+        return AppContext(
+            encryptedStorage: self.encryptedStorage,
+            session: session,
+            userAccountService: self.userAccountService,
+            dataService: self.dataService,
+            keyStorage: self.keyStorage,
+            keyService: self.keyService,
+            passPhraseService: self.passPhraseService,
+            clientConfigurationService: self.clientConfigurationService,
+            globalRouter: globalRouter
+        )
+    }
+
+    func getRequiredMailProvider() -> MailProvider {
+        guard let mailProvider = getOptionalMailProvider() else {
+            // todo - should throw instead
+            fatalError("wrongly using mail provider when not logged in")
+        }
+        return mailProvider
+    }
+
+    func getOptionalMailProvider() -> MailProvider? {
+        guard let currentUser = self.dataService.currentUser, let currentAuthType = self.dataService.currentAuthType else {
+            return nil
+        }
+        return MailProvider(
+            currentAuthType: currentAuthType,
+            currentUser: currentUser
+        )
+    }
+
+}

FlowCrypt/App/main.swift

@@ -9,16 +9,9 @@
 import Foundation
 import UIKit
 
-autoreleasepool {
-    if ProcessInfo().arguments.contains(AppReset.reset.rawValue) {
-        AppReset.resetKeychain()
-        AppReset.resetUserDefaults()
-    }
-
-    UIApplicationMain(
-        CommandLine.argc,
-        CommandLine.unsafeArgv,
-        nil,
-        NSStringFromClass(AppDelegate.self)
-    )
-}
+UIApplicationMain(
+    CommandLine.argc,
+    CommandLine.unsafeArgv,
+    nil,
+    NSStringFromClass(AppDelegate.self)
+)

FlowCrypt/Controllers/Bootstrap/InvalidStorageViewController.swift

@@ -18,10 +18,10 @@ final class InvalidStorageViewController: TableNodeViewController {
     }
 
     private let error: Error
-    private let encryptedStorage: EncryptedStorageType
+    private let encryptedStorage: EncryptedStorageType? // nil if failed to initialize
     private let router: GlobalRouterType
 
-    init(error: Error, encryptedStorage: EncryptedStorageType, router: GlobalRouterType) {
+    init(error: Error, encryptedStorage: EncryptedStorageType?, router: GlobalRouterType) {
         self.error = error
         self.encryptedStorage = encryptedStorage
         self.router = router
@@ -44,6 +44,10 @@ final class InvalidStorageViewController: TableNodeViewController {
     }
 
     @objc private func handleTap() {
+        guard let encryptedStorage = encryptedStorage else {
+            showAlert(message: "invalid_storage_failed_to_initialize".localized)
+            return
+        }
         do {
             try encryptedStorage.reset()
             router.proceed()

FlowCrypt/Controllers/CheckMailAuth/CheckMailAuthViewController.swift

@@ -13,8 +13,10 @@ import UIKit
 
 class CheckMailAuthViewController: TableNodeViewController {
     private let globalRouter: GlobalRouterType
+    private let appContext: AppContext
 
-    init(globalRouter: GlobalRouterType = GlobalRouter()) {
+    init(appContext: AppContext, globalRouter: GlobalRouterType = GlobalRouter()) {
+        self.appContext = appContext
         self.globalRouter = globalRouter
         super.init(node: TableNode())
     }
@@ -85,7 +87,7 @@ extension CheckMailAuthViewController {
         case 2:
             return ButtonCellNode(input: .signInAgain) { [weak self] in
                 guard let self = self else { return }
-                self.globalRouter.signIn(with: .gmailLogin(self))
+                self.globalRouter.signIn(appContext: self.appContext, route: .gmailLogin(self))
             }
         default:
             return ASCellNode()

FlowCrypt/Controllers/Compose/ComposeViewController.swift

@@ -39,18 +39,18 @@ final class ComposeViewController: TableNodeViewController {
         case subject, subjectDivider, text
     }
 
+    private let appContext: AppContext
     private let composeMessageService: ComposeMessageService
     private let notificationCenter: NotificationCenter
     private let decorator: ComposeViewDecorator
     private let contactsService: ContactsServiceType
     private let cloudContactProvider: CloudContactsProvider
     private let filesManager: FilesManagerType
     private let photosManager: PhotosManagerType
-    private let keyService: KeyServiceType
     private let keyMethods: KeyMethodsType
     private let service: ServiceActor
-    private let passPhraseService: PassPhraseService
     private let router: GlobalRouterType
+    private let clientConfiguration: ClientConfiguration
 
     private let search = PassthroughSubject<String, Never>()
     private let userDefaults: UserDefaults
@@ -68,42 +68,56 @@ final class ComposeViewController: TableNodeViewController {
     private var composedLatestDraft: ComposedDraft?
 
     init(
-        email: String,
+        appContext: AppContext,
         notificationCenter: NotificationCenter = .default,
         decorator: ComposeViewDecorator = ComposeViewDecorator(),
         input: ComposeMessageInput = .empty,
-        cloudContactProvider: CloudContactsProvider = UserContactsProvider(),
+        cloudContactProvider: CloudContactsProvider? = nil,
         userDefaults: UserDefaults = .standard,
-        contactsService: ContactsServiceType = ContactsService(),
-        composeMessageService: ComposeMessageService = ComposeMessageService(),
+        contactsService: ContactsServiceType? = nil,
+        composeMessageService: ComposeMessageService? = nil,
         filesManager: FilesManagerType = FilesManager(),
         photosManager: PhotosManagerType = PhotosManager(),
-        keyService: KeyServiceType = KeyService(),
-        passPhraseService: PassPhraseService = PassPhraseService(),
         keyMethods: KeyMethodsType = KeyMethods(),
         router: GlobalRouterType = GlobalRouter()
     ) {
+        self.appContext = appContext
+        guard let email = appContext.dataService.email else {
+            fatalError("missing current user email") // todo - need a more elegant solution
+        }
         self.email = email
         self.notificationCenter = notificationCenter
         self.input = input
         self.decorator = decorator
         self.userDefaults = userDefaults
-        self.contactsService = contactsService
+        let clientConfiguration = appContext.clientConfigurationService.getSaved(for: email)
+        self.contactsService = contactsService ?? ContactsService(
+            localContactsProvider: LocalContactsProvider(
+                encryptedStorage: appContext.encryptedStorage
+            ),
+            clientConfiguration: clientConfiguration
+        )
+        let cloudContactProvider = cloudContactProvider ?? UserContactsProvider(
+            userService: GoogleUserService(currentUserEmail: email)
+        )
         self.cloudContactProvider = cloudContactProvider
-        self.composeMessageService = composeMessageService
+        self.composeMessageService = composeMessageService ?? ComposeMessageService(
+            clientConfiguration: clientConfiguration,
+            encryptedStorage: appContext.encryptedStorage,
+            messageGateway: appContext.getRequiredMailProvider().messageSender
+        )
         self.filesManager = filesManager
         self.photosManager = photosManager
-        self.keyService = keyService
         self.keyMethods = keyMethods
         self.service = ServiceActor(
-            composeMessageService: composeMessageService,
-            contactsService: contactsService,
+            composeMessageService: self.composeMessageService,
+            contactsService: self.contactsService,
             cloudContactProvider: cloudContactProvider
         )
-        self.passPhraseService = passPhraseService
         self.router = router
         self.contextToSend.subject = input.subject
         self.contextToSend.attachments = input.attachments
+        self.clientConfiguration = clientConfiguration
         super.init(node: TableNode())
     }
 
@@ -354,7 +368,7 @@ extension ComposeViewController {
 
 extension ComposeViewController {
     private func prepareSigningKey() async throws -> PrvKeyInfo {
-        guard let signingKey = try await keyService.getSigningKey() else {
+        guard let signingKey = try await appContext.keyService.getSigningKey() else {
             throw AppErr.general("None of your private keys have your user id \"\(email)\". Please import the appropriate key.")
         }
 
@@ -396,15 +410,15 @@ extension ComposeViewController {
     private func handlePassPhraseEntry(_ passPhrase: String, for signingKey: PrvKeyInfo) async throws -> Bool {
         // since pass phrase was entered (an inconvenient thing for user to do),
         //  let's find all keys that match and save the pass phrase for all
-        let allKeys = try await self.keyService.getPrvKeyInfo()
+        let allKeys = try await appContext.keyService.getPrvKeyInfo()
         guard allKeys.isNotEmpty else {
             // tom - todo - nonsensical error type choice https://github.com/FlowCrypt/flowcrypt-ios/issues/859
             //   I copied it from another usage, but has to be changed
             throw KeyServiceError.retrieve
         }
         let matchingKeys = try await self.keyMethods.filterByPassPhraseMatch(keys: allKeys, passPhrase: passPhrase)
         // save passphrase for all matching keys
-        self.passPhraseService.savePassPhrasesInMemory(passPhrase, for: matchingKeys)
+        appContext.passPhraseService.savePassPhrasesInMemory(passPhrase, for: matchingKeys)
         // now figure out if the pass phrase also matched the signing prv itself
         let matched = matchingKeys.first(where: { $0.fingerprints.first == signingKey.fingerprints.first })
         return matched != nil// true if the pass phrase matched signing key
@@ -1110,7 +1124,7 @@ extension ComposeViewController {
 
         Task {
             do {
-                try await router.askForContactsPermission(for: .gmailLogin(self))
+                try await router.askForContactsPermission(appContext: appContext, for: .gmailLogin(self))
                 node.reloadSections([2], with: .automatic)
             } catch {
                 handleContactsPermissionError(error)