Add a WebRegistrationScreen (not included in the flow yet). (#3281)

ElementX/Sources/Services/Authentication/AuthenticationService.swift

@@ -40,15 +40,21 @@ class AuthenticationService: AuthenticationServiceProtocol {
             
             let client = try await makeClientBuilder().build(homeserverAddress: homeserverAddress)
             let loginDetails = await client.homeserverLoginDetails()
+            let elementWellKnown = await client.getElementWellKnown()
             
             MXLog.info("Sliding sync: \(client.slidingSyncVersion())")
             
-            if loginDetails.supportsOidcLogin() {
-                homeserver.loginMode = .oidc
+            homeserver.loginMode = if loginDetails.supportsOidcLogin() {
+                .oidc
             } else if loginDetails.supportsPasswordLogin() {
-                homeserver.loginMode = .password
+                .password
             } else {
-                homeserver.loginMode = .unsupported
+                .unsupported
+            }
+            
+            homeserver.registrationHelperURL = switch elementWellKnown {
+            case .success(let wellKnown): wellKnown.registrationHelperUrl.flatMap(URL.init)
+            case .failure: nil
             }
             
             self.client = client
@@ -125,6 +131,25 @@ class AuthenticationService: AuthenticationServiceProtocol {
         }
     }
     
+    func completeWebRegistration(using credentials: WebRegistrationCredentials) async -> Result<any UserSessionProtocol, AuthenticationServiceError> {
+        guard let client else { return .failure(.failedLoggingIn) }
+        let session = Session(accessToken: credentials.accessToken,
+                              refreshToken: nil,
+                              userId: credentials.userID,
+                              deviceId: credentials.deviceID,
+                              homeserverUrl: client.homeserver(),
+                              oidcData: nil,
+                              slidingSyncVersion: client.slidingSyncVersion())
+        
+        do {
+            try await client.restoreSession(session: session)
+            return await userSession(for: client)
+        } catch {
+            MXLog.error("Failed restoring the client using the provided credentials.")
+            return .failure(.failedUsingWebCredentials)
+        }
+    }
+    
     // MARK: - Private
     
     private func makeClientBuilder() -> AuthenticationClientBuilder {

ElementX/Sources/Services/Authentication/AuthenticationServiceProtocol.swift

@@ -27,6 +27,7 @@ enum AuthenticationServiceError: Error {
     case accountDeactivated
     case failedLoggingIn
     case sessionTokenRefreshNotSupported
+    case failedUsingWebCredentials
 }
 
 protocol AuthenticationServiceProtocol {
@@ -43,6 +44,8 @@ protocol AuthenticationServiceProtocol {
     func loginWithOIDCCallback(_ callbackURL: URL, data: OIDCAuthorizationDataProxy) async -> Result<UserSessionProtocol, AuthenticationServiceError>
     /// Performs a password login using the current homeserver.
     func login(username: String, password: String, initialDeviceName: String?, deviceID: String?) async -> Result<UserSessionProtocol, AuthenticationServiceError>
+    /// Completes registration using the credentials obtained via the helper URL.
+    func completeWebRegistration(using credentials: WebRegistrationCredentials) async -> Result<UserSessionProtocol, AuthenticationServiceError>
 }
 
 // MARK: - OIDC

ElementX/Sources/Services/Authentication/MockAuthenticationService.swift

@@ -9,7 +9,7 @@ import Combine
 import Foundation
 import MatrixRustSDK
 
-class MockAuthenticationServiceProxy: AuthenticationServiceProtocol {
+class MockAuthenticationService: AuthenticationServiceProtocol {
     let validCredentials = (username: "alice", password: "12345678")
     
     private let homeserverSubject: CurrentValueSubject<LoginHomeserver, Never>
@@ -58,4 +58,8 @@ class MockAuthenticationServiceProxy: AuthenticationServiceProtocol {
         let userSession = UserSessionMock(.init(clientProxy: ClientProxyMock(.init(userID: username))))
         return .success(userSession)
     }
+    
+    func completeWebRegistration(using credentials: WebRegistrationCredentials) async -> Result<any UserSessionProtocol, AuthenticationServiceError> {
+        .failure(.failedLoggingIn)
+    }
 }

ElementX/Sources/Services/Client/Client.swift

@@ -0,0 +1,32 @@
+//
+// Copyright 2024 New Vector Ltd.
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+// Please see LICENSE in the repository root for full details.
+//
+
+import Foundation
+import MatrixRustSDK
+
+extension ClientProtocol {
+    func getElementWellKnown() async -> Result<MatrixRustSDK.ElementWellKnown, ClientProxyError> {
+        do {
+            let serverName = if let userIDServerName = try? userIdServerName() {
+                "https://\(userIDServerName)"
+            } else {
+                server()
+            }
+            
+            guard let serverName,
+                  let url = URL(string: serverName)?.appending(path: "/.well-known/element/element.json") else {
+                return .failure(.invalidServerName)
+            }
+            
+            let response = try await getUrl(url: url.absoluteString)
+            let wellKnown = try makeElementWellKnown(string: response)
+            return .success(wellKnown)
+        } catch {
+            return .failure(.sdkError(error))
+        }
+    }
+}

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -594,20 +594,7 @@ class ClientProxy: ClientProxyProtocol {
     }
     
     func getElementWellKnown() async -> Result<ElementWellKnown?, ClientProxyError> {
-        guard let userIDServerName,
-              var url = URL(string: "https://\(userIDServerName)") else {
-            return .failure(.invalidUserIDServerName)
-        }
-        
-        url.append(path: "/.well-known/element/element.json")
-        
-        do {
-            let response = try await client.getUrl(url: url.absoluteString)
-            let sdkWellKnown = try makeElementWellKnown(string: response)
-            return .success(ElementWellKnown(sdkWellKnown))
-        } catch {
-            return .failure(.sdkError(error))
-        }
+        await client.getElementWellKnown().map(ElementWellKnown.init)
     }
         
     // MARK: Ignored users

ElementX/Sources/Services/Client/ClientProxyProtocol.swift

@@ -32,7 +32,7 @@ enum ClientProxyError: Error {
     case sdkError(Error)
     
     case invalidMedia
-    case invalidUserIDServerName
+    case invalidServerName
     case failedUploadingMedia(Error, MatrixErrorCode)
     case roomPreviewIsPrivate
 }

ElementX/Sources/Services/Client/ElementWellKnown.swift

@@ -19,8 +19,10 @@ struct ElementWellKnown {
     }
     
     let call: Call?
+    let registrationHelperURL: URL?
     
     init?(_ wellKnown: MatrixRustSDK.ElementWellKnown) {
-        call = Call(wellKnown.call)
+        call = wellKnown.call.flatMap(Call.init)
+        registrationHelperURL = wellKnown.registrationHelperUrl.flatMap(URL.init)
     }
 }