Adopt sliding sync discovery for authentication.

ElementX/Sources/Services/Authentication/AuthenticationClientBuilder.swift

@@ -0,0 +1,88 @@
+//
+// Copyright 2024 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 MatrixRustSDK
+
+/// A wrapper around `ClientBuilder` to share reusable code between Normal and QR logins.
+struct AuthenticationClientBuilder {
+    let sessionDirectories: SessionDirectories
+    let passphrase: String
+    let clientSessionDelegate: ClientSessionDelegate
+    
+    let appSettings: AppSettings
+    let appHooks: AppHooks
+    
+    /// Builds a Client for login using OIDC or password authentication.
+    func build(homeserverAddress: String) async throws -> Client {
+        if appSettings.slidingSyncDiscovery == .forceNative {
+            return try await makeClientBuilder(slidingSync: .forceNative).serverNameOrHomeserverUrl(serverNameOrUrl: homeserverAddress).build()
+        }
+        
+        if appSettings.slidingSyncDiscovery == .native {
+            do {
+                return try await makeClientBuilder(slidingSync: .discoverNative).serverNameOrHomeserverUrl(serverNameOrUrl: homeserverAddress).build()
+            } catch {
+                MXLog.warning("Native sliding sync not available: \(error)")
+                MXLog.info("Falling back to a sliding sync proxy.")
+            }
+        }
+        
+        return try await makeClientBuilder(slidingSync: .discoverProxy).serverNameOrHomeserverUrl(serverNameOrUrl: homeserverAddress).build()
+    }
+    
+    /// Builds a Client, authenticating with the given QR code data.
+    func buildWithQRCode(qrCodeData: QrCodeData,
+                         oidcConfiguration: OIDCConfigurationProxy,
+                         progressListener: QrLoginProgressListenerProxy) async throws -> Client {
+        if appSettings.slidingSyncDiscovery == .forceNative {
+            return try await makeClientBuilder(slidingSync: .forceNative).buildWithQrCode(qrCodeData: qrCodeData,
+                                                                                          oidcConfiguration: oidcConfiguration.rustValue,
+                                                                                          progressListener: progressListener)
+        }
+        
+        if appSettings.slidingSyncDiscovery == .native {
+            do {
+                return try await makeClientBuilder(slidingSync: .discoverNative).buildWithQrCode(qrCodeData: qrCodeData,
+                                                                                                 oidcConfiguration: oidcConfiguration.rustValue,
+                                                                                                 progressListener: progressListener)
+            } catch HumanQrLoginError.SlidingSyncNotAvailable {
+                MXLog.warning("Native sliding sync not available")
+                MXLog.info("Falling back to a sliding sync proxy.")
+            } catch {
+                throw error
+            }
+        }
+        
+        return try await makeClientBuilder(slidingSync: .discoverProxy).buildWithQrCode(qrCodeData: qrCodeData,
+                                                                                        oidcConfiguration: oidcConfiguration.rustValue,
+                                                                                        progressListener: progressListener)
+    }
+    
+    // MARK: - Private
+    
+    /// The base builder configuration used for authentication within the app.
+    private func makeClientBuilder(slidingSync: ClientBuilderSlidingSync) -> ClientBuilder {
+        ClientBuilder
+            .baseBuilder(httpProxy: appSettings.websiteURL.globalProxy,
+                         slidingSync: slidingSync,
+                         sessionDelegate: clientSessionDelegate,
+                         appHooks: appHooks)
+            .sessionPaths(dataPath: sessionDirectories.dataPath,
+                          cachePath: sessionDirectories.cachePath)
+            .passphrase(passphrase: passphrase)
+    }
+}

ElementX/Sources/Services/Authentication/AuthenticationService.swift

