Initial project setup.

ElementX/Sources/AppCoordinator.swift

@@ -0,0 +1,78 @@
+//
+//  AppCoordinator.swift
+//  ElementX
+//
+//  Created by Stefan Ceriu on 11.02.2022.
+//
+
+import UIKit
+
+class AppCoordinator: AuthenticationCoordinatorDelegate, Coordinator {
+    private let window: UIWindow
+    
+    private let mainNavigationController: UINavigationController
+    private let splashViewController: UIViewController
+    
+    private let navigationRouter: NavigationRouter
+    
+    private let keychainController: KeychainControllerProtocol
+    private let authenticationCoordinator: AuthenticationCoordinator!
+    
+    var childCoordinators: [Coordinator] = []
+    
+    init() {
+        splashViewController = SplashViewController()
+        mainNavigationController = UINavigationController(rootViewController: splashViewController)
+        mainNavigationController.setNavigationBarHidden(true, animated: false)
+        window = UIWindow(frame: UIScreen.main.bounds)
+        window.rootViewController = mainNavigationController
+        
+        navigationRouter = NavigationRouter(navigationController: mainNavigationController)
+        
+        guard let bundleIdentifier = Bundle.main.bundleIdentifier else {
+            fatalError("Should have a valid bundle identifier at this point")
+        }
+        
+        keychainController = KeychainController(identifier: bundleIdentifier)
+        authenticationCoordinator = AuthenticationCoordinator(keychainController: keychainController,
+                                                              navigationRouter: navigationRouter)
+        authenticationCoordinator.delegate = self
+    }
+    
+    func start() {
+        window.makeKeyAndVisible()
+        authenticationCoordinator.start()
+    }
+    
+    // MARK: - AuthenticationCoordinatorDelegate
+    
+    func authenticationCoordinator(_ authenticationCoordinator: AuthenticationCoordinator, didFailWithError error: AuthenticationCoordinatorError) {
+        
+    }
+    
+    func authenticationCoordinatorDidSetupUserSession(_ authenticationCoordinator: AuthenticationCoordinator) {
+        presentHomeScreen()
+    }
+    
+    func authenticationCoordinatorDidTearDownUserSession(_ authenticationCoordinator: AuthenticationCoordinator) {
+        
+    }
+    
+    // MARK: - Private
+    
+    private func presentHomeScreen() {
+        guard let userSession = authenticationCoordinator.userSession else {
+            fatalError("User session should be already setup at this point")
+        }
+        
+        let parameters = HomeScreenCoordinatorParameters(userSession: userSession)
+        let coordinator = HomeScreenCoordinator(parameters: parameters)
+        
+        add(childCoordinator: coordinator)
+        navigationRouter.setRootModule(coordinator)
+    }
+    
+    private func restart() {
+        
+    }
+}

ElementX/Sources/AppDelegate.swift

@@ -0,0 +1,20 @@
+//
+//  AppDelegate.swift
+//  ElementX
+//
+//  Created by Stefan Ceriu on 11.02.2022.
+//
+
+import UIKit
+
+@main
+class AppDelegate: UIResponder, UIApplicationDelegate {
+    
+    private var appCoordinator: AppCoordinator!
+    
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
+        appCoordinator = AppCoordinator()
+        appCoordinator.start()
+        return true
+    }
+}

ElementX/Sources/Modules/Authentication/AuthenticationCoordinator.swift

@@ -0,0 +1,123 @@
+//
+//  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 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()
+            return
+        }
+        
+        restorePreviousLogin(usernameTokenTuple)
+    }
+    
+    // MARK: - Private
+    
+    private func startNewLoginFlow() {
+        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):
+                do {
+                    self.setupUserSessionForClient(try loginNewClient(basePath: self.baseDirectoryPathForUsername(result.username),
+                                                                      username: result.username,
+                                                                      password: result.password))
+                    
+                    self.remove(childCoordinator: coordinator)
+                    self.navigationRouter.dismissModule()
+                } catch {
+                    self.delegate?.authenticationCoordinator(self, didFailWithError: .failedLoggingIn)
+                    MXLog.error("Failed logging in user with error: \(error)")
+                }
+            }
+        }
+        
+        add(childCoordinator: coordinator)
+        navigationRouter.present(coordinator)
+        
+        coordinator.start()
+    }
+    
+    private func restorePreviousLogin(_ usernameTokenTuple: (username: String, token: String)) {
+        do {
+            setupUserSessionForClient(try loginWithToken(basePath: baseDirectoryPathForUsername(usernameTokenTuple.username),
+                                                         restoreToken: usernameTokenTuple.token))
+        } catch {
+            delegate?.authenticationCoordinator(self, didFailWithError: .failedRestoringLogin)
+            MXLog.error("Failed restoring login with error: \(error)")
+        }
+    }
+    
+    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)
+        delegate?.authenticationCoordinatorDidSetupUserSession(self)
+    }
+    
+    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
+    }
+}

ElementX/Sources/Modules/Authentication/KeychainController.swift

@@ -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")
+        }
+    }
+}

ElementX/Sources/Modules/Authentication/KeychainControllerProtocol.swift

@@ -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()
+}

ElementX/Sources/Modules/Authentication/LoginScreen/LoginScreenCoordinator.swift

@@ -0,0 +1,66 @@
+//
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import SwiftUI
+
+struct LoginScreenCoordinatorParameters {
+    
+}
+
+final class LoginScreenCoordinator: Coordinator, Presentable {
+    
+    // MARK: - Properties
+    
+    // MARK: Private
+    
+    private let parameters: LoginScreenCoordinatorParameters
+    private let loginScreenHostingController: UIViewController
+    private var loginScreenViewModel: LoginScreenViewModelProtocol
+    
+    // MARK: Public
+
+    // Must be used only internally
+    var childCoordinators: [Coordinator] = []
+    var completion: ((LoginScreenViewModelResult) -> Void)?
+    
+    // MARK: - Setup
+    
+    @available(iOS 14.0, *)
+    init(parameters: LoginScreenCoordinatorParameters) {
+        self.parameters = parameters
+        
+        loginScreenViewModel = LoginScreenViewModel()
+        let view = LoginScreen(context: loginScreenViewModel.context)
+        
+        loginScreenHostingController = UIHostingController(rootView: view)
+        loginScreenHostingController.isModalInPresentation = true
+        
+        loginScreenViewModel.completion = { [weak self] result in
+            MXLog.debug("[LoginScreenCoordinator] LoginScreenViewModel did complete with result: \(result).")
+            guard let self = self else { return }
+            self.completion?(result)
+        }
+    }
+    
+    // MARK: - Public
+    func start() {
+        
+    }
+    
+    func toPresentable() -> UIViewController {
+        return self.loginScreenHostingController
+    }
+}

ElementX/Sources/Modules/Authentication/LoginScreen/LoginScreenModels.swift

@@ -0,0 +1,44 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+enum LoginScreenViewModelResult {
+    case login((username: String, password: String))
+}
+
+enum LoginScreenViewAction {
+    case login
+}
+
+struct LoginScreenViewState: BindableState {
+    var bindings: LoginScreenViewStateBindings
+}
+
+struct LoginScreenViewStateBindings {
+    var username: String
+    var password: String
+}
+
+struct LoginScreenErrorAlertInfo: Identifiable {
+    enum AlertType {
+        case genericFailure
+    }
+    
+    let id: AlertType
+    let title: String
+    let subtitle: String
+}

ElementX/Sources/Modules/Authentication/LoginScreen/LoginScreenViewModel.swift

@@ -0,0 +1,49 @@
+//
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import SwiftUI
+
+@available(iOS 14, *)
+typealias LoginScreenViewModelType = StateStoreViewModel<LoginScreenViewState,
+                                                         Never,
+                                                         LoginScreenViewAction>
+@available(iOS 14, *)
+class LoginScreenViewModel: LoginScreenViewModelType, LoginScreenViewModelProtocol {
+
+    // MARK: - Properties
+
+    // MARK: Private
+
+    // MARK: Public
+
+    var completion: ((LoginScreenViewModelResult) -> Void)?
+
+    // MARK: - Setup
+
+    init() {
+        super.init(initialViewState: LoginScreenViewState(bindings: LoginScreenViewStateBindings(username: "@stefan.ceriu-element01:matrix.org",
+                                                                                                 password: "radeon")))
+    }
+
+    // MARK: - Public
+
+    override func process(viewAction: LoginScreenViewAction) {
+        switch viewAction {
+        case .login:
+            completion?(.login((username: context.username, password: context.password)))
+        }
+    }
+}

ElementX/Sources/Modules/Authentication/LoginScreen/LoginScreenViewModelProtocol.swift

@@ -0,0 +1,24 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+protocol LoginScreenViewModelProtocol {
+    
+    var completion: ((LoginScreenViewModelResult) -> Void)? { get set }
+    @available(iOS 14, *)
+    var context: LoginScreenViewModelType.Context { get }
+}

ElementX/Sources/Modules/Authentication/LoginScreen/Test/UI/LoginScreenUITests.swift

