QR Code Login Flow

ElementX/Sources/Application/AppCoordinator.swift

@@ -414,10 +414,16 @@ class AppCoordinator: AppCoordinatorProtocol, AuthenticationFlowCoordinatorDeleg
     }
 
     private func startAuthentication() {
+        let encryptionKeyProvider = EncryptionKeyProvider()
         let authenticationService = AuthenticationServiceProxy(userSessionStore: userSessionStore,
-                                                               encryptionKeyProvider: EncryptionKeyProvider(),
+                                                               encryptionKeyProvider: encryptionKeyProvider,
                                                                appSettings: appSettings)
+        let qrCodeLoginService = QRCodeLoginService(oidcConfiguration: appSettings.oidcConfiguration.rustValue,
+                                                    encryptionKeyProvider: encryptionKeyProvider,
+                                                    userSessionStore: userSessionStore)
+
         authenticationFlowCoordinator = AuthenticationFlowCoordinator(authenticationService: authenticationService,
+                                                                      qrCodeLoginService: qrCodeLoginService,
                                                                       bugReportService: ServiceLocator.shared.bugReportService,
                                                                       navigationRootCoordinator: navigationRootCoordinator,
                                                                       appMediator: appMediator,

ElementX/Sources/Application/AppSettings.swift

@@ -163,6 +163,15 @@ final class AppSettings {
         return url
     }()
 
+    private(set) lazy var oidcConfiguration = OIDCConfigurationProxy(clientName: InfoPlistReader.main.bundleDisplayName,
+                                                                     redirectURI: oidcRedirectURL,
+                                                                     clientURI: websiteURL,
+                                                                     logoURI: logoURL,
+                                                                     tosURI: acceptableUseURL,
+                                                                     policyURI: privacyURL,
+                                                                     contacts: [supportEmailAddress],
+                                                                     staticRegistrations: oidcStaticRegistrations.mapKeys { $0.absoluteString })
+
     /// A dictionary of accounts that have performed an initial sync through their proxy.
     ///
     /// This is a temporary workaround. In the future we should be able to receive a signal from the

ElementX/Sources/FlowCoordinators/AuthenticationFlowCoordinator.swift

@@ -31,6 +31,7 @@ class AuthenticationFlowCoordinator: FlowCoordinatorProtocol {
     private let appSettings: AppSettings
     private let analytics: AnalyticsService
     private let userIndicatorController: UserIndicatorControllerProtocol
+    private let qrCodeLoginService: QRCodeLoginServiceProtocol
 
     private var cancellables = Set<AnyCancellable>()
 
@@ -42,6 +43,7 @@ class AuthenticationFlowCoordinator: FlowCoordinatorProtocol {
     weak var delegate: AuthenticationFlowCoordinatorDelegate?
 
     init(authenticationService: AuthenticationServiceProxyProtocol,
+         qrCodeLoginService: QRCodeLoginServiceProtocol,
          bugReportService: BugReportServiceProtocol,
          navigationRootCoordinator: NavigationRootCoordinator,
          appMediator: AppMediatorProtocol,
@@ -55,6 +57,7 @@ class AuthenticationFlowCoordinator: FlowCoordinatorProtocol {
         self.appSettings = appSettings
         self.analytics = analytics
         self.userIndicatorController = userIndicatorController
+        self.qrCodeLoginService = qrCodeLoginService
 
         navigationStackCoordinator = NavigationStackCoordinator()
     }
@@ -106,7 +109,7 @@ class AuthenticationFlowCoordinator: FlowCoordinatorProtocol {
     }
 
     private func startQRCodeLogin() {
-        let coordinator = QRCodeLoginScreenCoordinator(parameters: .init(qrCodeLoginService: QRCodeLoginService(),
+        let coordinator = QRCodeLoginScreenCoordinator(parameters: .init(qrCodeLoginService: qrCodeLoginService,
                                                                          orientationManager: appMediator.windowManager,
                                                                          appMediator: appMediator))
         coordinator.actionsPublisher.sink { [weak self] action in
@@ -116,6 +119,13 @@ class AuthenticationFlowCoordinator: FlowCoordinatorProtocol {
             switch action {
             case .cancel:
                 navigationStackCoordinator.setSheetCoordinator(nil)
+            case .done(let userSession):
+                navigationStackCoordinator.setSheetCoordinator(nil)
+                // Since the qr code login flow includes verification
+                appSettings.hasRunIdentityConfirmationOnboarding = true
+                DispatchQueue.main.async {
+                    self.userHasSignedIn(userSession: userSession)
+                }
             }
         }
         .store(in: &cancellables)

ElementX/Sources/FlowCoordinators/OnboardingFlowCoordinator.swift

@@ -87,9 +87,9 @@ class OnboardingFlowCoordinator: FlowCoordinatorProtocol {
 
         configureStateMachine()
 
-        stateMachine.tryEvent(.next)
-
         rootNavigationStackCoordinator.setFullScreenCoverCoordinator(navigationStackCoordinator, animated: !isNewLogin)
+
+        stateMachine.tryEvent(.next)
     }
 
     func handleAppRoute(_ appRoute: AppRoute, animated: Bool) {
@@ -134,6 +134,8 @@ class OnboardingFlowCoordinator: FlowCoordinatorProtocol {
                 return .analyticsPrompt
             case (.initial, false, false, false, true):
                 return .notificationPermissions
+            case (.initial, false, false, false, false):
+                return .finished
 
             case (.identityConfirmation, _, _, _, _):
                 return .identityConfirmed

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -6725,6 +6725,11 @@ class PollInteractionHandlerMock: PollInteractionHandlerProtocol {
     }
 }
 class QRCodeLoginServiceMock: QRCodeLoginServiceProtocol {
+    var qrLoginProgressPublisher: AnyPublisher<QrLoginProgress, Never> {
+        get { return underlyingQrLoginProgressPublisher }
+        set(value) { underlyingQrLoginProgressPublisher = value }
+    }
+    var underlyingQrLoginProgressPublisher: AnyPublisher<QrLoginProgress, Never>!
 
     //MARK: - requestAuthorizationIfNeeded
 
@@ -6790,6 +6795,74 @@ class QRCodeLoginServiceMock: QRCodeLoginServiceProtocol {
             return requestAuthorizationIfNeededReturnValue
         }
     }
+    //MARK: - loginWithQRCode
+
+    var loginWithQRCodeDataUnderlyingCallsCount = 0
+    var loginWithQRCodeDataCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return loginWithQRCodeDataUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = loginWithQRCodeDataUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                loginWithQRCodeDataUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    loginWithQRCodeDataUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    var loginWithQRCodeDataCalled: Bool {
+        return loginWithQRCodeDataCallsCount > 0
+    }
+    var loginWithQRCodeDataReceivedData: Data?
+    var loginWithQRCodeDataReceivedInvocations: [Data] = []
+
+    var loginWithQRCodeDataUnderlyingReturnValue: Result<UserSessionProtocol, QRCodeLoginServiceError>!
+    var loginWithQRCodeDataReturnValue: Result<UserSessionProtocol, QRCodeLoginServiceError>! {
+        get {
+            if Thread.isMainThread {
+                return loginWithQRCodeDataUnderlyingReturnValue
+            } else {
+                var returnValue: Result<UserSessionProtocol, QRCodeLoginServiceError>? = nil
+                DispatchQueue.main.sync {
+                    returnValue = loginWithQRCodeDataUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                loginWithQRCodeDataUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    loginWithQRCodeDataUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    var loginWithQRCodeDataClosure: ((Data) async -> Result<UserSessionProtocol, QRCodeLoginServiceError>)?
+
+    func loginWithQRCode(data: Data) async -> Result<UserSessionProtocol, QRCodeLoginServiceError> {
+        loginWithQRCodeDataCallsCount += 1
+        loginWithQRCodeDataReceivedData = data
+        loginWithQRCodeDataReceivedInvocations.append(data)
+        if let loginWithQRCodeDataClosure = loginWithQRCodeDataClosure {
+            return await loginWithQRCodeDataClosure(data)
+        } else {
+            return loginWithQRCodeDataReturnValue
+        }
+    }
 }
 class RoomDirectorySearchProxyMock: RoomDirectorySearchProxyProtocol {
     var resultsPublisher: CurrentValuePublisher<[RoomDirectorySearchResult], Never> {

ElementX/Sources/Other/Extensions/AVMetadataMachineReadableCodeObject.swift

@@ -0,0 +1,154 @@
+//
+// 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.
+//
+
+// Helpers to remove ECI headers from QR Code raw data
+// https://gist.github.com/PetrusM/267e2ee8c1d8b5dca17eac085afa7d7c
+import AVKit
+import Foundation
+
+extension AVMetadataMachineReadableCodeObject {
+    var binaryValue: Data? {
+        switch type {
+        case .qr:
+            guard let binaryValueWithProtocol else {
+                return nil
+            }
+            return removeQrProtocolData(binaryValueWithProtocol)
+        case .aztec:
+            guard let string = stringValue
+            else { return nil }
+            return string.data(using: String.Encoding.isoLatin1)
+        default:
+            return nil
+        }
+    }
+
+    var binaryValueWithProtocol: Data? {
+        guard let descriptor else {
+            return nil
+        }
+        switch type {
+        case .qr:
+            return (descriptor as? CIQRCodeDescriptor)?.errorCorrectedPayload
+        case .aztec:
+            return (descriptor as? CIAztecCodeDescriptor)?.errorCorrectedPayload
+        case .pdf417:
+            return (descriptor as? CIPDF417CodeDescriptor)?.errorCorrectedPayload
+        case .dataMatrix:
+            return (descriptor as? CIDataMatrixCodeDescriptor)?.errorCorrectedPayload
+        default:
+            return nil
+        }
+    }
+
+    private func removeQrProtocolData(_ input: Data) -> Data? {
+        var halves = input.halfBytes()
+        var batch = takeBatch(&halves)
+        var output = batch
+        while !batch.isEmpty {
+            batch = takeBatch(&halves)
+            output.append(contentsOf: batch)
+        }
+        return Data(output)
+    }
+
+    private func takeBatch(_ input: inout [HalfByte]) -> [UInt8] {
+        guard let version = (descriptor as? CIQRCodeDescriptor)?.symbolVersion else {
+            return []
+        }
+        let characterCountLength = version > 9 ? 16 : 8
+        let mode = input.remove(at: 0)
+        var output = [UInt8]()
+        switch mode.value {
+        // If there is not only binary in the QRCode, then cases should be added here.
+        case 0x04: // Binary
+            let charactersCount: UInt16
+            if characterCountLength == 8 {
+                charactersCount = UInt16(input.takeUInt8())
+            } else {
+                charactersCount = UInt16(input.takeUInt16())
+            }
+            for _ in 0..<charactersCount {
+                output.append(input.takeUInt8())
+            }
+            return output
+        case 0x00: // End of data
+            return []
+        default:
+            return []
+        }
+    }
+}
+
+private struct HalfByte {
+    let value: UInt8
+}
+
+private extension [HalfByte] {
+    mutating func takeUInt8() -> UInt8 {
+        let left = remove(at: 0)
+        let right = remove(at: 0)
+        return UInt8(left, right)
+    }
+
+    mutating func takeUInt16() -> UInt16 {
+        let first = remove(at: 0)
+        let second = remove(at: 0)
+        let third = remove(at: 0)
+        let fourth = remove(at: 0)
+        return UInt16(first, second, third, fourth)
+    }
+}
+
+private extension Data {
+    func halfBytes() -> [HalfByte] {
+        var result = [HalfByte]()
+        forEach { (byte: UInt8) in
+            result.append(contentsOf: byte.halfBytes())
+        }
+        return result
+    }
+
+    init(_ halves: [HalfByte]) {
+        var halves = halves
+        var result = [UInt8]()
+        while halves.count > 1 {
+            result.append(halves.takeUInt8())
+        }
+        self.init(result)
+    }
+}
+
+private extension UInt8 {
+    func halfBytes() -> [HalfByte] {
+        [HalfByte(value: self >> 4), HalfByte(value: self & 0x0F)]
+    }
+
+    init(_ left: HalfByte, _ right: HalfByte) {
+        self.init((left.value << 4) + (right.value & 0x0F))
+    }
+}
+
+private extension UInt16 {
+    init(_ first: HalfByte, _ second: HalfByte, _ third: HalfByte, _ fourth: HalfByte) {
+        let first = UInt16(first.value) << 12
+        let second = UInt16(second.value) << 8
+        let third = UInt16(third.value) << 4
+        let fourth = UInt16(fourth.value) & 0x0F
+        let result = first + second + third + fourth
+        self.init(result)
+    }
+}

ElementX/Sources/Screens/QRCodeLoginScreen/QRCodeLoginScreenCoordinator.swift

@@ -27,6 +27,7 @@ struct QRCodeLoginScreenCoordinatorParameters {
 
 enum QRCodeLoginScreenCoordinatorAction {
     case cancel
+    case done(userSession: UserSessionProtocol)
 }
 
 final class QRCodeLoginScreenCoordinator: CoordinatorProtocol {
@@ -54,6 +55,8 @@ final class QRCodeLoginScreenCoordinator: CoordinatorProtocol {
             switch action {
             case .cancel:
                 self.actionsSubject.send(.cancel)
+            case .done(let userSession):
+                self.actionsSubject.send(.done(userSession: userSession))
             }
         }
         .store(in: &cancellables)

ElementX/Sources/Screens/QRCodeLoginScreen/QRCodeLoginScreenModels.swift

@@ -18,6 +18,7 @@ import Foundation
 
 enum QRCodeLoginScreenViewModelAction {
     case cancel
+    case done(userSession: UserSessionProtocol)
 }
 
 struct QRCodeLoginScreenViewState: BindableState {
@@ -53,6 +54,12 @@ struct QRCodeLoginScreenViewState: BindableState {
         AttributedString(L10n.screenQrCodeLoginConnectionNoteSecureStateListItem2),
         AttributedString(L10n.screenQrCodeLoginConnectionNoteSecureStateListItem3)
     ]
+
+    var bindings = QRCodeLoginScreenViewStateBindings()
+}
+
+struct QRCodeLoginScreenViewStateBindings {
+    var qrResult: Data?
 }
 
 enum QRCodeLoginScreenViewAction {
@@ -108,4 +115,13 @@ enum QRCodeLoginState: Equatable {
             return false
         }
     }
+
+    var isScanning: Bool {
+        switch self {
+        case .scan(let state):
+            return state == .scanning
+        default:
+            return false
+        }
+    }
 }