@@ -47,9 +47,11 @@ class AuthenticationService: AuthenticationServiceProtocol {
         do {
             var homeserver = LoginHomeserver(address: homeserverAddress, loginMode: .unknown)
             
-            let client = try await makeClientBuilder().serverNameOrHomeserverUrl(serverNameOrUrl: homeserverAddress).build()
+            let client = try await makeClientBuilder().build(homeserverAddress: homeserverAddress)
             let loginDetails = await client.homeserverLoginDetails()
             
+            MXLog.info("Sliding sync: \(client.slidingSyncVersion())")
+            
             if loginDetails.supportsOidcLogin() {
                 homeserver.loginMode = .oidc
             } else if loginDetails.supportsPasswordLogin() {
@@ -64,8 +66,8 @@ class AuthenticationService: AuthenticationServiceProtocol {
         } catch ClientBuildError.WellKnownDeserializationError(let error) {
             MXLog.error("The user entered a server with an invalid well-known file: \(error)")
             return .failure(.invalidWellKnown(error))
-        } catch ClientBuildError.SlidingSyncNotAvailable {
-            MXLog.info("User entered a homeserver that isn't configured for sliding sync.")
+        } catch ClientBuildError.SlidingSyncVersion(let error) {
+            MXLog.info("User entered a homeserver that isn't configured for sliding sync: \(error)")
             return .failure(.slidingSyncNotAvailable)
         } catch {
             MXLog.error("Failed configuring a server: \(error)")
@@ -138,20 +140,16 @@ class AuthenticationService: AuthenticationServiceProtocol {
     
     // MARK: - Private
     
-    private func makeClientBuilder() -> ClientBuilder {
+    private func makeClientBuilder() -> AuthenticationClientBuilder {
         // Use a fresh session directory each time the user enters a different server
         // so that caches (e.g. server versions) are always fresh for the new server.
         rotateSessionDirectory()
         
-        return ClientBuilder
-            .baseBuilder(httpProxy: appSettings.websiteURL.globalProxy,
-                         slidingSync: appSettings.simplifiedSlidingSyncEnabled ? .simplified : .discovered,
-                         slidingSyncProxy: appSettings.slidingSyncProxyURL,
-                         sessionDelegate: userSessionStore.clientSessionDelegate,
-                         appHooks: appHooks)
-            .sessionPaths(dataPath: sessionDirectories.dataPath,
-                          cachePath: sessionDirectories.cachePath)
-            .passphrase(passphrase: passphrase)
+        return AuthenticationClientBuilder(sessionDirectories: sessionDirectories,
+                                           passphrase: passphrase,
+                                           clientSessionDelegate: userSessionStore.clientSessionDelegate,
+                                           appSettings: appSettings,
+                                           appHooks: appHooks)
     }
     
     private func rotateSessionDirectory() {

ElementX/Sources/Services/QRCode/QRCodeLoginService.swift

@@ -57,9 +57,10 @@ final class QRCodeLoginService: QRCodeLoginServiceProtocol {
         }
         
         do {
-            let client = try await makeClientBuilder().buildWithQrCode(qrCodeData: qrData,
-                                                                       oidcConfiguration: appSettings.oidcConfiguration.rustValue,
+            let client = try await makeClientBuilder().buildWithQRCode(qrCodeData: qrData,
+                                                                       oidcConfiguration: appSettings.oidcConfiguration,
                                                                        progressListener: listener)
+            MXLog.info("Sliding sync: \(client.slidingSyncVersion())")
             return await userSession(for: client)
         } catch let error as HumanQrLoginError {
             MXLog.error("QRCode login error: \(error)")
@@ -72,20 +73,16 @@ final class QRCodeLoginService: QRCodeLoginServiceProtocol {
     
     // MARK: - Private
     
-    private func makeClientBuilder() -> ClientBuilder {
+    private func makeClientBuilder() -> AuthenticationClientBuilder {
         // Use a fresh session directory each time the user scans a QR code to ensure caches
         // (e.g. server versions) are always fresh in case a different server is used.
         rotateSessionDirectory()
         
-        return ClientBuilder
-            .baseBuilder(httpProxy: appSettings.websiteURL.globalProxy,
-                         slidingSync: appSettings.simplifiedSlidingSyncEnabled ? .simplified : .discovered,
-                         slidingSyncProxy: appSettings.slidingSyncProxyURL,
-                         sessionDelegate: userSessionStore.clientSessionDelegate,
-                         appHooks: appHooks)
-            .sessionPaths(dataPath: sessionDirectories.dataPath,
-                          cachePath: sessionDirectories.cachePath)
-            .passphrase(passphrase: passphrase)
+        return AuthenticationClientBuilder(sessionDirectories: sessionDirectories,
+                                           passphrase: passphrase,
+                                           clientSessionDelegate: userSessionStore.clientSessionDelegate,
+                                           appSettings: appSettings,
+                                           appHooks: appHooks)
     }
     
     private func rotateSessionDirectory() {