@simasfin/smmf-sdk 0.0.0-stage → 0.2.3

package/ios/OnePassSDK/Liveness/LivenessViewController.swift

@@ -0,0 +1,724 @@
+import AVFoundation
+import UIKit
+
+public enum LivenessStatus {
+    case success
+    case failed
+    case cancelled
+}
+
+public struct LivenessResult {
+    public let status: LivenessStatus
+    public let imageBase64: String?
+    public let errorMessage: String?
+}
+
+public struct LivenessInput {
+    public let primaryColorHex: String?
+
+    public init(primaryColorHex: String? = nil) {
+        self.primaryColorHex = primaryColorHex
+    }
+}
+
+public final class LivenessViewController: UIViewController {
+
+    private enum Metric {
+        static let circleSize: CGFloat = 280
+        static let shutterSize: CGFloat = 60
+        static let buttonHeight: CGFloat = 40
+        static let cornerRadius: CGFloat = 6
+        static let headImageSize: CGFloat = 280
+        static let contentPadding: CGFloat = 24
+    }
+
+    private static let holdStillText = "Tahan posisi, lihat ke kamera"
+
+    private enum Timing {
+        static let timerFallbackInterval: TimeInterval = 3
+        static let mlGestureTimeout: TimeInterval = 20
+        static let captureDelay: TimeInterval = 0.5
+        static let photoWindow: TimeInterval = 3
+        static let countdownStart = 3
+    }
+
+    private let input: LivenessInput
+    private let completion: (LivenessResult) -> Void
+    private let gate = LivenessGate()
+
+    private var mlAvailable = true
+    private var gateActive = false
+    private var captureArmed = false
+    private var waitingForOpenEyes = false
+    private var captureStarted = false
+
+    private var pendingWork: [DispatchWorkItem] = []
+
+    private let session = AVCaptureSession()
+    private let photoOutput = AVCapturePhotoOutput()
+    private let videoOutput = AVCaptureVideoDataOutput()
+    private var analyzer: FaceAnalyzer?
+    private var previewLayer: AVCaptureVideoPreviewLayer?
+
+    private let contentArea = UIView()
+    private let backButton = UIButton(type: .system)
+    private let instructionLabel = UILabel()
+    private let countdownLabel = UILabel()
+    private var circleView: UIView?
+    private var shutterButton: UIView?
+    private var captureSpinner: UIActivityIndicatorView?
+
+    private var primaryColor: UIColor {
+        if let hex = input.primaryColorHex { return UIColor(hex: hex) }
+        return OnePassColor.simascore
+    }
+
+    public init(
+        input: LivenessInput,
+        completion: @escaping (LivenessResult) -> Void
+    ) {
+        self.input = input
+        self.completion = completion
+        super.init(nibName: nil, bundle: nil)
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) { fatalError("tidak dipakai") }
+
+    public override func viewDidLoad() {
+        super.viewDidLoad()
+        OnePassFont.register()
+        view.backgroundColor = .white
+        buildScaffold()
+        showIntroScreen()
+    }
+
+    public override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        if let circleView { previewLayer?.frame = circleView.bounds }
+    }
+
+    public override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        observeSessionInterruptions()
+    }
+
+    public override func viewWillDisappear(_ animated: Bool) {
+        super.viewWillDisappear(animated)
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    private func observeSessionInterruptions() {
+        let center = NotificationCenter.default
+        center.removeObserver(self)
+        center.addObserver(
+            self,
+            selector: #selector(handleSessionInterruption),
+            name: AVCaptureSession.wasInterruptedNotification,
+            object: session
+        )
+        center.addObserver(
+            self,
+            selector: #selector(handleSessionInterruptionEnded),
+            name: AVCaptureSession.interruptionEndedNotification,
+            object: session
+        )
+        center.addObserver(
+            self,
+            selector: #selector(handleAppWillResignActive),
+            name: UIApplication.willResignActiveNotification,
+            object: nil
+        )
+    }
+
+    @objc private func handleSessionInterruption() {
+        pauseGesturePass()
+    }
+
+    @objc private func handleAppWillResignActive() {
+        guard circleView != nil else { return }
+        pauseGesturePass()
+    }
+
+    @objc private func handleSessionInterruptionEnded() {
+        guard circleView != nil, !captureStarted else { return }
+        instructionLabel.text = GateStep.position.instruction
+        if !session.isRunning {
+            DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+                self?.session.startRunning()
+            }
+        }
+    }
+
+    private func pauseGesturePass() {
+        guard circleView != nil, !captureStarted else { return }
+        cancelPendingWork()
+        gate.reset()
+        gateActive = false
+        captureArmed = false
+        waitingForOpenEyes = false
+        previewLayer?.opacity = 1
+        captureSpinner?.isHidden = true
+        countdownLabel.isHidden = true
+        shutterButton?.isHidden = false
+        circleView?.layer.borderColor = UIColor.white.cgColor
+        instructionLabel.text = "Verifikasi terhenti, tekan tombol untuk mulai lagi"
+    }
+
+    private func cancelPendingWork() {
+        pendingWork.forEach { $0.cancel() }
+        pendingWork.removeAll()
+    }
+
+    private func after(_ delay: TimeInterval, _ block: @escaping () -> Void) {
+        let work = DispatchWorkItem(block: block)
+        pendingWork.append(work)
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: work)
+    }
+
+    private func finish(_ status: LivenessStatus, imageBase64: String? = nil, message: String? = nil) {
+        cancelPendingWork()
+        stopCamera()
+        completion(LivenessResult(status: status, imageBase64: imageBase64, errorMessage: message))
+    }
+
+    private func buildScaffold() {
+        let header = UIView()
+        header.backgroundColor = .white
+
+        let title = UILabel()
+        title.text = "Verifikasi Mandiri"
+        title.font = OnePassFont.bold(16)
+        title.textColor = OnePassColor.red500
+        title.translatesAutoresizingMaskIntoConstraints = false
+
+        backButton.backgroundColor = OnePassColor.gray100
+        backButton.layer.cornerRadius = Metric.cornerRadius
+        backButton.isHidden = true
+        backButton.translatesAutoresizingMaskIntoConstraints = false
+        backButton.addTarget(self, action: #selector(handleBack), for: .touchUpInside)
+        backButton.accessibilityLabel = "Kembali"
+        let backIcon = IconView(segments: IconsaxPath.arrowBack, size: 16, color: OnePassColor.gray800)
+        backIcon.isUserInteractionEnabled = false
+        backButton.addSubview(backIcon)
+
+        header.addSubview(title)
+        header.addSubview(backButton)
+
+        let topDivider = UIView()
+        topDivider.backgroundColor = OnePassColor.gray200
+        let bottomDivider = UIView()
+        bottomDivider.backgroundColor = OnePassColor.gray200
+
+        let footer = UIView()
+        footer.backgroundColor = OnePassColor.gray50
+        let logo = UIImageView(image: .onePass("logo_smmf"))
+        logo.contentMode = .scaleAspectFit
+        logo.translatesAutoresizingMaskIntoConstraints = false
+        footer.addSubview(logo)
+
+        [header, topDivider, contentArea, bottomDivider, footer].forEach {
+            $0.translatesAutoresizingMaskIntoConstraints = false
+            view.addSubview($0)
+        }
+
+        NSLayoutConstraint.activate([
+            header.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
+            header.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            header.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            header.heightAnchor.constraint(equalToConstant: 64),
+
+            title.centerXAnchor.constraint(equalTo: header.centerXAnchor),
+            title.centerYAnchor.constraint(equalTo: header.centerYAnchor),
+
+            backButton.leadingAnchor.constraint(equalTo: header.leadingAnchor, constant: 16),
+            backButton.centerYAnchor.constraint(equalTo: header.centerYAnchor),
+            backButton.widthAnchor.constraint(equalToConstant: 32),
+            backButton.heightAnchor.constraint(equalToConstant: 32),
+            backIcon.centerXAnchor.constraint(equalTo: backButton.centerXAnchor),
+            backIcon.centerYAnchor.constraint(equalTo: backButton.centerYAnchor),
+
+            topDivider.topAnchor.constraint(equalTo: header.bottomAnchor),
+            topDivider.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            topDivider.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            topDivider.heightAnchor.constraint(equalToConstant: 1),
+
+            contentArea.topAnchor.constraint(equalTo: topDivider.bottomAnchor),
+            contentArea.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            contentArea.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            contentArea.bottomAnchor.constraint(equalTo: bottomDivider.topAnchor),
+
+            bottomDivider.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            bottomDivider.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            bottomDivider.heightAnchor.constraint(equalToConstant: 1),
+            bottomDivider.bottomAnchor.constraint(equalTo: footer.topAnchor),
+
+            footer.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            footer.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            footer.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),
+            footer.heightAnchor.constraint(equalToConstant: 54),
+
+            logo.centerXAnchor.constraint(equalTo: footer.centerXAnchor),
+            logo.centerYAnchor.constraint(equalTo: footer.centerYAnchor),
+            logo.heightAnchor.constraint(equalToConstant: 30),
+        ])
+    }
+
+    @objc private func handleBack() {
+        stopCamera()
+        showIntroScreen()
+    }
+
+    private func resetContent() -> UIView {
+        contentArea.subviews.forEach { $0.removeFromSuperview() }
+        let container = UIView()
+        container.translatesAutoresizingMaskIntoConstraints = false
+        contentArea.addSubview(container)
+        NSLayoutConstraint.activate([
+            container.topAnchor.constraint(equalTo: contentArea.topAnchor),
+            container.leadingAnchor.constraint(equalTo: contentArea.leadingAnchor),
+            container.trailingAnchor.constraint(equalTo: contentArea.trailingAnchor),
+            container.bottomAnchor.constraint(equalTo: contentArea.bottomAnchor),
+        ])
+        return container
+    }
+
+    private func badge(text: String, segments: [IconSegment], iconSize: CGFloat, color: UIColor) -> UIView {
+        let container = UIView()
+        container.backgroundColor = color
+        container.layer.cornerRadius = Metric.cornerRadius
+        container.translatesAutoresizingMaskIntoConstraints = false
+
+        let icon = IconView(segments: segments, size: iconSize, color: .white)
+        let label = UILabel()
+        label.text = text
+        label.font = OnePassFont.regular(12)
+        label.textColor = .white
+        label.translatesAutoresizingMaskIntoConstraints = false
+
+        container.addSubview(icon)
+        container.addSubview(label)
+        NSLayoutConstraint.activate([
+            icon.leadingAnchor.constraint(equalTo: container.leadingAnchor, constant: 8),
+            icon.centerYAnchor.constraint(equalTo: container.centerYAnchor),
+            label.leadingAnchor.constraint(equalTo: icon.trailingAnchor, constant: 8),
+            label.trailingAnchor.constraint(equalTo: container.trailingAnchor, constant: -8),
+            label.topAnchor.constraint(equalTo: container.topAnchor, constant: 4),
+            label.bottomAnchor.constraint(equalTo: container.bottomAnchor, constant: -4),
+        ])
+        return container
+    }
+
+    func showIntroScreen() {
+        cancelPendingWork()
+        backButton.isHidden = true
+        contentArea.backgroundColor = .white
+        let container = resetContent()
+
+        let headContainer = UIView()
+        headContainer.translatesAutoresizingMaskIntoConstraints = false
+        let headImage = UIImageView(image: .onePass("placeholder_head"))
+        headImage.contentMode = .scaleAspectFill
+        headImage.clipsToBounds = true
+        headImage.layer.cornerRadius = Metric.cornerRadius
+        headImage.translatesAutoresizingMaskIntoConstraints = false
+        headContainer.addSubview(headImage)
+
+        let greenBadge = badge(
+            text: "Pastikan pencahayaan cukup",
+            segments: IconsaxPath.check,
+            iconSize: 12,
+            color: OnePassColor.greenCheckBadge
+        )
+        headContainer.addSubview(greenBadge)
+
+        let warningBadge = badge(
+            text: "Hindari penggunaan aksesoris wajah",
+            segments: IconsaxPath.close,
+            iconSize: 8,
+            color: OnePassColor.orangeWarningBadge
+        )
+
+        let warningImage = UIImageView(image: .onePass("hindari_pemakaian"))
+        warningImage.contentMode = .scaleAspectFit
+        warningImage.translatesAutoresizingMaskIntoConstraints = false
+
+        let action = OnePassButton(
+            title: "Ambil Foto",
+            style: .solid(primaryColor),
+            cornerRadius: Metric.cornerRadius,
+            font: OnePassFont.semibold(16)
+        )
+        action.translatesAutoresizingMaskIntoConstraints = false
+        action.addTarget(self, action: #selector(handleTakePhoto), for: .touchUpInside)
+
+        let stack = UIStackView(arrangedSubviews: [headContainer, warningBadge, warningImage, action])
+        stack.axis = .vertical
+        stack.alignment = .center
+        stack.spacing = 16
+        stack.translatesAutoresizingMaskIntoConstraints = false
+        container.addSubview(stack)
+
+        NSLayoutConstraint.activate([
+            stack.centerYAnchor.constraint(equalTo: container.centerYAnchor),
+            stack.leadingAnchor.constraint(
+                equalTo: container.leadingAnchor,
+                constant: Metric.contentPadding
+            ),
+            stack.trailingAnchor.constraint(
+                equalTo: container.trailingAnchor,
+                constant: -Metric.contentPadding
+            ),
+
+            headContainer.widthAnchor.constraint(equalToConstant: Metric.headImageSize),
+            headContainer.heightAnchor.constraint(equalToConstant: Metric.headImageSize),
+            headImage.topAnchor.constraint(equalTo: headContainer.topAnchor),
+            headImage.leadingAnchor.constraint(equalTo: headContainer.leadingAnchor),
+            headImage.trailingAnchor.constraint(equalTo: headContainer.trailingAnchor),
+            headImage.bottomAnchor.constraint(equalTo: headContainer.bottomAnchor),
+            greenBadge.topAnchor.constraint(equalTo: headContainer.topAnchor, constant: 16),
+            greenBadge.centerXAnchor.constraint(equalTo: headContainer.centerXAnchor),
+            greenBadge.widthAnchor.constraint(equalToConstant: 210),
+
+            warningImage.widthAnchor.constraint(equalToConstant: Metric.headImageSize),
+            action.heightAnchor.constraint(equalToConstant: Metric.buttonHeight),
+            action.leadingAnchor.constraint(equalTo: stack.leadingAnchor),
+            action.trailingAnchor.constraint(equalTo: stack.trailingAnchor),
+        ])
+    }
+
+    @objc private func handleTakePhoto() {
+        switch AVCaptureDevice.authorizationStatus(for: .video) {
+        case .authorized:
+            showCaptureScreen()
+        case .notDetermined:
+            AVCaptureDevice.requestAccess(for: .video) { [weak self] granted in
+                DispatchQueue.main.async {
+                    if granted { self?.showCaptureScreen() } else { self?.showPermissionScreen() }
+                }
+            }
+        default:
+            showPermissionScreen()
+        }
+    }
+
+    private func showPermissionScreen() {
+        backButton.isHidden = true
+        contentArea.backgroundColor = .white
+        let container = resetContent()
+
+        let message = UILabel()
+        message.text = "Izin kamera dibutuhkan untuk verifikasi wajah. Aktifkan izin kamera melalui pengaturan aplikasi."
+        message.font = OnePassFont.regular(14)
+        message.textColor = OnePassColor.gray600
+        message.numberOfLines = 0
+        message.textAlignment = .center
+
+        let settings = OnePassButton(
+            title: "Buka Pengaturan",
+            style: .solid(primaryColor),
+            cornerRadius: Metric.cornerRadius,
+            font: OnePassFont.semibold(16)
+        )
+        settings.addTarget(self, action: #selector(openSettings), for: .touchUpInside)
+
+        let back = OnePassButton(
+            title: "Kembali",
+            style: .outline(border: OnePassColor.gray200, text: OnePassColor.gray800),
+            cornerRadius: Metric.cornerRadius,
+            font: OnePassFont.semibold(16)
+        )
+        back.addTarget(self, action: #selector(handleCancel), for: .touchUpInside)
+
+        let stack = UIStackView(arrangedSubviews: [message, settings, back])
+        stack.axis = .vertical
+        stack.spacing = 12
+        stack.translatesAutoresizingMaskIntoConstraints = false
+        container.addSubview(stack)
+        NSLayoutConstraint.activate([
+            stack.centerYAnchor.constraint(equalTo: container.centerYAnchor),
+            stack.leadingAnchor.constraint(
+                equalTo: container.leadingAnchor,
+                constant: Metric.contentPadding
+            ),
+            stack.trailingAnchor.constraint(
+                equalTo: container.trailingAnchor,
+                constant: -Metric.contentPadding
+            ),
+            settings.heightAnchor.constraint(equalToConstant: Metric.buttonHeight),
+            back.heightAnchor.constraint(equalToConstant: Metric.buttonHeight),
+        ])
+    }
+
+    @objc private func openSettings() {
+        guard let url = URL(string: UIApplication.openSettingsURLString) else { return }
+        UIApplication.shared.open(url)
+    }
+
+    @objc private func handleCancel() {
+        finish(.cancelled)
+    }
+
+    func showCaptureScreen() {
+        cancelPendingWork()
+        gate.reset()
+        gateActive = false
+        captureArmed = false
+        waitingForOpenEyes = false
+        captureStarted = false
+        backButton.isHidden = false
+        contentArea.backgroundColor = .black
+        let container = resetContent()
+
+        instructionLabel.text = GateStep.position.instruction
+        instructionLabel.font = OnePassFont.medium(14)
+        instructionLabel.textColor = .white
+        instructionLabel.textAlignment = .center
+        instructionLabel.numberOfLines = 0
+        instructionLabel.translatesAutoresizingMaskIntoConstraints = false
+
+        let circle = UIView()
+        circle.backgroundColor = .white
+        circle.layer.cornerRadius = Metric.circleSize / 2
+        circle.layer.borderWidth = 4
+        circle.layer.borderColor = UIColor.white.cgColor
+        circle.clipsToBounds = true
+        circle.translatesAutoresizingMaskIntoConstraints = false
+        circleView = circle
+
+        countdownLabel.text = nil
+        countdownLabel.font = OnePassFont.bold(60)
+        countdownLabel.textColor = .white
+        countdownLabel.isHidden = true
+        countdownLabel.translatesAutoresizingMaskIntoConstraints = false
+
+        let spinner = UIActivityIndicatorView(style: .large)
+        spinner.color = OnePassColor.greenSpinner
+        spinner.isHidden = true
+        spinner.translatesAutoresizingMaskIntoConstraints = false
+        captureSpinner = spinner
+
+        let shutter = UIView()
+        shutter.backgroundColor = .white
+        shutter.layer.cornerRadius = Metric.shutterSize / 2
+        shutter.layer.borderWidth = 4
+        shutter.layer.borderColor = OnePassColor.shutterBorder.cgColor
+        shutter.translatesAutoresizingMaskIntoConstraints = false
+        shutter.isAccessibilityElement = true
+        shutter.accessibilityTraits = .button
+        shutter.accessibilityLabel = "Mulai verifikasi wajah"
+        shutter.addGestureRecognizer(
+            UITapGestureRecognizer(target: self, action: #selector(startCountdown))
+        )
+        shutterButton = shutter
+
+        [instructionLabel, circle, countdownLabel, spinner, shutter].forEach(container.addSubview)
+
+        NSLayoutConstraint.activate([
+            instructionLabel.topAnchor.constraint(equalTo: container.topAnchor, constant: 16),
+            instructionLabel.leadingAnchor.constraint(equalTo: container.leadingAnchor, constant: 16),
+            instructionLabel.trailingAnchor.constraint(equalTo: container.trailingAnchor, constant: -16),
+
+            circle.centerXAnchor.constraint(equalTo: container.centerXAnchor),
+            circle.centerYAnchor.constraint(equalTo: container.centerYAnchor),
+            circle.widthAnchor.constraint(equalToConstant: Metric.circleSize),
+            circle.heightAnchor.constraint(equalToConstant: Metric.circleSize),
+
+            countdownLabel.centerXAnchor.constraint(equalTo: circle.centerXAnchor),
+            countdownLabel.centerYAnchor.constraint(equalTo: circle.centerYAnchor),
+            spinner.centerXAnchor.constraint(equalTo: circle.centerXAnchor),
+            spinner.centerYAnchor.constraint(equalTo: circle.centerYAnchor),
+
+            shutter.centerXAnchor.constraint(equalTo: container.centerXAnchor),
+            shutter.bottomAnchor.constraint(equalTo: container.bottomAnchor, constant: -24),
+            shutter.widthAnchor.constraint(equalToConstant: Metric.shutterSize),
+            shutter.heightAnchor.constraint(equalToConstant: Metric.shutterSize),
+        ])
+
+        startCamera(in: circle)
+    }
+
+    private func startCamera(in circle: UIView) {
+        guard
+            let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front),
+            let deviceInput = try? AVCaptureDeviceInput(device: device)
+        else {
+            finish(.failed, message: "Kamera depan tidak tersedia di perangkat ini")
+            return
+        }
+        session.beginConfiguration()
+        session.inputs.forEach(session.removeInput)
+        session.outputs.forEach(session.removeOutput)
+        if session.canAddInput(deviceInput) { session.addInput(deviceInput) }
+        if session.canAddOutput(photoOutput) { session.addOutput(photoOutput) }
+        let faceAnalyzer = FaceAnalyzer { [weak self] snapshot in
+            DispatchQueue.main.async { self?.handleGateInput(snapshot) }
+        }
+        analyzer = faceAnalyzer
+        videoOutput.setSampleBufferDelegate(
+            faceAnalyzer,
+            queue: DispatchQueue(label: "id.co.onepass.face-analyzer")
+        )
+        videoOutput.alwaysDiscardsLateVideoFrames = true
+        if session.canAddOutput(videoOutput) { session.addOutput(videoOutput) }
+        session.commitConfiguration()
+
+        let layer = AVCaptureVideoPreviewLayer(session: session)
+        layer.videoGravity = .resizeAspectFill
+        layer.frame = circle.bounds
+        circle.layer.insertSublayer(layer, at: 0)
+        previewLayer = layer
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            self?.session.startRunning()
+        }
+    }
+
+    private func stopCamera() {
+        if session.isRunning { session.stopRunning() }
+        videoOutput.setSampleBufferDelegate(nil, queue: nil)
+        analyzer = nil
+        previewLayer?.removeFromSuperlayer()
+        previewLayer = nil
+        circleView = nil
+        captureSpinner = nil
+    }
+
+    @objc private func startCountdown() {
+        guard !gateActive, !captureStarted else { return }
+        shutterButton?.isHidden = true
+        countdown(Timing.countdownStart)
+    }
+
+    private func countdown(_ value: Int) {
+        if value == 0 {
+            countdownLabel.isHidden = true
+            gateActive = true
+            scheduleTimerFallback()
+            after(Timing.mlGestureTimeout) { [weak self] in
+                guard let self, !self.captureStarted, self.gate.step != .ready else { return }
+                self.mlAvailable = false
+            }
+            return
+        }
+        countdownLabel.isHidden = false
+        countdownLabel.text = "\(value)"
+        after(1) { [weak self] in self?.countdown(value - 1) }
+    }
+
+    private func handleGateInput(_ snapshot: FaceSnapshot?) {
+        guard mlAvailable, gateActive, !captureStarted else { return }
+        if captureArmed {
+            if waitingForOpenEyes, gate.readyForPhoto(snapshot) {
+                capturePhoto()
+            } else {
+                instructionLabel.text = gate.feedback(for: snapshot) ?? Self.holdStillText
+            }
+            return
+        }
+        gate.process(snapshot)
+        if gate.step == .ready {
+            armCapture()
+            return
+        }
+        let feedback = gate.feedback(for: snapshot)
+        instructionLabel.text = feedback ?? gate.step.instruction
+        circleView?.layer.borderColor = (feedback == nil
+            ? OnePassColor.greenPhotoBorder
+            : OnePassColor.orangeWarningBadge).cgColor
+    }
+
+    private func scheduleTimerFallback() {
+        after(Timing.timerFallbackInterval) { [weak self] in
+            guard let self, !self.captureStarted, !self.captureArmed else { return }
+            if !self.mlAvailable {
+                self.gate.advanceByTimer()
+                self.instructionLabel.text = self.gate.step.instruction
+                if self.gate.step == .ready { self.armCapture() } else { self.scheduleTimerFallback() }
+            } else if self.gate.step != .ready {
+                self.scheduleTimerFallback()
+            }
+        }
+    }
+
+    private func armCapture() {
+        guard !captureArmed else { return }
+        captureArmed = true
+        instructionLabel.text = Self.holdStillText
+        circleView?.layer.borderColor = OnePassColor.greenPhotoBorder.cgColor
+        after(Timing.captureDelay) { [weak self] in
+            guard let self else { return }
+            if self.mlAvailable { self.waitingForOpenEyes = true } else { self.capturePhoto() }
+        }
+        after(Timing.captureDelay + Timing.photoWindow) { [weak self] in
+            guard let self, !self.captureStarted else { return }
+            if self.mlAvailable { self.restartAfterMissedFace() } else { self.capturePhoto() }
+        }
+    }
+
+    private func restartAfterMissedFace() {
+        showCaptureScreen()
+        showToast("Wajah tidak terdeteksi, silakan ulangi")
+    }
+
+    private func capturePhoto() {
+        guard !captureStarted else { return }
+        captureStarted = true
+        waitingForOpenEyes = false
+        instructionLabel.text = "Sedang memproses, pastikan wajah terlihat jelas"
+        circleView?.layer.borderColor = UIColor.white.cgColor
+        previewLayer?.opacity = 0.3
+        captureSpinner?.isHidden = false
+        captureSpinner?.startAnimating()
+        photoOutput.capturePhoto(with: AVCapturePhotoSettings(), delegate: self)
+    }
+
+    func deliverCapturedImage(_ image: UIImage) {
+        let prepared = LivenessImagePreparer.prepareForUpload(image)
+        finish(.success, imageBase64: prepared.base64)
+    }
+
+    private func showToast(_ text: String) {
+        let toast = UILabel()
+        toast.text = text
+        toast.font = OnePassFont.regular(14)
+        toast.textColor = .white
+        toast.backgroundColor = UIColor.black.withAlphaComponent(0.85)
+        toast.textAlignment = .center
+        toast.numberOfLines = 0
+        toast.layer.cornerRadius = 8
+        toast.layer.masksToBounds = true
+        toast.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(toast)
+        NSLayoutConstraint.activate([
+            toast.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 32),
+            toast.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -32),
+            toast.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor, constant: -80),
+            toast.heightAnchor.constraint(greaterThanOrEqualToConstant: 44),
+        ])
+        after(3) { toast.removeFromSuperview() }
+    }
+}
+
+extension LivenessViewController: AVCapturePhotoCaptureDelegate {
+    public func photoOutput(
+        _ output: AVCapturePhotoOutput,
+        didFinishProcessingPhoto photo: AVCapturePhoto,
+        error: Error?
+    ) {
+        guard
+            error == nil,
+            let data = photo.fileDataRepresentation(),
+            let image = UIImage(data: data)
+        else {
+            DispatchQueue.main.async { [weak self] in
+                self?.showToast("Gagal mengambil foto, coba lagi")
+                self?.showCaptureScreen()
+            }
+            return
+        }
+        DispatchQueue.main.async { [weak self] in
+            self?.deliverCapturedImage(image)
+        }
+    }
+}