@@ -0,0 +1,45 @@
+//
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import XCTest
+import RiotSwiftUI
+
+@available(iOS 14.0, *)
+class LoginScreenUITests: MockScreenTest {
+
+    override class var screenType: MockScreenState.Type {
+        return MockLoginScreenScreenState.self
+    }
+
+    override class func createTest() -> MockScreenTest {
+        return LoginScreenUITests(selector: #selector(verifyLoginScreenScreen))
+    }
+
+    func verifyLoginScreenScreen() throws {
+        guard let screenState = screenState as? MockLoginScreenScreenState else { fatalError("no screen") }
+        switch screenState {
+        case .promptType(let promptType):
+            verifyLoginScreenPromptType(promptType: promptType)
+        }
+    }
+    
+    func verifyLoginScreenPromptType(promptType: LoginScreenPromptType) {
+        let title = app.staticTexts["title"]
+        XCTAssert(title.exists)
+        XCTAssertEqual(title.label, promptType.title)
+    }
+
+}

ElementX/Sources/Modules/Authentication/LoginScreen/Test/Unit/LoginScreenViewModelTests.swift

@@ -0,0 +1,31 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import XCTest
+
+@testable import ElementX
+
+@available(iOS 14.0, *)
+class LoginScreenViewModelTests: XCTestCase {
+    
+    override func setUpWithError() throws {
+        
+    }
+
+    func testInitialState() {
+        
+    }
+}

ElementX/Sources/Modules/Authentication/LoginScreen/View/LoginScreen.swift

@@ -0,0 +1,52 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import SwiftUI
+
+@available(iOS 14.0, *)
+struct LoginScreen: View {
+    
+    @ObservedObject var context: LoginScreenViewModel.Context
+    
+    var body: some View {
+        NavigationView {
+            VStack {
+                TextField("Username", text: $context.username)
+                    .textFieldStyle(.roundedBorder)
+                SecureField("Enter a password", text: $context.password)
+                    .textFieldStyle(.roundedBorder)
+                
+                Button { context.send(viewAction: .login) } label: {
+                    Text("Login")
+                }
+                .buttonStyle(.borderedProminent)
+                .padding(.horizontal, 50)
+            }
+            .padding(.horizontal, 8.0)
+            .navigationTitle("Login")
+            .navigationBarTitleDisplayMode(.inline)
+        }
+    }
+}
+
+// MARK: - Previews
+
+struct LoginScreen_Previews: PreviewProvider {
+    static var previews: some View {
+        let viewModel = LoginScreenViewModel()
+        LoginScreen(context: viewModel.context)
+    }
+}

ElementX/Sources/Modules/Authentication/UserSession.swift

@@ -0,0 +1,44 @@
+//
+//  UserSession.swift
+//  ElementX
+//
+//  Created by Stefan Ceriu on 14.02.2022.
+//
+
+import Foundation
+import MatrixRustSDK
+
+class UserSession {
+    
+    private let client: Client
+    
+    init(client: Client) {
+        self.client = client
+        
+        if !client.hasFirstSynced() {
+            MXLog.info("Started initial sync")
+            client.startSync()
+            MXLog.info("Finished intial sync")
+        }
+    }
+    
+    func roomList() -> [RoomModel] {
+        client.conversations().compactMap { room in
+            do {
+                return RoomModel(displayName: try room.displayName())
+            } catch {
+                MXLog.error("Failed retrieving room info with error: \(error)")
+                return nil
+            }
+        }
+    }
+    
+    var displayName: String? {
+        do {
+            return try client.displayName()
+        } catch {
+            MXLog.error("Failed retrieving room info with error: \(error)")
+            return nil
+        }
+    }
+}

ElementX/Sources/Modules/HomeScreen/HomeScreenCoordinator.swift

@@ -0,0 +1,64 @@
+//
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import SwiftUI
+
+struct HomeScreenCoordinatorParameters {
+    let userSession: UserSession
+}
+
+final class HomeScreenCoordinator: Coordinator, Presentable {
+    
+    // MARK: - Properties
+    
+    // MARK: Private
+    
+    private let parameters: HomeScreenCoordinatorParameters
+    private let homeScreenHostingController: UIViewController
+    private var homeScreenViewModel: HomeScreenViewModelProtocol
+    
+    // MARK: Public
+
+    // Must be used only internally
+    var childCoordinators: [Coordinator] = []
+    var completion: ((HomeScreenViewModelResult) -> Void)?
+    
+    // MARK: - Setup
+    
+    @available(iOS 14.0, *)
+    init(parameters: HomeScreenCoordinatorParameters) {
+        self.parameters = parameters
+        
+        let viewModel = HomeScreenViewModel(username: self.parameters.userSession.displayName ?? "💥")
+        let view = HomeScreen(context: viewModel.context)
+        homeScreenViewModel = viewModel
+        homeScreenHostingController = UIHostingController(rootView: view)
+        
+        homeScreenViewModel.completion = { [weak self] result in
+            guard let self = self else { return }
+            self.completion?(result)
+        }
+    }
+    
+    // MARK: - Public
+    func start() {
+        
+    }
+    
+    func toPresentable() -> UIViewController {
+        return self.homeScreenHostingController
+    }
+}

ElementX/Sources/Modules/HomeScreen/HomeScreenModels.swift

@@ -0,0 +1,31 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+enum HomeScreenViewModelResult {
+    case logout
+}
+
+// MARK: View
+
+struct HomeScreenViewState: BindableState {
+    let username: String
+}
+
+enum HomeScreenViewAction {
+    case logout
+}

ElementX/Sources/Modules/HomeScreen/HomeScreenViewModel.swift

@@ -0,0 +1,45 @@
+//
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import SwiftUI
+
+@available(iOS 14, *)
+typealias HomeScreenViewModelType = StateStoreViewModel<HomeScreenViewState,
+                                                                  Never,
+                                                                  HomeScreenViewAction>
+@available(iOS 14, *)
+class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol {
+
+    // MARK: - Properties
+
+    // MARK: Private
+
+    // MARK: Public
+
+    var completion: ((HomeScreenViewModelResult) -> Void)?
+
+    // MARK: - Setup
+
+    init(username: String) {
+        super.init(initialViewState: HomeScreenViewState(username: username))
+    }
+
+    // MARK: - Public
+
+    override func process(viewAction: HomeScreenViewAction) {
+        
+    }
+}

ElementX/Sources/Modules/HomeScreen/HomeScreenViewModelProtocol.swift

@@ -0,0 +1,24 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+protocol HomeScreenViewModelProtocol {
+    
+    var completion: ((HomeScreenViewModelResult) -> Void)? { get set }
+    @available(iOS 14, *)
+    var context: HomeScreenViewModelType.Context { get }
+}

ElementX/Sources/Modules/HomeScreen/Test/UI/HomeScreenUITests.swift

@@ -0,0 +1,45 @@
+//
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import XCTest
+import ElementX
+
+@available(iOS 14.0, *)
+class HomeScreenUITests: MockScreenTest {
+
+    override class var screenType: MockScreenState.Type {
+        return MockHomeScreenScreenState.self
+    }
+
+    override class func createTest() -> MockScreenTest {
+        return HomeScreenUITests(selector: #selector(verifyHomeScreenScreen))
+    }
+
+    func verifyHomeScreenScreen() throws {
+        guard let screenState = screenState as? MockHomeScreenScreenState else { fatalError("no screen") }
+        switch screenState {
+        case .promptType(let promptType):
+            verifyHomeScreenPromptType(promptType: promptType)
+        }
+    }
+    
+    func verifyHomeScreenPromptType(promptType: HomeScreenPromptType) {
+        let title = app.staticTexts["title"]
+        XCTAssert(title.exists)
+        XCTAssertEqual(title.label, promptType.title)
+    }
+
+}

ElementX/Sources/Modules/HomeScreen/Test/Unit/HomeScreenViewModelTests.swift

@@ -0,0 +1,30 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import XCTest
+
+@testable import ElementX
+
+@available(iOS 14.0, *)
+class HomeScreenViewModelTests: XCTestCase {
+    override func setUpWithError() throws {
+
+    }
+
+    func testInitialState() {
+
+    }
+}

ElementX/Sources/Modules/HomeScreen/View/HomeScreen.swift

@@ -0,0 +1,41 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import SwiftUI
+
+@available(iOS 14.0, *)
+struct HomeScreen: View {
+    
+    @ObservedObject var context: HomeScreenViewModel.Context
+    
+    // MARK: Views
+    
+    var body: some View {
+        VStack {
+            Text("Hello, \(context.viewState.username)!")
+        }
+    }
+}
+
+// MARK: - Previews
+
+@available(iOS 14.0, *)
+struct HomeScreen_Previews: PreviewProvider {
+    static var previews: some View {
+        let viewModel = HomeScreenViewModel(username: "Johnny Appleseed")
+        HomeScreen(context: viewModel.context)
+    }
+}

ElementX/Sources/Modules/Models/RoomModel.swift

@@ -0,0 +1,13 @@
+//
+//  RoomModel.swift
+//  ElementX
+//
+//  Created by Stefan Ceriu on 14.02.2022.
+//
+
+import Foundation
+import UIKit
+
+struct RoomModel {
+    let displayName: String
+}

ElementX/Sources/Modules/Other/Coordinator.swift

@@ -0,0 +1,51 @@
+/*
+ Copyright 2019 New Vector Ltd
+ 
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import UIKit
+
+/// Protocol describing a [Coordinator](http://khanlou.com/2015/10/coordinators-redux/).
+/// Coordinators are the objects which control the navigation flow of the application.
+/// It helps to isolate and reuse view controllers and pass dependencies down the navigation hierarchy.
+protocol Coordinator: AnyObject {
+    
+    /// Starts job of the coordinator.
+    func start()
+    
+    /// Child coordinators to retain. Prevent them from getting deallocated.
+    var childCoordinators: [Coordinator] { get set }
+    
+    /// Stores coordinator to the `childCoordinators` array.
+    ///
+    /// - Parameter childCoordinator: Child coordinator to store.
+    func add(childCoordinator: Coordinator)
+    
+    /// Remove coordinator from the `childCoordinators` array.
+    ///
+    /// - Parameter childCoordinator: Child coordinator to remove.
+    func remove(childCoordinator: Coordinator)
+}
+
+// `Coordinator` default implementation
+extension Coordinator {
+    
+    func add(childCoordinator coordinator: Coordinator) {
+        childCoordinators.append(coordinator)
+    }
+    
+    func remove(childCoordinator: Coordinator) {
+        self.childCoordinators = self.childCoordinators.filter { $0 !== childCoordinator }
+    }
+}

ElementX/Sources/Modules/Other/MXLog.swift

@@ -0,0 +1,179 @@
+//
+// Copyright 2021 The Matrix.org Foundation C.I.C
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+import SwiftyBeaver
+
+/// Various MXLog configuration options. Used in conjunction with `MXLog.configure()`
+@objc public class MXLogConfiguration: NSObject {
+    
+    /// the desired log level. `.verbose` by default.
+    @objc public var logLevel: MXLogLevel = MXLogLevel.verbose
+    
+    /// whether logs should be written directly to files. `false` by default.
+    @objc public var redirectLogsToFiles: Bool = false
+    
+    /// the maximum total space to use for log files in bytes. `100MB` by default.
+    @objc public var logFilesSizeLimit: UInt = 100 * 1024 * 1024 // 100MB
+    
+    /// the maximum number of log files to use before rolling. `50` by default.
+    @objc public var maxLogFilesCount: UInt = 50
+    
+    /// the subname for log files. Files will be named as 'console-[subLogName].log'. `nil` by default
+    @objc public var subLogName: String?
+}
+
+/// MXLog logging levels. Use .none to disable logging entirely.
+@objc public enum MXLogLevel: UInt {
+    case none
+    case verbose
+    case debug
+    case info
+    case warning
+    case error
+}
+
+private var logger: SwiftyBeaver.Type = {
+    let logger = SwiftyBeaver.self
+    MXLog.configureLogger(logger, withConfiguration: MXLogConfiguration())
+    return logger
+}()
+
+/**
+ Logging utility that provies multiple logging levels as well as file output and rolling.
+ Its purpose is to provide a common entry for customizing logging and should be used throughout the code.
+ Please see `MXLog.h` for Objective-C options.
+ */
+@objc public class MXLog: NSObject {
+    
+    /// Method used to customize MXLog's behavior.
+    /// Called automatically when first accessing the logger with the default values.
+    /// Please see `MXLogConfiguration` for all available options.
+    /// - Parameters:
+    ///     - configuration: the `MXLogConfiguration` instance to use
+    @objc static public func configure(_ configuration: MXLogConfiguration) {
+        configureLogger(logger, withConfiguration: configuration)
+    }
+    
+    public static func verbose(_ message: @autoclosure () -> Any,
+                               _ file: String = #file,
+                               _ function: String = #function,
+                               line: Int = #line,
+                               context: Any? = nil) {
+        logger.verbose(message(), file, function, line: line, context: context)
+    }
+    
+    @available(swift, obsoleted: 5.4)
+    @objc public static func logVerbose(_ message: String, file: String, function: String, line: Int) {
+        logger.verbose(message, file, function, line: line)
+    }
+    
+    public static func debug(_ message: @autoclosure () -> Any,
+                             _ file: String = #file,
+                             _ function: String = #function,
+                             line: Int = #line,
+                             context: Any? = nil) {
+        logger.debug(message(), file, function, line: line, context: context)
+    }
+    
+    @available(swift, obsoleted: 5.4)
+    @objc public static func logDebug(_ message: String, file: String, function: String, line: Int) {
+        logger.debug(message, file, function, line: line)
+    }
+    
+    public static func info(_ message: @autoclosure () -> Any,
+                            _ file: String = #file,
+                            _ function: String = #function,
+                            line: Int = #line,
+                            context: Any? = nil) {
+        logger.info(message(), file, function, line: line, context: context)
+    }
+    
+    @available(swift, obsoleted: 5.4)
+    @objc public static func logInfo(_ message: String, file: String, function: String, line: Int) {
+        logger.info(message, file, function, line: line)
+    }
+    
+    public static func warning(_ message: @autoclosure () -> Any, _
+                                file: String = #file,
+                               _ function: String = #function,
+                               line: Int = #line,
+                               context: Any? = nil) {
+        logger.warning(message(), file, function, line: line, context: context)
+    }
+    
+    @available(swift, obsoleted: 5.4)
+    @objc public static func logWarning(_ message: String, file: String, function: String, line: Int) {
+        logger.warning(message, file, function, line: line)
+    }
+    
+    public static func error(_ message: @autoclosure () -> Any,
+                             _ file: String = #file,
+                             _ function: String = #function,
+                             line: Int = #line,
+                             context: Any? = nil) {
+        logger.error(message(), file, function, line: line, context: context)
+    }
+    
+    @available(swift, obsoleted: 5.4)
+    @objc public static func logError(_ message: String, file: String, function: String, line: Int) {
+        logger.error(message, file, function, line: line)
+    }
+    
+    // MARK: - Private
+    
+    fileprivate static func configureLogger(_ logger: SwiftyBeaver.Type, withConfiguration configuration: MXLogConfiguration) {
+//        if let subLogName = configuration.subLogName {
+//            MXLogger.setSubLogName(subLogName)
+//        }
+//
+//        MXLogger.redirectNSLog(toFiles: configuration.redirectLogsToFiles,
+//                               numberOfFiles: configuration.maxLogFilesCount,
+//                               sizeLimit: configuration.logFilesSizeLimit)
+//
+        guard configuration.logLevel != .none else {
+            return
+        }
+        
+        let consoleDestination = ConsoleDestination()
+        consoleDestination.useNSLog = true
+        consoleDestination.asynchronously = false
+        consoleDestination.format = "$C $N.$F():$l $M"
+        consoleDestination.levelColor.verbose = ""
+        consoleDestination.levelColor.debug = ""
+        consoleDestination.levelColor.info = ""
+        consoleDestination.levelColor.warning = "⚠️"
+        consoleDestination.levelColor.error = "🚨"
+        
+        switch configuration.logLevel {
+        case .verbose:
+            consoleDestination.minLevel = .verbose
+        case .debug:
+            consoleDestination.minLevel = .debug
+        case .info:
+            consoleDestination.minLevel = .info
+        case .warning:
+            consoleDestination.minLevel = .warning
+        case .error:
+            consoleDestination.minLevel = .error
+        case .none:
+            break
+        }
+        
+        logger.removeAllDestinations()
+        logger.addDestination(consoleDestination)
+    }
+}

ElementX/Sources/Modules/Other/SwiftUI/ViewModel/BindableState.swift

@@ -0,0 +1,37 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+/// Represents a specific portion of the ViewState that can be bound to with SwiftUI's [2-way binding](https://developer.apple.com/documentation/swiftui/binding).
+protocol BindableState {
+    /// The associated type of the Bindable State. Defaults to Void.
+    associatedtype BindStateType = Void
+    var bindings: BindStateType { get set }
+}
+
+extension BindableState where BindStateType == Void {
+    /// We provide a default implementation for the Void type so that we can have `ViewState` that
+    /// just doesn't include/take advantage of the bindings.
+    var bindings: Void {
+        get {
+            
+        }
+        set {
+            fatalError("Can't bind to the default Void binding.")
+        }
+    }
+}

ElementX/Sources/Modules/Other/SwiftUI/ViewModel/StateStoreViewModel.swift

@@ -0,0 +1,140 @@
+//
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+import Combine
+
+/// A constrained and concise interface for interacting with the ViewModel.
+///
+/// This class is closely bound to`StateStoreViewModel`. It provides the exact interface the view should need to interact
+/// ViewModel (as modelled on our previous template architecture with the addition of two-way binding):
+/// - The ability read/observe view state
+/// - The ability to send view events
+/// - The ability to bind state to a specific portion of the view state safely.
+/// This class was brought about a little bit by necessity. The most idiomatic way of interacting with SwiftUI is via `@Published`
+/// properties which which are property wrappers and therefore can't be defined within protocols.
+/// A similar approach is taken in libraries like [CombineFeedback](https://github.com/sergdort/CombineFeedback).
+/// It provides a nice layer of consistency and also safety. As we are not passing the `ViewModel` to the view directly, shortcuts/hacks
+/// can't be made into the `ViewModel`.
+@available(iOS 14, *)
+@dynamicMemberLookup
+class ViewModelContext<ViewState: BindableState, ViewAction>: ObservableObject {
+    // MARK: - Properties
+
+    // MARK: Private
+
+    fileprivate let viewActions: PassthroughSubject<ViewAction, Never>
+
+    // MARK: Public
+
+    /// Get-able/Observable `Published` property for the `ViewState`
+    @Published fileprivate(set) var viewState: ViewState
+
+    /// Set-able/Bindable access to the bindable state.
+    subscript<T>(dynamicMember keyPath: WritableKeyPath<ViewState.BindStateType, T>) -> T {
+        get { viewState.bindings[keyPath: keyPath] }
+        set { viewState.bindings[keyPath: keyPath] = newValue }
+    }
+    
+    // MARK: Setup
+
+    init(initialViewState: ViewState) {
+        self.viewActions = PassthroughSubject()
+        self.viewState = initialViewState
+    }
+
+    // MARK: Public
+
+    /// Send a `ViewAction` to the `ViewModel` for processing.
+    /// - Parameter viewAction: The `ViewAction` to send to the `ViewModel`.
+    func send(viewAction: ViewAction) {
+        viewActions.send(viewAction)
+    }
+}
+
+/// A common ViewModel implementation for handling of `State`, `StateAction`s and `ViewAction`s
+///
+/// Generic type State is constrained to the BindableState protocol in that it may contain (but doesn't have to)
+/// a specific portion of state that can be safely bound to.
+/// If we decide to add more features to our state management (like doing state processing off the main thread)
+/// we can do it in this centralised place.
+@available(iOS 14, *)
+class StateStoreViewModel<State: BindableState, StateAction, ViewAction> {
+
+    typealias Context = ViewModelContext<State, ViewAction>
+
+    // MARK: - Properties
+
+    // MARK: Public
+    
+    /// For storing subscription references.
+    ///
+    /// Left as public for `ViewModel` implementations convenience.
+    var cancellables = Set<AnyCancellable>()
+
+    /// Constrained interface for passing to Views.
+    var context: Context
+    
+    var state: State {
+        get { context.viewState }
+        set { context.viewState = newValue }
+    }
+    
+    // MARK: Setup
+
+    init(initialViewState: State) {
+        self.context = Context(initialViewState: initialViewState)
+        self.context.viewActions.sink { [weak self] action in
+            guard let self = self else { return }
+            self.process(viewAction: action)
+        }
+        .store(in: &cancellables)
+    }
+
+    /// Send state actions to modify the state within the reducer.
+    /// - Parameter action: The state action to send to the reducer.
+    @available(*, deprecated, message: "Mutate state directly instead")
+    func dispatch(action: StateAction) {
+        Self.reducer(state: &context.viewState, action: action)
+    }
+
+    /// Send state actions from a publisher to modify the state within the reducer.
+    /// - Parameter actionPublisher: The publisher that produces actions to be sent to the reducer
+    @available(*, deprecated, message: "Mutate state directly instead")
+    func dispatch(actionPublisher: AnyPublisher<StateAction, Never>) {
+        actionPublisher.sink { [weak self] action in
+            guard let self = self else { return }
+            Self.reducer(state: &self.context.viewState, action: action)
+        }
+        .store(in: &cancellables)
+    }
+
+    /// Override to handle mutations to the `State`
+    ///
+    /// A redux style reducer, all modifications to state happen here.
+    /// - Parameters:
+    ///   - state: The `inout` state to be modified,
+    ///   - action: The action that defines which state modification should take place.
+    class func reducer(state: inout State, action: StateAction) {
+        // Default implementation, -no-op
+    }
+
+    /// Override to handles incoming `ViewAction`s from the `ViewModel`.
+    /// - Parameter viewAction: The `ViewAction` to be processed in `ViewModel` implementation.
+    func process(viewAction: ViewAction) {
+        // Default implementation, -no-op
+    }
+}

ElementX/Sources/Modules/Other/WeakDictionary/WeakDictionary.swift

@@ -0,0 +1,104 @@
+//
+//  WeakDictionary.swift
+//  WeakDictionary
+//
+//  Created by Nicholas Cross on 19/10/2016.
+//  Copyright © 2016 Nicholas Cross. All rights reserved.
+//
+
+import Foundation
+
+public struct WeakDictionary<Key: Hashable, Value: AnyObject> {
+
+    private var storage: [Key: WeakDictionaryReference<Value>]
+
+    public init() {
+        self.init(storage: [Key: WeakDictionaryReference<Value>]())
+    }
+
+    public init(dictionary: [Key: Value]) {
+        var newStorage = [Key: WeakDictionaryReference<Value>]()
+        dictionary.forEach({ key, value in newStorage[key] = WeakDictionaryReference<Value>(value: value) })
+        self.init(storage: newStorage)
+    }
+
+    private init(storage: [Key: WeakDictionaryReference<Value>]) {
+        self.storage = storage
+    }
+
+    public mutating func reap() {
+        storage = weakDictionary().storage
+    }
+
+    public func weakDictionary() -> WeakDictionary<Key, Value> {
+        return self[startIndex ..< endIndex]
+    }
+
+    public func dictionary() -> [Key: Value] {
+        var newStorage = [Key: Value]()
+
+        storage.forEach { key, value in
+            if let retainedValue = value.value {
+                newStorage[key] = retainedValue
+            }
+        }
+
+        return newStorage
+    }
+}
+
+extension WeakDictionary: Collection {
+
+    public typealias Index = DictionaryIndex<Key, WeakDictionaryReference<Value>>
+
+    public var startIndex: Index {
+        return storage.startIndex
+    }
+
+    public var endIndex: Index {
+        return storage.endIndex
+    }
+
+    public func index(after index: Index) -> Index {
+        return storage.index(after: index)
+    }
+
+    public subscript(position: Index) -> (Key, WeakDictionaryReference<Value>) {
+        return storage[position]
+    }
+
+    public subscript(key: Key) -> Value? {
+        get {
+            guard let valueRef = storage[key] else {
+                return nil
+            }
+
+            return valueRef.value
+        }
+
+        set {
+            guard let value = newValue else {
+                storage[key] = nil
+                return
+            }
+
+            storage[key] = WeakDictionaryReference<Value>(value: value)
+        }
+    }
+
+    public subscript(bounds: Range<Index>) -> WeakDictionary<Key, Value> {
+        let subStorage = storage[bounds.lowerBound ..< bounds.upperBound]
+        var newStorage = [Key: WeakDictionaryReference<Value>]()
+
+        subStorage.filter { _, value in return value.value != nil }
+            .forEach { key, value in newStorage[key] = value }
+
+        return WeakDictionary<Key, Value>(storage: newStorage)
+    }
+}
+
+extension Dictionary where Value: AnyObject {
+    public func weakDictionary() -> WeakDictionary<Key, Value> {
+        return WeakDictionary<Key, Value>(dictionary: self)
+    }
+}

ElementX/Sources/Modules/Other/WeakDictionary/WeakDictionaryKeyReference.swift

@@ -0,0 +1,36 @@
+//
+//  WeakDictionaryKeyReference.swift
+//  WeakDictionary-iOS
+//
+//  Created by Nicholas Cross on 2/1/19.
+//  Copyright © 2019 Nicholas Cross. All rights reserved.
+//
+
+import Foundation
+
+public struct WeakDictionaryKey<Key: AnyObject & Hashable, Value: AnyObject> : Hashable {
+
+    private weak var baseKey: Key?
+    private let hash: Int
+    private var retainedValue: Value?
+    private let nilKeyHash = UUID().hashValue
+
+    public init(key: Key, value: Value? = nil) {
+        baseKey = key
+        retainedValue = value
+        hash = key.hashValue
+    }
+
+    public static func == (lhs: WeakDictionaryKey, rhs: WeakDictionaryKey) -> Bool {
+        return (lhs.baseKey != nil && rhs.baseKey != nil && lhs.baseKey == rhs.baseKey)
+            || lhs.hashValue == rhs.hashValue
+    }
+
+    public var hashValue: Int {
+        return baseKey != nil ? hash : nilKeyHash
+    }
+
+    public var key: Key? {
+        return baseKey
+    }
+}

ElementX/Sources/Modules/Other/WeakDictionary/WeakDictionaryReference.swift

@@ -0,0 +1,21 @@
+//
+//  WeakDictionaryReference.swift
+//  WeakDictionary-iOS
+//
+//  Created by Nicholas Cross on 2/1/19.
+//  Copyright © 2019 Nicholas Cross. All rights reserved.
+//
+
+import Foundation
+
+public struct WeakDictionaryReference<Value: AnyObject> {
+    private weak var referencedValue: Value?
+
+    init(value: Value) {
+        referencedValue = value
+    }
+
+    public var value: Value? {
+        return referencedValue
+    }
+}

ElementX/Sources/Modules/Other/WeakDictionary/WeakKeyDictionary.swift

@@ -0,0 +1,124 @@
+//
+//  WeakKeyDictionary.swift
+//  WeakDictionary-iOS
+//
+//  Created by Nicholas Cross on 2/1/19.
+//  Copyright © 2019 Nicholas Cross. All rights reserved.
+//
+
+import Foundation
+
+public struct WeakKeyDictionary<Key: AnyObject & Hashable, Value: AnyObject> {
+
+    private var storage: WeakDictionary<WeakDictionaryKey<Key, Value>, Value>
+    private let valuesRetainedByKey: Bool
+
+    public init(valuesRetainedByKey: Bool = false) {
+        self.init(
+            storage: WeakDictionary<WeakDictionaryKey<Key, Value>, Value>(),
+            valuesRetainedByKey: valuesRetainedByKey
+        )
+    }
+
+    public init(dictionary: [Key: Value], valuesRetainedByKey: Bool = false) {
+        var newStorage = WeakDictionary<WeakDictionaryKey<Key, Value>, Value>()
+
+        dictionary.forEach { key, value in
+            var keyRef: WeakDictionaryKey<Key, Value>!
+
+            if valuesRetainedByKey {
+                keyRef = WeakDictionaryKey<Key, Value>(key: key, value: value)
+            } else {
+                keyRef = WeakDictionaryKey<Key, Value>(key: key)
+            }
+
+            newStorage[keyRef] = value
+        }
+
+        self.init(storage: newStorage, valuesRetainedByKey: valuesRetainedByKey)
+    }
+
+    private init(storage: WeakDictionary<WeakDictionaryKey<Key, Value>, Value>, valuesRetainedByKey: Bool = false) {
+        self.storage = storage
+        self.valuesRetainedByKey = valuesRetainedByKey
+    }
+
+    public mutating func reap() {
+        storage = weakKeyDictionary().storage
+    }
+
+    public func weakDictionary() -> WeakDictionary<Key, Value> {
+        return dictionary().weakDictionary()
+    }
+
+    public func weakKeyDictionary() -> WeakKeyDictionary<Key, Value> {
+        return self[startIndex ..< endIndex]
+    }
+
+    public func dictionary() -> [Key: Value] {
+        var newStorage = [Key: Value]()
+
+        storage.forEach { key, value in
+            if let retainedKey = key.key, let retainedValue = value.value {
+                newStorage[retainedKey] = retainedValue
+            }
+        }
+
+        return newStorage
+    }
+}
+
+extension WeakKeyDictionary: Collection {
+
+    public typealias Index = DictionaryIndex<WeakDictionaryKey<Key, Value>, WeakDictionaryReference<Value>>
+
+    public var startIndex: Index {
+        return storage.startIndex
+    }
+
+    public var endIndex: Index {
+        return storage.endIndex
+    }
+
+    public func index(after index: Index) -> Index {
+        return storage.index(after: index)
+    }
+
+    public subscript(position: Index) -> (WeakDictionaryKey<Key, Value>, WeakDictionaryReference<Value>) {
+        return storage[position]
+    }
+
+    public subscript(key: Key) -> Value? {
+        get {
+            return storage[WeakDictionaryKey<Key, Value>(key: key)]
+        }
+
+        set {
+            let retainedValue = valuesRetainedByKey ? newValue : nil
+            let weakKey = WeakDictionaryKey<Key, Value>(key: key, value: retainedValue)
+            storage[weakKey] = newValue
+        }
+    }
+
+    public subscript(bounds: Range<Index>) -> WeakKeyDictionary<Key, Value> {
+        let subStorage = storage[bounds.lowerBound ..< bounds.upperBound]
+        var newStorage = WeakDictionary<WeakDictionaryKey<Key, Value>, Value>()
+
+        subStorage.filter { key, value in return key.key != nil && value.value != nil }
+            .forEach { key, value in newStorage[key] = value.value }
+
+        return WeakKeyDictionary<Key, Value>(storage: newStorage)
+    }
+}
+
+extension WeakDictionary where Key: AnyObject {
+    public func weakKeyDictionary(valuesRetainedByKey: Bool = false) -> WeakKeyDictionary<Key, Value> {
+        return WeakKeyDictionary<Key, Value>(dictionary: dictionary(), valuesRetainedByKey: valuesRetainedByKey)
+    }
+}
+
+extension Dictionary where Key: AnyObject, Value: AnyObject {
+    public func weakKeyDictionary(valuesRetainedByKey: Bool = false) -> WeakKeyDictionary<Key, Value> {
+        return WeakKeyDictionary<Key, Value>(dictionary: self, valuesRetainedByKey: valuesRetainedByKey)
+    }
+}

ElementX/Sources/Modules/Routers/NavigationModule.swift

@@ -0,0 +1,36 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+/// Structure used to pass modules to routers with pop completion blocks.
+struct NavigationModule {
+    /// Actual presentable of the module
+    let presentable: Presentable
+    
+    /// Block to be called when the module is popped
+    let popCompletion: (() -> Void)?
+}
+
+// MARK: - CustomStringConvertible
+
+extension NavigationModule: CustomStringConvertible {
+    
+    var description: String {
+        return "NavigationModule: \(presentable), pop completion: \(String(describing: popCompletion))"
+    }
+    
+}

ElementX/Sources/Modules/Routers/NavigationRouter.swift

@@ -0,0 +1,405 @@
+/*
+ Copyright 2019 New Vector Ltd
+ 
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import UIKit
+
+/// `NavigationRouter` is a concrete implementation of NavigationRouterType.
+final class NavigationRouter: NSObject, NavigationRouterType {
+    
+    // MARK: - Properties
+    
+    // MARK: Private
+    
+    private var completions: [UIViewController : () -> Void]
+    private let navigationController: UINavigationController
+    
+    /// Stores the association between the added Presentable and his view controller.
+    /// They can be the same if the controller is not added via his Coordinator or it is a simple UIViewController.
+    private var storedModules = WeakDictionary<UIViewController, AnyObject>()
+    
+    // MARK: Public
+    
+    /// Returns the presentables associated to each view controller
+    var modules: [Presentable] {
+        return self.viewControllers.map { (viewController) -> Presentable in
+            return self.module(for: viewController)
+        }
+    }
+    
+    /// Return the view controllers stack
+    var viewControllers: [UIViewController] {
+        return navigationController.viewControllers
+    }
+    
+    // MARK: - Setup
+    
+    init(navigationController: UINavigationController) {
+        self.navigationController = navigationController
+        self.completions = [:]
+        super.init()
+        self.navigationController.delegate = self
+        
+        // Post local notification on NavigationRouter creation
+        let userInfo: [String: Any] = [NavigationRouter.NotificationUserInfoKey.navigationRouter: self,
+                        NavigationRouter.NotificationUserInfoKey.navigationController: navigationController]
+        NotificationCenter.default.post(name: NavigationRouter.didCreate, object: self, userInfo: userInfo)
+    }
+    
+    deinit {
+        // Post local notification on NavigationRouter deinit
+        let userInfo: [String: Any] = [NavigationRouter.NotificationUserInfoKey.navigationRouter: self,
+                        NavigationRouter.NotificationUserInfoKey.navigationController: navigationController]
+        NotificationCenter.default.post(name: NavigationRouter.willDestroy, object: self, userInfo: userInfo)
+    }
+    
+    // MARK: - Public
+    
+    func present(_ module: Presentable, animated: Bool = true) {
+        MXLog.debug("[NavigationRouter] Present \(module)")
+        navigationController.present(module.toPresentable(), animated: animated, completion: nil)
+    }
+    
+    func dismissModule(animated: Bool = true, completion: (() -> Void)? = nil) {
+        MXLog.debug("[NavigationRouter] Dismiss presented module")
+        navigationController.dismiss(animated: animated, completion: completion)
+    }
+    
+    func setRootModule(_ module: Presentable, hideNavigationBar: Bool = false, animated: Bool = false, popCompletion: (() -> Void)? = nil) {
+        MXLog.debug("[NavigationRouter] Set root module \(module)")
+        
+        let controller = module.toPresentable()
+        
+        // Avoid setting a UINavigationController onto stack
+        guard controller is UINavigationController == false else {
+            MXLog.error("Cannot add a UINavigationController to NavigationRouter")
+            return
+        }
+        
+        self.addModule(module, for: controller)
+        
+        let controllersToPop = self.navigationController.viewControllers.reversed()
+        
+        controllersToPop.forEach {
+            self.willPopViewController($0)
+        }
+        
+        if let popCompletion = popCompletion {
+            completions[controller] = popCompletion
+        }
+        
+        self.willPushViewController(controller)
+        
+        navigationController.setViewControllers([controller], animated: animated)
+        navigationController.isNavigationBarHidden = hideNavigationBar
+        
+        // Pop old view controllers
+        controllersToPop.forEach {
+            self.didPopViewController($0)
+        }
+        
+        // Add again controller to module association, in case same module instance is added back
+        self.addModule(module, for: controller)
+        
+        self.didPushViewController(controller)
+    }
+        
+    func setModules(_ modules: [NavigationModule], hideNavigationBar: Bool, animated: Bool) {
+        
+        MXLog.debug("[NavigationRouter] Set modules \(modules)")
+        
+        let controllers = modules.map { (module) -> UIViewController in
+            let controller = module.presentable.toPresentable()
+            self.addModule(module.presentable, for: controller)
+            return controller
+        }
+                
+        let controllersToPop = self.navigationController.viewControllers.reversed()
+        
+        controllersToPop.forEach {
+            self.willPopViewController($0)
+        }
+        
+        controllers.forEach {
+            self.willPushViewController($0)
+        }
+        
+        // Set new view controllers
+        navigationController.setViewControllers(controllers, animated: animated)
+        navigationController.isNavigationBarHidden = hideNavigationBar
+        
+        // Pop old view controllers
+        controllersToPop.forEach {
+            self.didPopViewController($0)
+        }
+        
+        // Add again controller to module association, in case same modules instance are added back
+        modules.forEach { (module) in
+            self.addModule(module.presentable, for: module.presentable.toPresentable())
+        }
+        
+        controllers.forEach {
+            self.didPushViewController($0)
+        }
+    }
+    
+    func popToRootModule(animated: Bool) {
+        MXLog.debug("[NavigationRouter] Pop to root module")
+        
+        let controllers = self.navigationController.viewControllers
+        
+        if controllers.count > 1 {
+            let controllersToPop = controllers[1..<controllers.count]
+            
+            controllersToPop.reversed().forEach {
+                self.willPopViewController($0)
+            }
+        }
+        
+        if let controllers = navigationController.popToRootViewController(animated: animated) {
+            controllers.reversed().forEach {
+                self.didPopViewController($0)
+            }
+        }
+    }
+    
+    func popToModule(_ module: Presentable, animated: Bool) {
+        MXLog.debug("[NavigationRouter] Pop to module \(module)")
+        
+        let controller = module.toPresentable()
+        let controllersBeforePop = self.navigationController.viewControllers
+        
+        if let controllerIndex = controllersBeforePop.firstIndex(of: controller) {
+            let controllersToPop = controllersBeforePop[controllerIndex..<controllersBeforePop.count]
+            
+            controllersToPop.reversed().forEach {
+                self.willPopViewController($0)
+            }
+        }
+        
+        if let controllers = navigationController.popToViewController(controller, animated: animated) {
+            controllers.reversed().forEach {
+                self.didPopViewController($0)
+            }
+        }
+    }
+    
+    func push(_ module: Presentable, animated: Bool = true, popCompletion: (() -> Void)? = nil) {
+        MXLog.debug("[NavigationRouter] Push module \(module)")
+        
+        let controller = module.toPresentable()
+        
+        // Avoid pushing UINavigationController onto stack
+        guard controller is UINavigationController == false else {
+            MXLog.error("Cannot push a UINavigationController to NavigationRouter")
+            return
+        }
+        
+        self.addModule(module, for: controller)
+        
+        if let completion = popCompletion {
+            completions[controller] = completion
+        }
+        
+        self.willPushViewController(controller)
+        
+        navigationController.pushViewController(controller, animated: animated)
+        
+        self.didPushViewController(controller)
+    }
+    
+    func push(_ modules: [NavigationModule], animated: Bool) {
+        MXLog.debug("[NavigationRouter] Push modules \(modules)")
+        
+        // Avoid pushing any UINavigationController onto stack
+        guard modules.first(where: { $0.presentable.toPresentable() is UINavigationController }) == nil else {
+            MXLog.error("Cannot push a UINavigationController to NavigationRouter")
+            return
+        }
+        
+        for module in modules {
+            let controller = module.presentable.toPresentable()
+            self.addModule(module.presentable, for: controller)
+            
+            if let completion = module.popCompletion {
+                completions[controller] = completion
+            }
+            
+            self.willPushViewController(controller)
+        }
+        
+        var viewControllers = navigationController.viewControllers
+        viewControllers.append(contentsOf: modules.map({ $0.presentable.toPresentable() }))
+        navigationController.setViewControllers(viewControllers, animated: animated)
+        
+        for module in modules {
+            let controller = module.presentable.toPresentable()
+            self.didPushViewController(controller)
+        }
+    }
+    
+    func popModule(animated: Bool = true) {
+        MXLog.debug("[NavigationRouter] Pop module")
+        
+        if let lastController = navigationController.viewControllers.last {
+            self.willPopViewController(lastController)
+        }
+        
+        if let controller = navigationController.popViewController(animated: animated) {
+            self.didPopViewController(controller)
+        }
+    }
+    
+    func popAllModules(animated: Bool) {
+        MXLog.debug("[NavigationRouter] Pop all modules")
+        
+        let controllersToPop = self.navigationController.viewControllers.reversed()
+        
+        controllersToPop.forEach {
+            self.willPopViewController($0)
+        }        
+        
+        navigationController.setViewControllers([], animated: animated)
+        
+        controllersToPop.forEach {
+            self.didPopViewController($0)
+        }
+    }
+    
+    func contains(_ module: Presentable) -> Bool {
+        
+        let controller = module.toPresentable()
+        return self.navigationController.viewControllers.contains(controller)
+    }
+        
+    // MARK: Presentable
+    
+    func toPresentable() -> UIViewController {
+        return navigationController
+    }
+    
+    // MARK: - Private
+    
+    private func module(for viewController: UIViewController) -> Presentable {
+        
+        guard let module = self.storedModules[viewController] as? Presentable else {
+            return viewController
+        }
+        return module
+    }
+    
+    private func addModule(_ module: Presentable, for viewController: UIViewController) {
+        self.storedModules[viewController] = module as AnyObject
+    }
+    
+    private func removeModule(for viewController: UIViewController) {
+        self.storedModules[viewController] = nil
+    }
+    
+    private func runCompletion(for controller: UIViewController) {
+        guard let completion = completions[controller] else {
+            return
+        }
+        completion()
+        completions.removeValue(forKey: controller)
+    }
+    
+    private func willPushViewController(_ viewController: UIViewController) {
+        self.postNotification(withName: NavigationRouter.willPushModule, for: viewController)
+    }
+    
+    private func didPushViewController(_ viewController: UIViewController) {
+        self.postNotification(withName: NavigationRouter.didPushModule, for: viewController)
+    }
+    
+    private func willPopViewController(_ viewController: UIViewController) {
+        self.postNotification(withName: NavigationRouter.willPopModule, for: viewController)
+    }
+    
+    private func didPopViewController(_ viewController: UIViewController) {                
+        self.postNotification(withName: NavigationRouter.didPopModule, for: viewController)
+        
+        // Call completion closure associated to the view controller
+        // So associated coordinator can be deallocated
+        runCompletion(for: viewController)
+        
+        self.removeModule(for: viewController)
+    }
+    
+    private func postNotification(withName name: Notification.Name, for viewController: UIViewController) {
+        
+        let module = self.module(for: viewController)
+        
+        let userInfo: [String: Any] = [
+            NotificationUserInfoKey.navigationRouter: self,
+            NotificationUserInfoKey.module: module,
+            NotificationUserInfoKey.viewController: viewController
+        ]
+        NotificationCenter.default.post(name: name, object: self, userInfo: userInfo)
+    }
+}
+
+// MARK: - UINavigationControllerDelegate
+extension NavigationRouter: UINavigationControllerDelegate {
+    
+    func navigationController(_ navigationController: UINavigationController, willShow viewController: UIViewController, animated: Bool) {
+        
+        // TODO: Try to post `NavigationRouter.willPopModule` notification here
+    }
+    
+    func navigationController(_ navigationController: UINavigationController, didShow viewController: UIViewController, animated: Bool) {
+        
+        // Ensure the view controller is popping
+        guard let poppedViewController = navigationController.transitionCoordinator?.viewController(forKey: .from),
+            !navigationController.viewControllers.contains(poppedViewController) else {
+                return
+        }
+        
+        MXLog.debug("[NavigationRouter] Popped module: \(poppedViewController)")
+        
+        self.didPopViewController(poppedViewController)
+    }
+}
+
+// MARK: - NavigationRouter notification constants
+extension NavigationRouter {
+    
+    // MARK: Notification names
+    
+    public static let willPushModule = Notification.Name("NavigationRouterWillPushModule")
+    public static let didPushModule = Notification.Name("NavigationRouterDidPushModule")
+    public static let willPopModule = Notification.Name("NavigationRouterWillPopModule")
+    public static let didPopModule = Notification.Name("NavigationRouterDidPopModule")
+    
+    public static let didCreate = Notification.Name("NavigationRouterDidCreate")
+    public static let willDestroy = Notification.Name("NavigationRouterWillDestroy")
+    
+    // MARK: Notification keys
+    
+    public struct NotificationUserInfoKey {
+        
+        /// The associated view controller (UIViewController).
+        static let viewController = "viewController"
+        
+        /// The associated module (Presentable), can the view controller itself or is Coordinator
+        static let module = "module"
+        
+        /// The navigation router that send the notification (NavigationRouterType)
+        static let navigationRouter = "navigationRouter"
+        
+        /// The navigation controller (UINavigationController) associated to the navigation router
+        static let navigationController = "navigationController"
+    }
+}

ElementX/Sources/Modules/Routers/NavigationRouterStore.swift

@@ -0,0 +1,96 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import UIKit
+
+/// `NavigationRouterStore` enables to get a NavigationRouter from a UINavigationController instance.
+class NavigationRouterStore: NavigationRouterStoreProtocol {
+    
+    // MARK: - Constants
+    
+    static let shared = NavigationRouterStore()
+    
+    // MARK: - Properties
+
+     // FIXME: WeakDictionary does not work with protocol
+    // Find a way to use NavigationRouterType as value
+    private var navigationRouters = WeakDictionary<UINavigationController, NavigationRouter>()
+    
+    // MARK: - Setup
+    
+    /// As we are ensuring that there is only one navigation controller per NavigationRouter, the class here should be used as a singleton.
+    private init() {
+        self.registerNavigationRouterNotifications()
+    }
+    
+    // MARK: - Public
+    
+    func navigationRouter(for navigationController: UINavigationController) -> NavigationRouterType {
+        
+        if let existingNavigationRouter = self.findNavigationRouter(for: navigationController) {
+            return existingNavigationRouter
+        }
+        
+        let navigationRouter = NavigationRouter(navigationController: UINavigationController())
+        return navigationRouter
+    }
+    
+    // MARK: - Private
+    
+    private func findNavigationRouter(for navigationController: UINavigationController) -> NavigationRouterType? {
+        return self.navigationRouters[navigationController]
+    }
+    
+    private func removeNavigationRouter(for navigationController: UINavigationController) {
+        self.navigationRouters[navigationController] = nil
+    }
+    
+    private func registerNavigationRouterNotifications() {
+        NotificationCenter.default.addObserver(self, selector: #selector(navigationRouterDidCreate(_:)), name: NavigationRouter.didCreate, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(navigationRouterWillDestroy(_:)), name: NavigationRouter.willDestroy, object: nil)
+    }
+    
+    @objc private func navigationRouterDidCreate(_ notification: Notification) {
+                
+        guard let userInfo = notification.userInfo,
+              let navigationRouter = userInfo[NavigationRouter.NotificationUserInfoKey.navigationRouter] as? NavigationRouterType,
+              let navigationController = userInfo[NavigationRouter.NotificationUserInfoKey.navigationController] as? UINavigationController else {
+            return
+        }
+        
+        if let existingNavigationRouter = self.findNavigationRouter(for: navigationController) {
+            fatalError("\(existingNavigationRouter) is already tied to the same navigation controller as \(navigationRouter). We should have only one NavigationRouter per navigation controller")
+        } else {
+            // FIXME: WeakDictionary does not work with protocol
+            // Find a way to avoid this cast
+            self.navigationRouters[navigationController] = navigationRouter as? NavigationRouter
+        }
+    }
+    
+    @objc private func navigationRouterWillDestroy(_ notification: Notification) {
+        guard let userInfo = notification.userInfo,
+              let navigationRouter = userInfo[NavigationRouter.NotificationUserInfoKey.navigationRouter] as? NavigationRouterType,
+              let navigationController = userInfo[NavigationRouter.NotificationUserInfoKey.navigationController] as? UINavigationController else {
+            return
+        }
+        
+        if let existingNavigationRouter = self.findNavigationRouter(for: navigationController), existingNavigationRouter !== navigationRouter {
+            fatalError("\(existingNavigationRouter) is already tied to the same navigation controller as \(navigationRouter). We should have only one NavigationRouter per navigation controller")
+        }
+        
+        self.removeNavigationRouter(for: navigationController)
+    }
+}

ElementX/Sources/Modules/Routers/NavigationRouterStoreProtocol.swift

@@ -0,0 +1,25 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import UIKit
+
+/// `NavigationRouterStoreProtocol` describes a structure that enables to get a NavigationRouter from a UINavigationController instance.
+protocol NavigationRouterStoreProtocol {
+    
+    /// Gets the existing navigation router for the supplied controller, creating a new one if it doesn't yet exist.
+    /// Note: The store only holds a weak reference to the returned router. It is the caller's responsibility to retain it.
+    func navigationRouter(for navigationController: UINavigationController) -> NavigationRouterType
+}

ElementX/Sources/Modules/Routers/NavigationRouterType.swift

@@ -0,0 +1,135 @@
+/*
+ Copyright 2019 New Vector Ltd
+ 
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import UIKit
+
+/// Protocol describing a router that wraps a UINavigationController and add convenient completion handlers. Completions are called when a Presentable is removed.
+/// Routers are used to be passed between coordinators. They handles only `physical` navigation.
+protocol NavigationRouterType: AnyObject, Presentable {
+
+    /// Present modally a view controller on the navigation controller
+    ///
+    /// - Parameter module: The Presentable to present.
+    /// - Parameter animated: Specify true to animate the transition.
+    func present(_ module: Presentable, animated: Bool)
+    
+    /// Dismiss presented view controller from navigation controller
+    ///
+    /// - Parameter animated: Specify true to animate the transition.
+    /// - Parameter completion: Animation completion (not the pop completion).
+    func dismissModule(animated: Bool, completion: (() -> Void)?)
+    
+    /// Set root view controller of navigation controller
+    ///
+    /// - Parameter module: The Presentable to set as root.
+    /// - Parameter hideNavigationBar: Specify true to hide the UINavigationBar.
+    /// - Parameter animated: Specify true to animate the transition.
+    /// - Parameter popCompletion: Completion called when `module` is removed from the navigation stack.
+    func setRootModule(_ module: Presentable, hideNavigationBar: Bool, animated: Bool, popCompletion: (() -> Void)?)
+    
+    /// Set view controllers stack of navigation controller
+    /// - Parameters:
+    ///   - modules: The modules stack to set.
+    ///   - hideNavigationBar: Specify true to hide the UINavigationBar.
+    ///   - animated: Specify true to animate the transition.
+    func setModules(_ modules: [NavigationModule], hideNavigationBar: Bool, animated: Bool)
+    
+    /// Pop to root view controller of navigation controller and remove all others
+    ///
+    /// - Parameter animated: Specify true to animate the transition.
+    func popToRootModule(animated: Bool)
+    
+    /// Pops view controllers until the specified view controller is at the top of the navigation stack
+    ///
+    /// - Parameter module: The Presentable that should to be at the top of the stack.
+    /// - Parameter animated: Specify true to animate the transition.
+    func popToModule(_ module: Presentable, animated: Bool)
+    
+    /// Push a view controller on navigation controller stack
+    ///
+    /// - Parameter animated: Specify true to animate the transition.
+    /// - Parameter popCompletion: Completion called when `module` is removed from the navigation stack.
+    func push(_ module: Presentable, animated: Bool, popCompletion: (() -> Void)?)
+    
+    /// Push some view controllers on navigation controller stack
+    ///
+    /// - Parameter modules: Modules to push
+    /// - Parameter animated: Specify true to animate the transition.
+    func push(_ modules: [NavigationModule], animated: Bool)
+    
+    /// Pop last view controller from navigation controller stack
+    ///
+    /// - Parameter animated: Specify true to animate the transition.
+    func popModule(animated: Bool)
+    
+    /// Pops all view controllers
+    ///
+    /// - Parameter animated: Specify true to animate the transition.
+    func popAllModules(animated: Bool)
+    
+    /// Returns the modules that are currently in the navigation stack
+    var modules: [Presentable] { get }
+    
+    /// Check if the navigation controller contains the given presentable.
+    /// - Parameter module: The presentable for which to check the existence.
+    func contains(_ module: Presentable) -> Bool
+}
+
+// `NavigationRouterType` default implementation
+extension NavigationRouterType {
+    
+    func setRootModule(_ module: Presentable) {
+        setRootModule(module, hideNavigationBar: false, animated: false, popCompletion: nil)
+    }
+    
+    func setRootModule(_ module: Presentable, popCompletion: (() -> Void)?) {
+        setRootModule(module, hideNavigationBar: false, animated: false, popCompletion: popCompletion)
+    }
+    
+    func setModules(_ modules: [NavigationModule], animated: Bool) {
+        setModules(modules, hideNavigationBar: false, animated: animated)
+    }
+    
+    func setModules(_ modules: [Presentable], animated: Bool) {
+        setModules(modules, hideNavigationBar: false, animated: animated)
+    }
+    
+}
+
+// MARK: - Presentable <--> NavigationModule Transitive Methods
+
+extension NavigationRouterType {
+    
+    func setRootModule(_ module: NavigationModule) {
+        setRootModule(module.presentable, popCompletion: module.popCompletion)
+    }
+    
+    func push(_ module: NavigationModule, animated: Bool) {
+        push(module.presentable, animated: animated, popCompletion: module.popCompletion)
+    }
+    
+    func setModules(_ modules: [Presentable], hideNavigationBar: Bool, animated: Bool) {
+        setModules(modules.map { $0.toModule() },
+                   hideNavigationBar: hideNavigationBar,
+                   animated: animated)
+    }
+    
+    func push(_ modules: [Presentable], animated: Bool) {
+        push(modules.map { $0.toModule() },
+             animated: animated)
+    }
+    
+}

ElementX/Sources/Modules/Routers/Presentable.swift

@@ -0,0 +1,38 @@
+/*
+ Copyright 2019 New Vector Ltd
+ 
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import UIKit
+
+/// Protocol used to pass UIViewControllers to routers
+protocol Presentable {
+    func toPresentable() -> UIViewController
+}
+
+extension UIViewController: Presentable {
+    public func toPresentable() -> UIViewController {
+        return self
+    }
+}
+
+extension Presentable {
+    
+    /// Returns a new module from the presentable without a pop completion block
+    /// - Returns: Module
+    func toModule() -> NavigationModule {
+        return NavigationModule(presentable: self, popCompletion: nil)
+    }
+    
+}

ElementX/Sources/Modules/Routers/RootRouter.swift

@@ -0,0 +1,87 @@
+/*
+ Copyright 2020 New Vector Ltd
+ 
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import UIKit
+
+/// `RootRouter` is a concrete implementation of RootRouterType.
+final class RootRouter: RootRouterType {
+    
+    // MARK: - Constants
+    
+    // `rootViewController` animation constants
+    private enum RootViewControllerUpdateAnimation {
+        static let duration: TimeInterval = 0.3
+        static let options: UIView.AnimationOptions = .transitionCrossDissolve
+    }
+    
+    // MARK: - Properties
+    
+    private var presentedModule: Presentable?
+    
+    let window: UIWindow
+    
+    /// The root view controller currently presented    
+    var rootViewController: UIViewController? {
+        return self.window.rootViewController
+    }
+    
+    // MARK: - Setup
+    
+    init(window: UIWindow) {
+        self.window = window
+    }
+    
+    // MARK: - Public methods
+    
+    func setRootModule(_ module: Presentable) {
+        self.updateRootViewController(rootViewController: module.toPresentable(), animated: false, completion: nil)
+        self.window.makeKeyAndVisible()
+    }
+    
+    func dismissRootModule(animated: Bool, completion: (() -> Void)?) {
+        self.updateRootViewController(rootViewController: nil, animated: animated, completion: completion)
+    }
+    
+    func presentModule(_ module: Presentable, animated: Bool, completion: (() -> Void)?) {
+        let viewControllerPresenter = self.rootViewController?.presentedViewController ?? self.rootViewController
+        
+        viewControllerPresenter?.present(module.toPresentable(), animated: animated, completion: completion)
+        self.presentedModule = module
+    }
+    
+    func dismissModule(animated: Bool, completion: (() -> Void)?) {
+        self.presentedModule?.toPresentable().dismiss(animated: animated, completion: completion)
+    }
+    
+    // MARK: - Private methods
+    
+    private func updateRootViewController(rootViewController: UIViewController?, animated: Bool, completion: (() -> Void)?) {
+        
+        if animated {
+            UIView.transition(with: window, duration: RootViewControllerUpdateAnimation.duration, options: RootViewControllerUpdateAnimation.options, animations: {
+                let oldState: Bool = UIView.areAnimationsEnabled
+                UIView.setAnimationsEnabled(false)
+                self.window.rootViewController = rootViewController
+                UIView.setAnimationsEnabled(oldState)
+            }, completion: { (_: Bool) -> Void in
+                completion?()
+            })
+        } else {
+            self.window.rootViewController = rootViewController
+            completion?()
+        }
+    }
+}

ElementX/Sources/Modules/Routers/RootRouterType.swift

@@ -0,0 +1,49 @@
+/*
+ Copyright 2020 New Vector Ltd
+ 
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import UIKit
+
+/// Protocol describing a router that wraps the root navigation of the application.
+/// Routers are used to be passed between coordinators. They handles only `physical` navigation.
+protocol RootRouterType: AnyObject {          
+    
+    /// Update the root view controller
+    ///
+    /// - Parameter module: The new root view controller to set
+    func setRootModule(_ module: Presentable)        
+    
+    /// Dismiss the root view controller
+    ///
+    /// - Parameters:
+    ///     - animated: Specify true to animate the transition.
+    ///     - completion: The closure executed after the view controller is dismissed.
+    func dismissRootModule(animated: Bool, completion: (() -> Void)?)
+    
+    /// Present modally a view controller on the root view controller
+    ///
+    /// - Parameters:
+    ///   - module: Specify true to animate the transition.
+    ///   - animated: Specify true to animate the transition.
+    ///   - completion: Animation completion.
+    func presentModule(_ module: Presentable, animated: Bool, completion: (() -> Void)?)
+    
+    /// Dismiss modally presented view controller from root view controller
+    ///
+    /// - Parameters:
+    ///   - animated: Specify true to animate the transition.
+    ///   - completion: Animation completion.
+    func dismissModule(animated: Bool, completion: (() -> Void)?)
+}

ElementX/Sources/Modules/Splash/SplashViewController.swift

@@ -0,0 +1,12 @@
+//
+//  SplashViewController.swift
+//  ElementX
+//
+//  Created by Stefan Ceriu on 14.02.2022.
+//
+
+import UIKit
+
+class SplashViewController: UIViewController {
+    
+}

ElementX/Sources/Modules/Splash/SplashViewController.xib

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.XIB" version="3.0" toolsVersion="19529" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES">
+    <device id="retina6_1" orientation="portrait" appearance="light"/>
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="19519"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="System colors in document resources" minToolsVersion="11.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <objects>
+        <placeholder placeholderIdentifier="IBFilesOwner" id="-1" userLabel="File's Owner" customClass="SplashViewController" customModule="ElementX" customModuleProvider="target">
+            <connections>
+                <outlet property="view" destination="i5M-Pr-FkT" id="sfx-zR-JGt"/>
+            </connections>
+        </placeholder>
+        <placeholder placeholderIdentifier="IBFirstResponder" id="-2" customClass="UIResponder"/>
+        <view clearsContextBeforeDrawing="NO" contentMode="scaleToFill" id="i5M-Pr-FkT">
+            <rect key="frame" x="0.0" y="0.0" width="414" height="896"/>
+            <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+            <subviews>
+                <imageView clipsSubviews="YES" userInteractionEnabled="NO" contentMode="scaleAspectFit" horizontalHuggingPriority="251" verticalHuggingPriority="251" image="app-logo" translatesAutoresizingMaskIntoConstraints="NO" id="ue7-fB-5XS">
+                    <rect key="frame" x="87" y="328" width="240" height="240"/>
+                    <color key="tintColor" red="0.050980392156862744" green="0.74117647058823533" blue="0.54509803921568623" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                </imageView>
+            </subviews>
+            <viewLayoutGuide key="safeArea" id="fnl-2z-Ty3"/>
+            <color key="backgroundColor" systemColor="systemBackgroundColor"/>
+            <constraints>
+                <constraint firstItem="fnl-2z-Ty3" firstAttribute="bottom" relation="greaterThanOrEqual" secondItem="ue7-fB-5XS" secondAttribute="bottom" constant="16" id="Cip-Sc-gaF"/>
+                <constraint firstItem="ue7-fB-5XS" firstAttribute="top" relation="greaterThanOrEqual" secondItem="fnl-2z-Ty3" secondAttribute="top" constant="16" id="Clt-cS-YAr"/>
+                <constraint firstItem="ue7-fB-5XS" firstAttribute="centerY" secondItem="i5M-Pr-FkT" secondAttribute="centerY" id="N3w-Jf-MRA"/>
+                <constraint firstItem="fnl-2z-Ty3" firstAttribute="trailing" relation="greaterThanOrEqual" secondItem="ue7-fB-5XS" secondAttribute="trailing" constant="16" id="WfN-3K-kpr"/>
+                <constraint firstItem="ue7-fB-5XS" firstAttribute="centerX" secondItem="i5M-Pr-FkT" secondAttribute="centerX" id="ujr-SL-AyX"/>
+                <constraint firstItem="ue7-fB-5XS" firstAttribute="leading" relation="greaterThanOrEqual" secondItem="fnl-2z-Ty3" secondAttribute="leading" constant="16" id="yNl-Wu-AES"/>
+            </constraints>
+            <point key="canvasLocation" x="137.68115942028987" y="153.34821428571428"/>
+        </view>
+    </objects>
+    <resources>
+        <image name="app-logo" width="240" height="240"/>
+        <systemColor name="systemBackgroundColor">
+            <color white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+        </systemColor>
+    </resources>
+</document>

ElementX/Sources/Modules/Templates/SimpleScreenExample/Coordinator/TemplateSimpleScreenCoordinator.swift

@@ -0,0 +1,64 @@
+//
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import SwiftUI
+
+struct TemplateSimpleScreenCoordinatorParameters {
+    let promptType: TemplateSimpleScreenPromptType
+}
+
+final class TemplateSimpleScreenCoordinator: Coordinator, Presentable {
+    
+    // MARK: - Properties
+    
+    // MARK: Private
+    
+    private let parameters: TemplateSimpleScreenCoordinatorParameters
+    private let templateSimpleScreenHostingController: UIViewController
+    private var templateSimpleScreenViewModel: TemplateSimpleScreenViewModelProtocol
+    
+    // MARK: Public
+
+    // Must be used only internally
+    var childCoordinators: [Coordinator] = []
+    var completion: ((TemplateSimpleScreenViewModelResult) -> Void)?
+    
+    // MARK: - Setup
+    
+    @available(iOS 14.0, *)
+    init(parameters: TemplateSimpleScreenCoordinatorParameters) {
+        self.parameters = parameters
+        
+        let viewModel = TemplateSimpleScreenViewModel(promptType: parameters.promptType)
+        let view = TemplateSimpleScreen(viewModel: viewModel.context)
+        templateSimpleScreenViewModel = viewModel
+        templateSimpleScreenHostingController = VectorHostingController(rootView: view)
+    }
+    
+    // MARK: - Public
+    func start() {
+        MXLog.debug("[TemplateSimpleScreenCoordinator] did start.")
+        templateSimpleScreenViewModel.completion = { [weak self] result in
+            MXLog.debug("[TemplateSimpleScreenCoordinator] TemplateSimpleScreenViewModel did complete with result: \(result).")
+            guard let self = self else { return }
+            self.completion?(result)
+        }
+    }
+    
+    func toPresentable() -> UIViewController {
+        return self.templateSimpleScreenHostingController
+    }
+}

ElementX/Sources/Modules/Templates/SimpleScreenExample/MockTemplateSimpleScreenScreenState.swift

@@ -0,0 +1,57 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+import SwiftUI
+
+/// Using an enum for the screen allows you define the different state cases with
+/// the relevant associated data for each case.
+@available(iOS 14.0, *)
+enum MockTemplateSimpleScreenScreenState: MockScreenState, CaseIterable {
+    // A case for each state you want to represent
+    // with specific, minimal associated data that will allow you
+    // mock that screen.
+    case promptType(TemplateSimpleScreenPromptType)
+    
+    /// The associated screen
+    var screenType: Any.Type {
+        TemplateSimpleScreen.self
+    }
+    
+    /// A list of screen state definitions
+    static var allCases: [MockTemplateSimpleScreenScreenState] {
+        // Each of the presence statuses
+        TemplateSimpleScreenPromptType.allCases.map(MockTemplateSimpleScreenScreenState.promptType)
+    }
+    
+    /// Generate the view struct for the screen state.
+    var screenView: ([Any], AnyView) {
+        let promptType: TemplateSimpleScreenPromptType
+        switch self {
+        case .promptType(let type):
+            promptType = type
+        }
+        let viewModel = TemplateSimpleScreenViewModel(promptType: promptType)
+        
+        // can simulate service and viewModel actions here if needs be.
+        
+        return (
+            [promptType, viewModel],
+            AnyView(TemplateSimpleScreen(viewModel: viewModel.context)
+                .addDependency(MockAvatarService.example))
+        )
+    }
+}

ElementX/Sources/Modules/Templates/SimpleScreenExample/TemplateSimpleScreenModels.swift

@@ -0,0 +1,67 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+// MARK: - Coordinator
+
+enum TemplateSimpleScreenPromptType {
+    case regular
+    case upgrade
+}
+
+extension TemplateSimpleScreenPromptType: Identifiable, CaseIterable {
+    var id: Self { self }
+    
+    var title: String {
+        switch self {
+        case .regular:
+            return VectorL10n.roomCreationMakePublicPromptTitle
+        case .upgrade:
+            return VectorL10n.roomDetailsHistorySectionPromptTitle
+        }
+    }
+    
+    var image: ImageAsset {
+        switch self {
+        case .regular:
+            return Asset.Images.appSymbol
+        case .upgrade:
+            return Asset.Images.keyVerificationSuccessShield
+        }
+    }
+}
+
+// MARK: View model
+
+enum TemplateSimpleScreenViewModelResult {
+    case accept
+    case cancel
+}
+
+// MARK: View
+
+struct TemplateSimpleScreenViewState: BindableState {
+    var promptType: TemplateSimpleScreenPromptType
+    var count: Int
+}
+
+enum TemplateSimpleScreenViewAction {
+    case incrementCount
+    case decrementCount
+    case accept
+    case cancel
+}

ElementX/Sources/Modules/Templates/SimpleScreenExample/TemplateSimpleScreenViewModel.swift

@@ -0,0 +1,54 @@
+//
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import SwiftUI
+
+@available(iOS 14, *)
+typealias TemplateSimpleScreenViewModelType = StateStoreViewModel<TemplateSimpleScreenViewState,
+                                                                  Never,
+                                                                  TemplateSimpleScreenViewAction>
+@available(iOS 14, *)
+class TemplateSimpleScreenViewModel: TemplateSimpleScreenViewModelType, TemplateSimpleScreenViewModelProtocol {
+
+    // MARK: - Properties
+
+    // MARK: Private
+
+    // MARK: Public
+
+    var completion: ((TemplateSimpleScreenViewModelResult) -> Void)?
+
+    // MARK: - Setup
+
+    init(promptType: TemplateSimpleScreenPromptType, initialCount: Int = 0) {
+        super.init(initialViewState: TemplateSimpleScreenViewState(promptType: promptType, count: 0))
+    }
+
+    // MARK: - Public
+
+    override func process(viewAction: TemplateSimpleScreenViewAction) {
+        switch viewAction {
+        case .accept:
+            completion?(.accept)
+        case .cancel:
+            completion?(.cancel)
+        case .incrementCount:
+            state.count += 1
+        case .decrementCount:
+            state.count -= 1
+        }
+    }
+}

ElementX/Sources/Modules/Templates/SimpleScreenExample/TemplateSimpleScreenViewModelProtocol.swift

@@ -0,0 +1,24 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+protocol TemplateSimpleScreenViewModelProtocol {
+    
+    var completion: ((TemplateSimpleScreenViewModelResult) -> Void)? { get set }
+    @available(iOS 14, *)
+    var context: TemplateSimpleScreenViewModelType.Context { get }
+}

ElementX/Sources/Modules/Templates/SimpleScreenExample/Test/UI/TemplateSimpleScreenUITests.swift

@@ -0,0 +1,45 @@
+//
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import XCTest
+import RiotSwiftUI
+
+@available(iOS 14.0, *)
+class TemplateSimpleScreenUITests: MockScreenTest {
+
+    override class var screenType: MockScreenState.Type {
+        return MockTemplateSimpleScreenScreenState.self
+    }
+
+    override class func createTest() -> MockScreenTest {
+        return TemplateSimpleScreenUITests(selector: #selector(verifyTemplateSimpleScreenScreen))
+    }
+
+    func verifyTemplateSimpleScreenScreen() throws {
+        guard let screenState = screenState as? MockTemplateSimpleScreenScreenState else { fatalError("no screen") }
+        switch screenState {
+        case .promptType(let promptType):
+            verifyTemplateSimpleScreenPromptType(promptType: promptType)
+        }
+    }
+    
+    func verifyTemplateSimpleScreenPromptType(promptType: TemplateSimpleScreenPromptType) {
+        let title = app.staticTexts["title"]
+        XCTAssert(title.exists)
+        XCTAssertEqual(title.label, promptType.title)
+    }
+
+}

ElementX/Sources/Modules/Templates/SimpleScreenExample/Test/Unit/TemplateSimpleScreenViewModelTests.swift

@@ -0,0 +1,49 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import XCTest
+
+@testable import RiotSwiftUI
+
+@available(iOS 14.0, *)
+class TemplateSimpleScreenViewModelTests: XCTestCase {
+    private enum Constants {
+        static let counterInitialValue = 0
+    }
+    
+    var viewModel: TemplateSimpleScreenViewModelProtocol!
+    var context: TemplateSimpleScreenViewModelType.Context!
+    
+    override func setUpWithError() throws {
+        viewModel = TemplateSimpleScreenViewModel(promptType: .regular, initialCount: Constants.counterInitialValue)
+        context = viewModel.context
+    }
+
+    func testInitialState() {
+        XCTAssertEqual(context.viewState.count, Constants.counterInitialValue)
+    }
+
+    func testCounter() throws {
+        context.send(viewAction: .incrementCount)
+        XCTAssertEqual(context.viewState.count, 1)
+        
+        context.send(viewAction: .incrementCount)
+        XCTAssertEqual(context.viewState.count, 2)
+        
+        context.send(viewAction: .decrementCount)
+        XCTAssertEqual(context.viewState.count, 1)
+    }
+}

ElementX/Sources/Modules/Templates/SimpleScreenExample/View/TemplateSimpleScreen.swift

@@ -0,0 +1,113 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import SwiftUI
+
+@available(iOS 14.0, *)
+struct TemplateSimpleScreen: View {
+
+    // MARK: - Properties
+    
+    // MARK: Private
+    
+    @Environment(\.theme) private var theme
+    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
+    
+    private var horizontalPadding: CGFloat {
+        horizontalSizeClass == .regular ? 50 : 16
+    }
+    
+    // MARK: Public
+    
+    @ObservedObject var viewModel: TemplateSimpleScreenViewModel.Context
+    
+    // MARK: Views
+    
+    var body: some View {
+        GeometryReader { geometry in
+            VStack {
+                ScrollView(showsIndicators: false) {
+                    mainContent
+                        .padding(.top, 50)
+                        .padding(.horizontal, horizontalPadding)
+                }
+                
+                buttons
+                    .padding(.horizontal, horizontalPadding)
+                    .padding(.bottom, geometry.safeAreaInsets.bottom > 0 ? 0 : 16)
+            }
+        }
+        .background(theme.colors.background.ignoresSafeArea())
+        .accentColor(theme.colors.accent)
+    }
+    
+    /// The main content of the view to be shown in a scroll view.
+    var mainContent: some View {
+        VStack(spacing: 36) {
+            Text(viewModel.viewState.promptType.title)
+                .font(theme.fonts.title1B)
+                .foregroundColor(theme.colors.primaryContent)
+                .accessibilityIdentifier("title")
+            
+            Image(viewModel.viewState.promptType.image.name)
+                .resizable()
+                .scaledToFit()
+                .frame(width: 100)
+                .foregroundColor(theme.colors.accent)
+            
+            HStack {
+                Text("Counter: \(viewModel.viewState.count)")
+                    .foregroundColor(theme.colors.primaryContent)
+                
+                Button("-") {
+                    viewModel.send(viewAction: .decrementCount)
+                }
+                
+                Button("+") {
+                    viewModel.send(viewAction: .incrementCount)
+                }
+            }
+            .font(theme.fonts.title3)
+        }
+    }
+    
+    /// The action buttons shown at the bottom of the view.
+    var buttons: some View {
+        VStack {
+            Button { viewModel.send(viewAction: .accept) } label: {
+                Text("Accept")
+                    .font(theme.fonts.bodySB)
+            }
+            .buttonStyle(PrimaryActionButtonStyle())
+            
+            Button { viewModel.send(viewAction: .cancel) } label: {
+                Text("Cancel")
+                    .font(theme.fonts.body)
+                    .padding(.vertical, 12)
+            }
+        }
+    }
+}
+
+// MARK: - Previews
+
+@available(iOS 14.0, *)
+struct TemplateSimpleScreen_Previews: PreviewProvider {
+    static let stateRenderer = MockTemplateSimpleScreenScreenState.stateRenderer
+    static var previews: some View {
+        stateRenderer.screenGroup()
+    }
+}

ElementX/Supporting Files/Assets.xcassets/AccentColor.colorset/Contents.json

@@ -0,0 +1,11 @@
+{
+  "colors" : [
+    {
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

ElementX/Supporting Files/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,98 @@
+{
+  "images" : [
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "60x60"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "60x60"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "76x76"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "76x76"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "83.5x83.5"
+    },
+    {
+      "idiom" : "ios-marketing",
+      "scale" : "1x",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

ElementX/Supporting Files/Assets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

ElementX/Supporting Files/Assets.xcassets/app-logo.imageset/Contents.json

@@ -0,0 +1,26 @@
+{
+  "images" : [
+    {
+      "filename" : "launch_screen_logo.png",
+      "idiom" : "universal",
+      "scale" : "1x"
+    },
+    {
+      "filename" : "launch_screen_logo@2x.png",
+      "idiom" : "universal",
+      "scale" : "2x"
+    },
+    {
+      "filename" : "launch_screen_logo@3x.png",
+      "idiom" : "universal",
+      "scale" : "3x"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  },
+  "properties" : {
+    "template-rendering-intent" : "template"
+  }
+}

ElementX/Supporting Files/Base.lproj/LaunchScreen.storyboard

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="19529" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <device id="retina6_1" orientation="portrait" appearance="light"/>
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="19519"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="System colors in document resources" minToolsVersion="11.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="414" height="896"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                        <color key="backgroundColor" systemColor="systemBackgroundColor"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+    <resources>
+        <systemColor name="systemBackgroundColor">
+            <color white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+        </systemColor>
+    </resources>
+</document>

ElementX/Supporting Files/ElementX.entitlements

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.app-sandbox</key>
+	<true/>
+	<key>com.apple.security.network.client</key>
+	<true/>
+</dict>
+</plist>