Add support for initiating and responding to user verification requests (#3759)

2026-11-02 20:39:24 +00:00 · 2025-02-10 20:07:11 +02:00
parent 22d0fae423
commit 8680d8437b
94 changed files with 528 additions and 208 deletions
@@ -14,13 +14,26 @@ enum SessionVerificationScreenCoordinatorAction {
 }

 enum SessionVerificationScreenFlow {
-    case initiator
-    case responder(details: SessionVerificationRequestDetails)
+    case deviceInitiator
+    case deviceResponder(requestDetails: SessionVerificationRequestDetails)
+    case userIntiator(userID: String)
+    case userResponder(requestDetails: SessionVerificationRequestDetails)
+    
+    var isResponder: Bool {
+        switch self {
+        case .deviceInitiator, .userIntiator:
+            false
+        case .deviceResponder, .userResponder:
+            true
+        }
+    }
 }

 struct SessionVerificationScreenCoordinatorParameters {
    let sessionVerificationControllerProxy: SessionVerificationControllerProxyProtocol
    let flow: SessionVerificationScreenFlow
+    let appSettings: AppSettings
+    let mediaProvider: MediaProviderProtocol
 }

 final class SessionVerificationScreenCoordinator: CoordinatorProtocol {
@@ -35,7 +48,9 @@ final class SessionVerificationScreenCoordinator: CoordinatorProtocol {
    
    init(parameters: SessionVerificationScreenCoordinatorParameters) {
        viewModel = SessionVerificationScreenViewModel(sessionVerificationControllerProxy: parameters.sessionVerificationControllerProxy,
-                                                       flow: parameters.flow)
+                                                       flow: parameters.flow,
+                                                       appSettings: parameters.appSettings,
+                                                       mediaProvider: parameters.mediaProvider)
    }
    
    // MARK: - Public
@@ -20,17 +20,25 @@ enum SessionVerificationScreenViewAction {
    case restart
    case accept
    case decline
+    case cancel
    case done
 }

 struct SessionVerificationScreenViewState: BindableState {
    let flow: SessionVerificationScreenFlow
+    let learnMoreURL: URL
+    
    var verificationState: SessionVerificationScreenStateMachine.State
    
    var headerIcon: (keyPath: KeyPath<CompoundIcons, Image>, style: BigIcon.Style) {
        switch verificationState {
        case .initial:
-            return (\.devices, .defaultSolid)
+            switch flow {
+            case .deviceInitiator, .deviceResponder:
+                return (\.devices, .defaultSolid)
+            case .userIntiator, .userResponder:
+                return (\.userProfileSolid, .defaultSolid)
+            }
        case .acceptingVerificationRequest:
            return (\.devices, .defaultSolid)
        case .requestingVerification:
@@ -56,25 +64,31 @@ struct SessionVerificationScreenViewState: BindableState {
        }
    }
    
+    var titleAccessibilityIdentifier: String {
+        verificationState == .verified ? A11yIdentifiers.sessionVerificationScreen.verificationComplete : ""
+    }
+    
    var title: String? {
        switch verificationState {
        case .initial:
            switch flow {
-            case .initiator:
+            case .deviceInitiator:
                return L10n.screenSessionVerificationUseAnotherDeviceTitle
-            case .responder:
+            case .userIntiator:
+                return L10n.screenSessionVerificationUserInitiatorTitle
+            case .deviceResponder, .userResponder:
                return L10n.screenSessionVerificationRequestTitle
            }
        case .acceptingVerificationRequest:
-            return L10n.screenSessionVerificationWaitingAnotherDeviceTitle
+            return waitingTitle
        case .requestingVerification:
-            return L10n.screenSessionVerificationWaitingToAcceptTitle
+            return waitingTitle
        case .verificationRequestAccepted:
            return L10n.screenSessionVerificationCompareEmojisTitle
        case .startingSasVerification:
-            return nil
+            return waitingTitle
        case .sasVerificationStarted:
-            return nil
+            return waitingTitle
        case .showingChallenge:
            return L10n.screenSessionVerificationCompareEmojisTitle
        case .acceptingChallenge:
@@ -84,47 +98,71 @@ struct SessionVerificationScreenViewState: BindableState {
        case .verified:
            return L10n.commonVerificationComplete
        case .cancelling:
-            return nil
+            return waitingTitle
        case .cancelled:
            return L10n.commonVerificationFailed
        }
    }
    
-    var titleAccessibilityIdentifier: String {
-        verificationState == .verified ? A11yIdentifiers.sessionVerificationScreen.verificationComplete : ""
+    private var waitingTitle: String {
+        switch flow {
+        case .deviceInitiator, .deviceResponder:
+            return L10n.screenSessionVerificationWaitingOtherDeviceTitle
+        case .userIntiator, .userResponder:
+            return L10n.screenSessionVerificationWaitingOtherUserTitle
+        }
    }
        
    var message: String {
        switch verificationState {
        case .initial:
            switch flow {
-            case .initiator:
+            case .deviceInitiator:
                return L10n.screenSessionVerificationUseAnotherDeviceSubtitle
-            case .responder:
+            case .userIntiator:
+                return L10n.screenSessionVerificationUserInitiatorSubtitle
+            case .deviceResponder:
                return L10n.screenSessionVerificationRequestSubtitle
+            case .userResponder:
+                return L10n.screenSessionVerificationUserResponderSubtitle
            }
        case .acceptingVerificationRequest:
-            return L10n.screenSessionVerificationWaitingAnotherDeviceSubtitle
+            return waitingMessage
        case .requestingVerification:
-            return L10n.screenSessionVerificationWaitingToAcceptSubtitle
+            return waitingMessage
        case .verificationRequestAccepted:
            return L10n.screenSessionVerificationRequestAcceptedSubtitle
        case .startingSasVerification:
-            return L10n.commonWaiting
+            return waitingMessage
        case .sasVerificationStarted:
-            return L10n.commonWaiting
+            return waitingMessage
        case .acceptingChallenge:
            return L10n.screenSessionVerificationCompareEmojisSubtitle
        case .decliningChallenge:
            return L10n.screenSessionVerificationCompareEmojisSubtitle
        case .cancelling:
-            return L10n.commonWaiting
+            return waitingMessage
        case .showingChallenge:
-            return L10n.screenSessionVerificationCompareEmojisSubtitle
+            switch flow {
+            case .deviceInitiator, .deviceResponder:
+                return L10n.screenSessionVerificationCompareEmojisSubtitle
+            case .userIntiator, .userResponder:
+                return L10n.screenSessionVerificationCompareEmojisUserSubtitle
+            }
        case .verified:
-            return L10n.screenSessionVerificationCompleteSubtitle
+            switch flow {
+            case .deviceInitiator, .deviceResponder:
+                return L10n.screenSessionVerificationCompleteSubtitle
+            case .userIntiator, .userResponder:
+                return L10n.screenSessionVerificationCompleteUserSubtitle
+            }
+            
        case .cancelled:
            return L10n.screenSessionVerificationFailedSubtitle
        }
    }
+    
+    private var waitingMessage: String {
+        L10n.screenSessionVerificationWaitingSubtitle
+    }
 }
@@ -24,13 +24,18 @@ class SessionVerificationScreenViewModel: SessionVerificationViewModelType, Sess

    init(sessionVerificationControllerProxy: SessionVerificationControllerProxyProtocol,
         flow: SessionVerificationScreenFlow,
+         appSettings: AppSettings,
+         mediaProvider: MediaProviderProtocol,
         verificationState: SessionVerificationScreenStateMachine.State = .initial) {
        self.sessionVerificationControllerProxy = sessionVerificationControllerProxy
        self.flow = flow
        
        stateMachine = SessionVerificationScreenStateMachine(state: verificationState)
        
-        super.init(initialViewState: .init(flow: flow, verificationState: verificationState))
+        super.init(initialViewState: .init(flow: flow,
+                                           learnMoreURL: appSettings.encryptionURL,
+                                           verificationState: verificationState),
+                   mediaProvider: mediaProvider)
        
        setupStateMachine()
        
@@ -63,10 +68,13 @@ class SessionVerificationScreenViewModel: SessionVerificationViewModelType, Sess
            }
            .store(in: &cancellables)
        
-        if case .responder(let details) = flow {
+        switch flow {
+        case .deviceResponder(let details), .userResponder(let details):
            Task {
                await self.sessionVerificationControllerProxy.acknowledgeVerificationRequest(details: details)
            }
+        default:
+            break
        }
    }
    
@@ -86,6 +94,9 @@ class SessionVerificationScreenViewModel: SessionVerificationViewModelType, Sess
            stateMachine.processEvent(.acceptChallenge)
        case .decline:
            stateMachine.processEvent(.declineChallenge)
+        case .cancel:
+            stateMachine.processEvent(.cancel)
+            actionsSubject.send(.finished)
        case .done:
            actionsSubject.send(.finished)
        }
@@ -112,7 +123,15 @@ class SessionVerificationScreenViewModel: SessionVerificationViewModelType, Sess
            case (.initial, .acceptVerificationRequest, .acceptingVerificationRequest):
                acceptVerificationRequest()
            case (.initial, .requestVerification, .requestingVerification):
-                requestVerification()
+                Task {
+                    switch await self.requestVerification() {
+                    case .success:
+                        // Need to wait for the callback from the remote
+                        break
+                    case .failure:
+                        self.stateMachine.processEvent(.didFail)
+                    }
+                }
            case (.verificationRequestAccepted, .startSasVerification, .startingSasVerification):
                startSasVerification()
            case (.showingChallenge, .acceptChallenge, .acceptingChallenge):
@@ -124,8 +143,11 @@ class SessionVerificationScreenViewModel: SessionVerificationViewModelType, Sess
            case (_, _, .verified):
                actionsSubject.send(.finished)
            case (.initial, _, .cancelled):
-                if case .responder = flow {
+                switch flow {
+                case .deviceResponder, .userResponder:
                    actionsSubject.send(.finished)
+                default:
+                    break
                }
            default:
                break
@@ -139,7 +161,7 @@ class SessionVerificationScreenViewModel: SessionVerificationViewModelType, Sess
    
    private func acceptVerificationRequest() {
        Task {
-            guard case .responder = flow else {
+            guard flow.isResponder else {
                fatalError("Incorrect API usage.")
            }
            
@@ -152,15 +174,14 @@ class SessionVerificationScreenViewModel: SessionVerificationViewModelType, Sess
        }
    }
    
-    private func requestVerification() {
-        Task {
-            switch await sessionVerificationControllerProxy.requestVerification() {
-            case .success:
-                // Need to wait for the callback from the remote
-                break
-            case .failure:
-                stateMachine.processEvent(.didFail)
-            }
+    private func requestVerification() async -> Result<Void, SessionVerificationControllerProxyError> {
+        switch flow {
+        case .deviceInitiator:
+            return await sessionVerificationControllerProxy.requestDeviceVerification()
+        case .userIntiator(let userID):
+            return await sessionVerificationControllerProxy.requestUserVerification(userID)
+        default:
+            fatalError("Incorrect API usage.")
        }
    }
    
@@ -14,8 +14,44 @@ struct SessionVerificationRequestDetailsView: View {
    private let outerShape = RoundedRectangle(cornerRadius: 8)
    
    let details: SessionVerificationRequestDetails
+    let isUserVerification: Bool
+    let mediaProvider: MediaProviderProtocol?
    
    var body: some View {
+        if isUserVerification {
+            userRequestDetails
+        } else {
+            deviceRequestDetails
+        }
+    }
+    
+    private var userRequestDetails: some View {
+        HStack(spacing: 12) {
+            LoadableAvatarImage(url: details.senderProfile.avatarURL,
+                                name: details.senderProfile.displayName,
+                                contentID: details.senderProfile.userID,
+                                avatarSize: .user(on: .sessionVerification),
+                                mediaProvider: mediaProvider)
+            
+            VStack(alignment: .leading, spacing: 0) {
+                Text(details.senderProfile.displayName ?? details.senderProfile.userID)
+                    .font(.compound.bodySM)
+                    .foregroundColor(.compound.textSecondary)
+                
+                if details.senderProfile.displayName != nil {
+                    Text(details.senderProfile.userID)
+                        .font(.compound.bodyMD)
+                        .foregroundColor(.compound.textPrimary)
+                }
+            }
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding(12)
+        .background(.compound.bgSubtleSecondary)
+        .clipShape(outerShape)
+    }
+    
+    private var deviceRequestDetails: some View {
        VStack(spacing: 24) {
            VStack(alignment: .leading, spacing: 12) {
                HStack(spacing: 16) {
@@ -26,7 +62,8 @@ struct SessionVerificationRequestDetailsView: View {
                        .background(.compound.bgSubtleSecondary)
                        .clipShape(RoundedRectangle(cornerRadius: 8))
                    
-                    Text(details.displayName ?? details.senderID)
+                    let displayName = isUserVerification ? details.senderProfile.displayName : details.deviceDisplayName
+                    Text(displayName ?? details.senderProfile.userID)
                        .font(.compound.bodyMDSemibold)
                        .foregroundColor(.compound.textPrimary)
                        .frame(maxWidth: .infinity, alignment: .leading)
@@ -60,6 +97,8 @@ struct SessionVerificationRequestDetailsView: View {
                    .stroke(.compound.borderDisabled)
            }
            
+            .font(.compound.bodyMDSemibold)
+            
            Text(L10n.screenSessionVerificationRequestFooter)
                .font(.compound.bodyMDSemibold)
                .foregroundColor(.compound.textPrimary)
@@ -68,13 +107,25 @@ struct SessionVerificationRequestDetailsView: View {
 }

 struct SessionVerificationRequestDetailsView_Previews: PreviewProvider, TestablePreview {
+    static let details = SessionVerificationRequestDetails(senderProfile: UserProfileProxy(userID: "@bob:matrix.org",
+                                                                                           displayName: "Billy bob",
+                                                                                           avatarURL: .mockMXCUserAvatar),
+                                                           flowID: "123",
+                                                           deviceID: "CODEMISTAKE",
+                                                           deviceDisplayName: "Bob's Element X iOS",
+                                                           firstSeenDate: .init(timeIntervalSince1970: 0))
+    
    static var previews: some View {
-        let details = SessionVerificationRequestDetails(senderID: "@bob:matrix.org",
-                                                        flowID: "123",
-                                                        deviceID: "CODEMISTAKE",
-                                                        displayName: "Bob's Element X iOS",
-                                                        firstSeenDate: .init(timeIntervalSince1970: 0))
+        SessionVerificationRequestDetailsView(details: details,
+                                              isUserVerification: true,
+                                              mediaProvider: MediaProviderMock(configuration: .init()))
+            .padding()
+            .previewDisplayName("User")
        
-        SessionVerificationRequestDetailsView(details: details)
+        SessionVerificationRequestDetailsView(details: details,
+                                              isUserVerification: false,
+                                              mediaProvider: MediaProviderMock(configuration: .init()))
+            .padding()
+            .previewDisplayName("Device")
    }
 }
@@ -25,10 +25,24 @@ struct SessionVerificationScreen: View {
        .backgroundStyle(.compound.bgCanvasDefault)
        .interactiveDismissDisabled()
        .navigationBarBackButtonHidden(context.viewState.verificationState == .verified)
+        .toolbar { toolbar }
    }
    
    // MARK: - Private
    
+    private var toolbar: some ToolbarContent {
+        ToolbarItem(placement: .cancellationAction) {
+            switch context.viewState.flow {
+            case .userIntiator, .userResponder:
+                Button(L10n.actionCancel) {
+                    context.send(viewAction: .cancel)
+                }
+            default:
+                EmptyView()
+            }
+        }
+    }
+    
    @ViewBuilder
    private var screenHeader: some View {
        VStack(spacing: 0) {
@@ -55,11 +69,23 @@ struct SessionVerificationScreen: View {
        switch context.viewState.verificationState {
        case .initial:
            switch context.viewState.flow {
-            case .responder(let details):
-                SessionVerificationRequestDetailsView(details: details)
+            case .deviceResponder(let details):
+                SessionVerificationRequestDetailsView(details: details,
+                                                      isUserVerification: false,
+                                                      mediaProvider: context.mediaProvider)
+            case .userResponder(let details):
+                SessionVerificationRequestDetailsView(details: details,
+                                                      isUserVerification: true,
+                                                      mediaProvider: context.mediaProvider)
+            case .userIntiator:
+                Button(L10n.actionLearnMore) {
+                    UIApplication.shared.open(context.viewState.learnMoreURL)
+                }
+                .buttonStyle(.compound(.plain))
            default:
                EmptyView()
            }
+            
        case .showingChallenge(let emojis), .acceptingChallenge(let emojis), .decliningChallenge(let emojis):
            emojisPanel(with: emojis)
                .accessibilityIdentifier(A11yIdentifiers.sessionVerificationScreen.emojiWrapper)
@@ -89,13 +115,13 @@ struct SessionVerificationScreen: View {
        switch context.viewState.verificationState {
        case .initial:
            switch context.viewState.flow {
-            case .initiator:
+            case .deviceInitiator, .userIntiator:
                Button(L10n.actionStartVerification) {
                    context.send(viewAction: .requestVerification)
                }
                .buttonStyle(.compound(.primary))
                .accessibilityIdentifier(A11yIdentifiers.sessionVerificationScreen.requestVerification)
-            case .responder:
+            case .deviceResponder, .userResponder:
                VStack(spacing: 16) {
                    Button(L10n.actionStart) {
                        context.send(viewAction: .acceptVerificationRequest)
@@ -112,12 +138,12 @@ struct SessionVerificationScreen: View {
            }
        case .cancelled:
            switch context.viewState.flow {
-            case .initiator:
+            case .deviceInitiator, .userIntiator:
                Button(L10n.actionRetry) {
                    context.send(viewAction: .restart)
                }
                .buttonStyle(.compound(.primary))
-            case .responder:
+            case .deviceResponder, .userResponder:
                Button(L10n.actionDone) {
                    context.send(viewAction: .done)
                }
@@ -146,11 +172,6 @@ struct SessionVerificationScreen: View {
                .accessibilityIdentifier(A11yIdentifiers.sessionVerificationScreen.declineChallenge)
            }
            
-        case .acceptingVerificationRequest, .acceptingChallenge, .decliningChallenge, .requestingVerification:
-            Button(L10n.screenIdentityWaitingOnOtherDevice) { }
-                .buttonStyle(.compound(.primary))
-                .disabled(true)
-
        default:
            EmptyView()
        }
@@ -174,16 +195,25 @@ struct SessionVerificationScreen: View {

 struct SessionVerification_Previews: PreviewProvider, TestablePreview {
    static var previews: some View {
-        sessionVerificationScreen(state: .initial)
-            .previewDisplayName("Initial - Initiator")
+        sessionVerificationScreen(state: .initial, flow: .deviceInitiator)
+            .previewDisplayName("Initial - Device Initiator")
        
-        let details = SessionVerificationRequestDetails(senderID: "@bob:matrix.org",
+        sessionVerificationScreen(state: .initial, flow: .userIntiator(userID: "@bob:matrix.org"))
+            .previewDisplayName("Initial - User Initiator")
+        
+        let details = SessionVerificationRequestDetails(senderProfile: UserProfileProxy(userID: "@bob:matrix.org",
+                                                                                        displayName: "Billy Bob",
+                                                                                        avatarURL: .mockMXCUserAvatar),
                                                        flowID: "123",
                                                        deviceID: "CODEMISTAKE",
-                                                        displayName: "Bob's Element X iOS",
+                                                        deviceDisplayName: "Bob's Element X iOS",
                                                        firstSeenDate: .init(timeIntervalSince1970: 0))
-        sessionVerificationScreen(state: .initial, flow: .responder(details: details))
-            .previewDisplayName("Initial - Responder")
+        
+        sessionVerificationScreen(state: .initial, flow: .deviceResponder(requestDetails: details))
+            .previewDisplayName("Initial - Device Responder")
+        
+        sessionVerificationScreen(state: .initial, flow: .userResponder(requestDetails: details))
+            .previewDisplayName("Initial - User Responder")
        
        sessionVerificationScreen(state: .acceptingVerificationRequest)
            .previewDisplayName("Accepting Verification Request")
@@ -213,9 +243,11 @@ struct SessionVerification_Previews: PreviewProvider, TestablePreview {
    }
    
    static func sessionVerificationScreen(state: SessionVerificationScreenStateMachine.State,
-                                          flow: SessionVerificationScreenFlow = .initiator) -> some View {
+                                          flow: SessionVerificationScreenFlow = .deviceInitiator) -> some View {
        let viewModel = SessionVerificationScreenViewModel(sessionVerificationControllerProxy: SessionVerificationControllerProxyMock.configureMock(),
                                                           flow: flow,
+                                                           appSettings: AppSettings(),
+                                                           mediaProvider: MediaProviderMock(configuration: .init()),
                                                           verificationState: state)
        
        return SessionVerificationScreen(context: viewModel.context)