Tutorial: Build an iOS Identity Verification App

import SwiftUI

struct SetupView: View {
    let onJourneyStarted: (URL) -> Void

    @AppStorage("serverURL") private var serverURL = "http://localhost:3000"
    @AppStorage("resourceId") private var resourceId = ""

    @State private var isLoading = false
    @State private var errorMessage: String?

    var body: some View {
        Form {
            Section {
                Text("Configure the companion server connection and journey template, then tap Start Journey to begin.")
                    .font(.subheadline)
                    .foregroundStyle(.secondary)
            }

            Section("Companion Server") {
                TextField("Server URL", text: $serverURL)
                    .textContentType(.URL)
                    .autocorrectionDisabled()
                    .textInputAutocapitalization(.never)
                    .keyboardType(.URL)

                Text("The companion server creates journey sessions using the GBG Go Core SDK. See server/README.md for setup.")
                    .font(.caption)
                    .foregroundStyle(.secondary)
            }

            Section("Journey Template") {
                TextField("Resource ID (optional)", text: $resourceId)
                    .autocorrectionDisabled()
                    .textInputAutocapitalization(.never)

                Text("Leave blank to use the server's default. Format: <id>@<version> (e.g. abc123@latest).")
                    .font(.caption)
                    .foregroundStyle(.secondary)
            }

            if let errorMessage {
                Section {
                    Label(errorMessage, systemImage: "exclamationmark.triangle")
                        .foregroundStyle(.red)
                        .font(.callout)
                }
            }

            Section {
                Button(action: startJourney) {
                    if isLoading {
                        ProgressView()
                            .frame(maxWidth: .infinity)
                    } else {
                        Text("Start Journey")
                            .frame(maxWidth: .infinity)
                            .fontWeight(.semibold)
                    }
                }
                .disabled(isLoading || serverURL.isEmpty)
            }
        }
        .navigationTitle("GBG Go Reference")
    }

    private func startJourney() {
        isLoading = true
        errorMessage = nil

        Task {
            do {
                let response = try await JourneyService.startJourney(
                    serverURL: serverURL,
                    resourceId: resourceId.isEmpty ? nil : resourceId
                )
                onJourneyStarted(response.journeyUrl)
            } catch {
                errorMessage = error.localizedDescription
            }
            isLoading = false
        }
    }
}

import Foundation

enum JourneyService {

    struct StartResponse: Decodable {
        let journeyUrl: URL
        let instanceId: String
        let connectToken: String
        let expiresIn: Int
    }

    enum ServiceError: LocalizedError {
        case invalidServerURL(String)
        case serverError(statusCode: Int, message: String)
        case networkError(Error)
        case decodingError(Error)
        case missingJourneyURL

        var errorDescription: String? {
            switch self {
            case .invalidServerURL(let url):
                return "Invalid server URL: \(url). Check the URL format."
            case .serverError(let code, let message):
                return "Server returned \(code): \(message)"
            case .networkError(let error):
                return "Cannot reach the server: \(error.localizedDescription). Is it running?"
            case .decodingError(let error):
                return "Unexpected server response: \(error.localizedDescription)"
            case .missingJourneyURL:
                return "Server did not return a journey URL. Check the server logs."
            }
        }
    }

    static func startJourney(
        serverURL: String,
        resourceId: String?
    ) async throws -> StartResponse {
        guard let baseURL = URL(string: serverURL),
              let endpoint = URL(string: "/api/journey/start", relativeTo: baseURL) else {
            throw ServiceError.invalidServerURL(serverURL)
        }

        var body: [String: Any] = [:]
        if let resourceId {
            body["resourceId"] = resourceId
        }

        var request = URLRequest(url: endpoint)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.timeoutInterval = 30

        if !body.isEmpty {
            request.httpBody = try JSONSerialization.data(withJSONObject: body)
        }

        let data: Data
        let response: URLResponse
        do {
            (data, response) = try await URLSession.shared.data(for: request)
        } catch {
            throw ServiceError.networkError(error)
        }

        if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode != 200 {
            let message: String
            if let errorBody = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
               let errorMessage = errorBody["message"] as? String ?? errorBody["error"] as? String {
                message = errorMessage
            } else {
                message = String(data: data, encoding: .utf8) ?? "Unknown error"
            }
            throw ServiceError.serverError(statusCode: httpResponse.statusCode, message: message)
        }

        do {
            let startResponse = try JSONDecoder().decode(StartResponse.self, from: data)
            return startResponse
        } catch {
            throw ServiceError.decodingError(error)
        }
    }
}

import GBGBridge
import SwiftUI

struct JourneyView: View {
    let journeyURL: URL

    @StateObject private var host = BridgeHost(hostVersion: "1.0.0")

    @State private var showDocumentCamera = false
    @State private var showSelfieCamera = false

    var body: some View {
        ZStack(alignment: .bottom) {
            BridgeWebView(url: journeyURL, host: host)
                .ignoresSafeArea()

            if let error = host.lastError {
                Text(error)
                    .font(.caption)
                    .foregroundColor(.white)
                    .padding(8)
                    .background(Color.red.cornerRadius(8))
                    .padding()
            }
        }
            .navigationTitle("Journey")
            .navigationBarTitleDisplayMode(.inline)
            .onAppear(perform: configureHandlers)
            .fullScreenCover(isPresented: $showDocumentCamera) {
                documentCameraView
            }
            .fullScreenCover(isPresented: $showSelfieCamera) {
                selfieCameraView
            }
            .onChange(of: host.documentCapture.activeRequest?.correlationId) { _ in
                showDocumentCamera = host.documentCapture.activeRequest != nil
            }
            .onChange(of: host.selfieCapture.activeRequest?.correlationId) { _ in
                showSelfieCamera = host.selfieCapture.activeRequest != nil
            }
    }

    // MARK: - Handler Configuration

    private func configureHandlers() {
        host.documentCapture.handler = { [weak host] _ in
            guard let host else { return .cancelled(reason: "Host deallocated") }
            return await host.documentCapture.awaitCompletion()
        }

        host.selfieCapture.handler = { [weak host] _ in
            guard let host else { return .cancelled(reason: "Host deallocated") }
            return await host.selfieCapture.awaitCompletion()
        }
    }

    // MARK: - Camera Views

    private var documentCameraView: some View {
        StubDocumentCameraView(
            onCaptured: { result in
                host.documentCapture.complete(.document(result))
            },
            onCancelled: {
                host.documentCapture.cancelIfBusy(reason: "User dismissed camera")
            }
        )
    }

    private var selfieCameraView: some View {
        StubSelfieCameraView(
            onCaptured: { result in
                host.selfieCapture.complete(.selfie(result))
            },
            onCancelled: {
                host.selfieCapture.cancelIfBusy(reason: "User dismissed camera")
            }
        )
    }
}