Server Confirmation Screen (#959)

* Add ServerConfirmationScreen.

ElementX/Sources/Services/Authentication/AuthenticationServiceProxy.swift

@@ -14,6 +14,7 @@
 // limitations under the License.
 //
 
+import Combine
 import Foundation
 import MatrixRustSDK
 
@@ -21,7 +22,9 @@ class AuthenticationServiceProxy: AuthenticationServiceProxyProtocol {
     private let authenticationService: AuthenticationService
     private let userSessionStore: UserSessionStoreProtocol
     
-    private(set) var homeserver = LoginHomeserver(address: ServiceLocator.shared.settings.defaultHomeserverAddress, loginMode: .unknown)
+    private let homeserverSubject: CurrentValueSubject<LoginHomeserver, Never> = .init(LoginHomeserver(address: ServiceLocator.shared.settings.defaultHomeserverAddress,
+                                                                                                       loginMode: .unknown))
+    var homeserver: CurrentValuePublisher<LoginHomeserver, Never> { homeserverSubject.asCurrentValuePublisher() }
     
     init(userSessionStore: UserSessionStoreProtocol) {
         self.userSessionStore = userSessionStore
@@ -60,7 +63,7 @@ class AuthenticationServiceProxy: AuthenticationServiceProxyProtocol {
                 }
             }
             
-            self.homeserver = homeserver
+            homeserverSubject.send(homeserver)
             return .success(())
         } catch AuthenticationError.SlidingSyncNotAvailable {
             MXLog.info("User entered a homeserver that isn't configured for sliding sync.")

ElementX/Sources/Services/Authentication/AuthenticationServiceProxyProtocol.swift

@@ -17,6 +17,14 @@
 import Foundation
 import MatrixRustSDK
 
+/// Represents a particular authentication flow.
+enum AuthenticationFlow {
+    /// The flow for signing in to an existing account.
+    case login
+    /// The flow for creating a new account.
+    case register
+}
+
 enum AuthenticationServiceError: Error {
     /// An error occurred during OIDC authentication.
     case oidcError(OIDCError)
@@ -29,7 +37,8 @@ enum AuthenticationServiceError: Error {
 }
 
 protocol AuthenticationServiceProxyProtocol {
-    var homeserver: LoginHomeserver { get }
+    /// The currently configured homeserver.
+    var homeserver: CurrentValuePublisher<LoginHomeserver, Never> { get }
     
     /// Sets up the service for login on the specified homeserver address.
     func configure(for homeserverAddress: String) async -> Result<Void, AuthenticationServiceError>

ElementX/Sources/Services/Authentication/MockAuthenticationServiceProxy.swift

@@ -14,27 +14,33 @@
 // limitations under the License.
 //
 
+import Combine
 import Foundation
 import MatrixRustSDK
 
 class MockAuthenticationServiceProxy: AuthenticationServiceProxyProtocol {
     let validCredentials = (username: "alice", password: "12345678")
     
-    private(set) var homeserver: LoginHomeserver = .mockMatrixDotOrg
+    private let homeserverSubject: CurrentValueSubject<LoginHomeserver, Never>
+    var homeserver: CurrentValuePublisher<LoginHomeserver, Never> { homeserverSubject.asCurrentValuePublisher() }
+    
+    init(homeserver: LoginHomeserver = .mockMatrixDotOrg) {
+        homeserverSubject = .init(homeserver)
+    }
     
     func configure(for homeserverAddress: String) async -> Result<Void, AuthenticationServiceError> {
         // Map the address to the mock homeservers
         if LoginHomeserver.mockMatrixDotOrg.address.contains(homeserverAddress) {
-            homeserver = .mockMatrixDotOrg
+            homeserverSubject.send(.mockMatrixDotOrg)
             return .success(())
         } else if LoginHomeserver.mockOIDC.address.contains(homeserverAddress) {
-            homeserver = .mockOIDC
+            homeserverSubject.send(.mockOIDC)
             return .success(())
         } else if LoginHomeserver.mockBasicServer.address.contains(homeserverAddress) {
-            homeserver = .mockBasicServer
+            homeserverSubject.send(.mockBasicServer)
             return .success(())
         } else if LoginHomeserver.mockUnsupported.address.contains(homeserverAddress) {
-            homeserver = .mockUnsupported
+            homeserverSubject.send(.mockUnsupported)
             return .success(())
         } else {
             // Otherwise fail with an invalid server.