Liveness Verification API

import UIKit
import AVFoundation
import Vision

class LumiIDNativeScannerVC: UIViewController, AVCaptureVideoDataOutputSampleBufferDelegate {

    // MARK: - UI Elements
    private let previewView = UIView()
    private let instructionLabel = UILabel()
    private let captureButton = UIButton()
    private let progressView = UIProgressView(progressViewStyle: .bar)

    // MARK: - Properties
    private var captureSession: AVCaptureSession?
    private var videoOutput = AVCaptureVideoDataOutput()
    private var currentChallenge: [String] = []
    private var capturedFrames: [String: String] = [:] 
    private var stepIndex = 0
    private var sessionID: String?
    private var isProcessing = false
    private var lastFrameAsBase64: String?

    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        checkPermissions()
    }

    // MARK: - UI & Permissions Setup
    private func setupUI() {
        view.backgroundColor = .black
        
        // Setup Instruction Label
        instructionLabel.translatesAutoresizingMaskIntoConstraints = false
        instructionLabel.textColor = .white
        instructionLabel.textAlignment = .center
        instructionLabel.font = .systemFont(ofSize: 20, weight: .bold)
        instructionLabel.numberOfLines = 0
        instructionLabel.text = "Initializing LumiID..."
        view.addSubview(instructionLabel)
        
        // Setup Capture Button
        captureButton.translatesAutoresizingMaskIntoConstraints = false
        captureButton.backgroundColor = .white
        captureButton.layer.cornerRadius = 35
        captureButton.setTitle("CAPTURE", for: .normal)
        captureButton.setTitleColor(.black, for: .normal)
        captureButton.titleLabel?.font = .systemFont(ofSize: 12, weight: .black)
        captureButton.addTarget(self, action: #selector(handleCaptureTap), for: .touchUpInside)
        view.addSubview(captureButton)
        
        // Constraints
        NSLayoutConstraint.activate([
            instructionLabel.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 40),
            instructionLabel.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 20),
            instructionLabel.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -20),
            
            captureButton.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor, constant: -50),
            captureButton.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            captureButton.widthAnchor.constraint(equalToConstant: 70),
            captureButton.heightAnchor.constraint(equalToConstant: 70)
        ])
    }

    private func checkPermissions() {
        switch AVCaptureDevice.authorizationStatus(for: .video) {
        case .authorized:
            startLivenessSession()
        case .notDetermined:
            AVCaptureDevice.requestAccess(for: .video) { granted in
                if granted { DispatchQueue.main.async { self.startLivenessSession() } }
            }
        default:
            instructionLabel.text = "Camera access denied. Please enable in Settings."
        }
    }

    // MARK: - Step 1: Initialize Session
    private func startLivenessSession() {
        // CLIENT NOTE: Replace with actual API call to GET /v1/liveness/challenge/
        self.sessionID = "sess_987654321"
        self.currentChallenge = ["center", "up", "right"]
        self.stepIndex = 0
        
        DispatchQueue.main.async {
            self.updateInstruction()
            self.setupCamera()
        }
    }

    private func updateInstruction() {
        guard stepIndex < currentChallenge.count else {
            instructionLabel.text = "Verifying Identity..."
            submitToLumiID()
            return
        }
        let action = currentChallenge[stepIndex].uppercased()
        instructionLabel.text = "STEP \(stepIndex + 1)\nLook \(action)"
    }

    // MARK: - Step 2: Camera Engine
    private func setupCamera() {
        captureSession = AVCaptureSession()
        captureSession?.sessionPreset = .vga640x480

        guard let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front),
              let input = try? AVCaptureDeviceInput(device: device) else { return }

        if captureSession!.canAddInput(input) { captureSession!.addInput(input) }

        videoOutput.setSampleBufferDelegate(self, queue: DispatchQueue(label: "lumiid.queue"))
        if captureSession!.canAddOutput(videoOutput) { captureSession!.addOutput(videoOutput) }

        let previewLayer = AVCaptureVideoPreviewLayer(session: captureSession!)
        previewLayer.frame = view.layer.bounds
        previewLayer.videoGravity = .resizeAspectFill
        view.layer.insertSublayer(previewLayer, at: 0)

        DispatchQueue.global(qos: .userInitiated).async {
            self.captureSession?.startRunning()
        }
    }

    // MARK: - Step 3: Capture Handler
    @objc private func handleCaptureTap() {
        guard !isProcessing, let frame = lastFrameAsBase64 else { return }
        
        let currentStep = currentChallenge[stepIndex]
        capturedFrames[currentStep] = frame
        
        stepIndex += 1
        updateInstruction()
    }

    // MARK: - Step 4: API Submission
    private func submitToLumiID() {
        isProcessing = true
        captureSession?.stopRunning()

        let payload: [String: Any] = [
            "session_id": sessionID ?? "",
            "frames": capturedFrames
        ]

        // CLIENT NOTE: Replace with your actual LumiID URL and API Token
        guard let url = URL(string: "https://api.lumiid.test:8000/v1/face-liveness/") else { return }
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
        request.addValue("Bearer YOUR_API_TOKEN", forHTTPHeaderField: "Authorization")
        request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

        URLSession.shared.dataTask(with: request) { data, _, _ in
            DispatchQueue.main.async {
                self.instructionLabel.text = "Verification Submitted"
                // Handle navigation or success alerts here
                self.dismiss(animated: true)
            }
        }.resume()
    }

    // MARK: - Delegate: Frame Processing
    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
        
        let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
        let context = CIContext()
        if let cgImage = context.createCGImage(ciImage, from: ciImage.extent) {
            // .leftMirrored is standard for the front-facing camera
            let uiImage = UIImage(cgImage: cgImage, scale: 1.0, orientation: .leftMirrored)
            
            if let imageData = uiImage.jpegData(compressionQuality: 0.6) {
                self.lastFrameAsBase64 = "data:image/jpeg;base64,\(imageData.base64EncodedString())"
            }
        }
    }
}