Added room timeline screen with live events listening and back pagination. Rearranged project files.

2026-11-04 01:20:12 +00:00 · 2022-03-08 14:24:33 +02:00
parent f403c59b95
commit c22d9689d4
77 changed files with 1269 additions and 491 deletions
@@ -0,0 +1,202 @@
+//
+//  AuthenticationCoordinator.swift
+//  ElementX
+//
+//  Created by Stefan Ceriu on 11.02.2022.
+//
+
+import Foundation
+import MatrixRustSDK
+
+enum AuthenticationCoordinatorError: Error {
+    case failedLoggingIn
+    case failedRestoringLogin
+    case failedSettingUpSession
+}
+
+protocol AuthenticationCoordinatorDelegate: AnyObject {
+    
+    func authenticationCoordinatorDidStartLoading(_ authenticationCoordinator: AuthenticationCoordinator)
+    
+    func authenticationCoordinatorDidSetupUserSession(_ authenticationCoordinator: AuthenticationCoordinator)
+    
+    func authenticationCoordinatorDidTearDownUserSession(_ authenticationCoordinator: AuthenticationCoordinator)
+    
+    func authenticationCoordinator(_ authenticationCoordinator: AuthenticationCoordinator,
+                                   didFailWithError error: AuthenticationCoordinatorError)
+}
+
+class AuthenticationCoordinator: Coordinator {
+    
+    private let keychainController: KeychainControllerProtocol
+    private let navigationRouter: NavigationRouter
+    
+    private(set) var userSession: UserSession?
+    var childCoordinators: [Coordinator] = []
+    
+    weak var delegate: AuthenticationCoordinatorDelegate?
+    
+    init(keychainController: KeychainControllerProtocol,
+         navigationRouter: NavigationRouter) {
+        self.keychainController =  keychainController
+        self.navigationRouter = navigationRouter
+    }
+    
+    func start() {
+        
+        let availableRestoreTokens = keychainController.restoreTokens()
+        
+        guard let usernameTokenTuple = availableRestoreTokens.first else {
+            startNewLoginFlow { result in
+                switch result {
+                case .success:
+                    self.delegate?.authenticationCoordinatorDidSetupUserSession(self)
+                case .failure(let error):
+                    self.delegate?.authenticationCoordinator(self, didFailWithError: error)
+                    MXLog.error("Failed logging in user with error: \(error)")
+                }
+            }
+            return
+        }
+        
+        restorePreviousLogin(usernameTokenTuple) { [weak self] result in
+            guard let self = self else { return }
+            
+            switch result {
+            case .success:
+                self.delegate?.authenticationCoordinatorDidSetupUserSession(self)
+            case .failure(let error):
+                self.delegate?.authenticationCoordinator(self, didFailWithError: error)
+                MXLog.error("Failed restoring login with error: \(error)")
+            }
+        }
+    }
+    
+    func logout() {
+        keychainController.removeAllTokens()
+        
+        if let userIdentifier = userSession?.userIdentifier {
+            deleteBaseDirectoryForUsername(userIdentifier)
+        }
+        
+        userSession = nil
+        
+        delegate?.authenticationCoordinatorDidTearDownUserSession(self)
+    }
+    
+    // MARK: - Private
+    
+    private func startNewLoginFlow(_ completion: @escaping (Result<(), AuthenticationCoordinatorError>) -> Void) {
+        let parameters = LoginScreenCoordinatorParameters()
+        let coordinator = LoginScreenCoordinator(parameters: parameters)
+        
+        coordinator.completion = { [weak self, weak coordinator] result in
+            guard let self = self, let coordinator = coordinator else {
+                return
+            }
+            
+            switch result {
+            case .login(let result):
+                self.login(username: result.username, password: result.password) { [weak self] result in
+                    guard let self = self else { return }
+                    
+                    switch result {
+                    case .success:
+                        completion(.success(()))
+                        self.remove(childCoordinator: coordinator)
+                        self.navigationRouter.dismissModule()
+                    case .failure(let error):
+                        completion(.failure(error))
+                    }
+                }
+            }
+        }
+        
+        add(childCoordinator: coordinator)
+        navigationRouter.present(coordinator)
+        
+        coordinator.start()
+    }
+    
+    private func login(username: String, password: String, completion: @escaping (Result<Void, AuthenticationCoordinatorError>) -> Void) {
+        
+        delegate?.authenticationCoordinatorDidStartLoading(self)
+        
+        DispatchQueue.global(qos: .background).async { [weak self] in
+            guard let self = self else { return }
+            
+            do {
+                self.setupUserSessionForClient(try loginNewClient(basePath: self.baseDirectoryPathForUsername(username),
+                                                                  username: username,
+                                                                  password: password))
+                
+                DispatchQueue.main.async {
+                    completion(.success(()))
+                }
+            } catch {
+                DispatchQueue.main.async {
+                    completion(.failure(.failedLoggingIn))
+                }
+            }
+        }
+    }
+    
+    private func restorePreviousLogin(_ usernameTokenTuple: (username: String, token: String), completion: @escaping (Result<Void, AuthenticationCoordinatorError>) -> Void) {
+        
+        delegate?.authenticationCoordinatorDidStartLoading(self)
+        
+        DispatchQueue.global(qos: .background).async { [weak self] in
+            guard let self = self else { return }
+            
+            do {
+                self.setupUserSessionForClient(try loginWithToken(basePath: self.baseDirectoryPathForUsername(usernameTokenTuple.username),
+                                                                  restoreToken: usernameTokenTuple.token))
+                
+                DispatchQueue.main.async {
+                    completion(.success(()))
+                }
+            } catch {
+                DispatchQueue.main.async {
+                    completion(.failure(.failedRestoringLogin))
+                }
+            }
+        }
+    }
+    
+    private func setupUserSessionForClient(_ client: Client) {
+        
+        do {
+            let restoreToken = try client.restoreToken()
+            let userId = try client.userId()
+            
+            keychainController.setRestoreToken(restoreToken, forUsername: userId)
+        } catch {
+            delegate?.authenticationCoordinator(self, didFailWithError: .failedSettingUpSession)
+            MXLog.error("Failed setting up user session with error: \(error)")
+        }
+        
+        userSession = UserSession(client: client)
+    }
+    
+    private func baseDirectoryPathForUsername(_ username: String) -> String {
+        guard var url = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else {
+            fatalError("Should always be able to retrieve the caches directory")
+        }
+        
+        url = url.appendingPathComponent(username)
+        
+        try? FileManager.default.createDirectory(at: url, withIntermediateDirectories: false, attributes: nil)
+        
+        return url.path
+    }
+    
+    private func deleteBaseDirectoryForUsername(_ username: String) {
+        guard var url = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else {
+            fatalError("Should always be able to retrieve the caches directory")
+        }
+        
+        url = url.appendingPathComponent(username)
+
+        try? FileManager.default.removeItem(at: url)
+    }
+}
@@ -0,0 +1,57 @@
+//
+//  KeychainController.swift
+//  ElementX
+//
+//  Created by Stefan Ceriu on 14.02.2022.
+//
+
+import Foundation
+import KeychainAccess
+
+class KeychainController: KeychainControllerProtocol {
+    
+    struct Constants {
+        static let restoreTokenGroupKey = "restoreTokens"
+    }
+    
+    private let keychain: Keychain
+    
+    init(identifier: String) {
+        keychain = Keychain(service: identifier)
+    }
+ 
+    func setRestoreToken(_ token: String, forUsername username: String) {
+        do {
+            try keychain.set(token, key: username)
+        } catch {
+            MXLog.error("Failed storing user restore token")
+        }
+    }
+    
+    func restoreTokenForUsername(_ username: String) -> String? {
+        do {
+            return try keychain.get(username)
+        } catch {
+            MXLog.error("Failed retrieving user restore token")
+            return nil
+        }
+    }
+    
+    func restoreTokens() -> [(username: String, token: String)] {
+        keychain.allKeys().compactMap { username in
+            guard let token = restoreTokenForUsername(username) else {
+                return nil
+            }
+            
+            return (username, token)
+        }
+    }
+    
+    func removeAllTokens() {
+        do {
+            try keychain.removeAll()
+        } catch {
+            MXLog.error("Failed removing all tokens")
+        }
+    }
+}
@@ -0,0 +1,15 @@
+//
+//  KeychainControllerProtocol.swift
+//  ElementX
+//
+//  Created by Stefan Ceriu on 14.02.2022.
+//
+
+import Foundation
+
+protocol KeychainControllerProtocol {
+    func setRestoreToken(_ token: String, forUsername username: String)
+    func restoreTokenForUsername(_ username: String) -> String?
+    func restoreTokens() -> [(username: String, token: String)]
+    func removeAllTokens()
+}
@@ -0,0 +1,119 @@
+//
+//  UserSession.swift
+//  ElementX
+//
+//  Created by Stefan Ceriu on 14.02.2022.
+//
+
+import Foundation
+import MatrixRustSDK
+import Combine
+import UIKit
+
+enum UserSessionCallback {
+    case updatedRoomsList
+}
+
+enum UserSessionError: Error {
+    case failedRetrievingAvatar
+}
+
+private class WeakUserSessionWrapper: ClientDelegate {
+    private weak var userSession: UserSession?
+    
+    init(userSession: UserSession) {
+        self.userSession = userSession
+    }
+    
+    func didReceiveSyncUpdate() {
+        DispatchQueue.main.async {
+            self.userSession?.didReceiveSyncUpdate()
+        }
+    }
+}
+
+class UserSession: ClientDelegate {
+    
+    private let client: Client
+    private var rooms: [RoomProxy] = [] {
+        didSet {
+            self.callbacks.send(.updatedRoomsList)
+        }
+    }
+    
+    deinit {
+        client.setDelegate(delegate: nil)
+    }
+    
+    let callbacks = PassthroughSubject<UserSessionCallback, Never>()
+    
+    init(client: Client) {
+        self.client = client
+        
+        client.setDelegate(delegate: WeakUserSessionWrapper(userSession: self))
+        client.startSync()
+    }
+    
+    var userIdentifier: String {
+        do {
+            return try client.userId()
+        } catch {
+            MXLog.error("Failed retrieving room info with error: \(error)")
+            return "Unknown user identifier"
+        }
+    }
+    
+    var userDisplayName: String? {
+        do {
+            return try client.displayName()
+        } catch {
+            MXLog.error("Failed retrieving room info with error: \(error)")
+            return nil
+        }
+    }
+    
+    func loadUserAvatar(_ completion: @escaping (Result<UIImage?, Error>) -> Void) {
+        DispatchQueue.global(qos: .background).async {
+            do {
+                let avatarData = try self.client.avatar()
+                DispatchQueue.main.async {
+                    completion(.success(UIImage(data: Data(bytes: avatarData, count: avatarData.count))))
+                }
+            } catch {
+                MXLog.error("Failed retrieving room name with error: \(error)")
+                DispatchQueue.main.async {
+                    completion(.failure(UserSessionError.failedRetrievingAvatar))
+                }
+            }
+        }
+    }
+    
+    func getRoomList(_ completion: @escaping ([RoomProxyProtocol]) -> Void) {
+        fetchRoomList(completion)
+    }
+    
+    // MARK: ClientDelegate
+    
+    func didReceiveSyncUpdate() {
+        fetchRoomList { [weak self] rooms in
+            guard let self = self else { return }
+            if self.rooms != rooms {
+                self.rooms = rooms
+            }
+        }
+    }
+    
+    // MARK: Private
+    
+    func fetchRoomList(_ completion: @escaping ([RoomProxy]) -> Void) {
+        DispatchQueue.global(qos: .background).async {
+            let rooms = self.client.conversations().map {
+                return RoomProxy(room: $0)
+            }
+            
+            DispatchQueue.main.async {
+                completion(rooms)
+            }
+        }
+    }
+}