@simasfin/smmf-sdk 0.0.0-stage → 0.2.3

package/ios/OnePassSDK/Ocr/KtpOcrViewController.swift

@@ -0,0 +1,703 @@
+import AVFoundation
+import UIKit
+
+public enum KtpOcrStatusCode {
+    case success
+    case failed
+    case cancelled
+}
+
+public struct KtpOcrResult {
+    public let status: KtpOcrStatusCode
+    public let imageBase64: String?
+    public let errorMessage: String?
+}
+
+public struct KtpOcrInput {
+    public let primaryColorHex: String?
+
+    public init(primaryColorHex: String? = nil) {
+        self.primaryColorHex = primaryColorHex
+    }
+}
+
+public final class KtpOcrViewController: UIViewController {
+
+    private enum Metric {
+        static let buttonHeight: CGFloat = 38
+        static let buttonRadius: CGFloat = 8
+        static let shutterSize: CGFloat = 80
+        static let flashSize: CGFloat = 44
+        static let contentPadding: CGFloat = 20
+        static let photoWidthFraction: CGFloat = 0.85
+        static let photoRadius: CGFloat = 12
+        static let gateFailuresBeforeOverride = 2
+    }
+
+    private let input: KtpOcrInput
+    private let completion: (KtpOcrResult) -> Void
+
+    var capturedJpeg: Data?
+    private var torchOn = false
+    private var qualityIssue: KtpQualityResult?
+    private var gateFailures = 0
+    private let inspector = KtpPhotoInspector()
+
+    private let session = AVCaptureSession()
+    private let photoOutput = AVCapturePhotoOutput()
+    private var captureDevice: AVCaptureDevice?
+    private var previewLayer: AVCaptureVideoPreviewLayer?
+    private var cameraContainer: UIView?
+    private var overlay: KtpFrameOverlayView?
+    private var flashIcon: IconView?
+
+    private var primaryColor: UIColor {
+        if let hex = input.primaryColorHex { return UIColor(hex: hex) }
+        return OnePassColor.primary600
+    }
+
+    public init(
+        input: KtpOcrInput,
+        completion: @escaping (KtpOcrResult) -> 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
+        showIntroScreen()
+    }
+
+    public override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        if let cameraContainer { previewLayer?.frame = cameraContainer.bounds }
+    }
+
+    public override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        NotificationCenter.default.removeObserver(self)
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleInterruptionEnded),
+            name: AVCaptureSession.interruptionEndedNotification,
+            object: session
+        )
+    }
+
+    public override func viewWillDisappear(_ animated: Bool) {
+        super.viewWillDisappear(animated)
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    @objc private func handleInterruptionEnded() {
+        guard cameraContainer != nil, !session.isRunning else { return }
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            self?.session.startRunning()
+        }
+    }
+
+    private func finish(
+        _ status: KtpOcrStatusCode,
+        imageBase64: String? = nil,
+        message: String? = nil
+    ) {
+        stopCamera()
+        completion(KtpOcrResult(status: status, imageBase64: imageBase64, errorMessage: message))
+    }
+
+    private func resetRoot() -> UIView {
+        view.subviews.forEach { $0.removeFromSuperview() }
+        let container = UIView()
+        container.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(container)
+        NSLayoutConstraint.activate([
+            container.topAnchor.constraint(equalTo: view.topAnchor),
+            container.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            container.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            container.bottomAnchor.constraint(equalTo: view.bottomAnchor),
+        ])
+        return container
+    }
+
+    func showIntroScreen() {
+        stopCamera()
+        capturedJpeg = nil
+        view.backgroundColor = .white
+        let container = resetRoot()
+
+        let illustration = UIImageView(image: .onePass("ktp_illustration"))
+        illustration.contentMode = .scaleAspectFit
+        illustration.translatesAutoresizingMaskIntoConstraints = false
+
+        let title = UILabel()
+        title.text = "Foto KTP Asli Kamu"
+        title.font = OnePassFont.bold(14)
+        title.textColor = .black
+
+        let checklistTitle = UILabel()
+        checklistTitle.text = "Pastikan Foto:"
+        checklistTitle.font = OnePassFont.medium(14)
+        checklistTitle.textColor = OnePassColor.tertiary700
+
+        let checklist = UIStackView(
+            arrangedSubviews: [
+                "KTP Asli (bukan dari layar HP)",
+                "Tidak Terpotong",
+                "Terang dan Terbaca",
+            ].map(checklistRow)
+        )
+        checklist.axis = .vertical
+
+        let content = UIStackView(arrangedSubviews: [title, checklistTitle, checklist, infoBanner()])
+        content.axis = .vertical
+        content.alignment = .fill
+        content.spacing = 0
+        content.setCustomSpacing(12, after: title)
+        content.setCustomSpacing(4, after: checklistTitle)
+        content.setCustomSpacing(16, after: checklist)
+        content.translatesAutoresizingMaskIntoConstraints = false
+
+        let footer = UIView()
+        footer.backgroundColor = .white
+        footer.translatesAutoresizingMaskIntoConstraints = false
+        let action = OnePassButton(
+            title: "Ambil Foto",
+            style: .solid(primaryColor),
+            cornerRadius: Metric.buttonRadius,
+            font: OnePassFont.semibold(14)
+        )
+        action.translatesAutoresizingMaskIntoConstraints = false
+        action.addTarget(self, action: #selector(handleTakePhoto), for: .touchUpInside)
+        footer.addSubview(action)
+
+        [illustration, content, footer].forEach(container.addSubview)
+
+        NSLayoutConstraint.activate([
+            illustration.topAnchor.constraint(equalTo: container.safeAreaLayoutGuide.topAnchor),
+            illustration.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            illustration.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+
+            content.topAnchor.constraint(
+                equalTo: illustration.bottomAnchor,
+                constant: Metric.contentPadding
+            ),
+            content.leadingAnchor.constraint(
+                equalTo: container.leadingAnchor,
+                constant: Metric.contentPadding
+            ),
+            content.trailingAnchor.constraint(
+                equalTo: container.trailingAnchor,
+                constant: -Metric.contentPadding
+            ),
+
+            footer.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            footer.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            footer.bottomAnchor.constraint(equalTo: container.bottomAnchor),
+            action.topAnchor.constraint(equalTo: footer.topAnchor, constant: 16),
+            action.leadingAnchor.constraint(equalTo: footer.leadingAnchor, constant: 16),
+            action.trailingAnchor.constraint(equalTo: footer.trailingAnchor, constant: -16),
+            action.bottomAnchor.constraint(
+                equalTo: footer.safeAreaLayoutGuide.bottomAnchor,
+                constant: -16
+            ),
+            action.heightAnchor.constraint(equalToConstant: Metric.buttonHeight),
+        ])
+    }
+
+    private func checklistRow(_ text: String) -> UIView {
+        let row = UIStackView()
+        row.axis = .horizontal
+        row.alignment = .center
+        row.spacing = 8
+
+        let check = UILabel()
+        check.text = "✓"
+        check.font = OnePassFont.regular(14)
+        check.textColor = OnePassColor.tertiary700
+
+        let label = UILabel()
+        label.text = text
+        label.font = OnePassFont.medium(12)
+        label.textColor = OnePassColor.tertiary700
+
+        row.addArrangedSubview(check)
+        row.addArrangedSubview(label)
+        return row
+    }
+
+    private func infoBanner() -> UIView {
+        let banner = UIView()
+        banner.backgroundColor = OnePassColor.warning50
+        banner.layer.cornerRadius = 8
+        banner.layer.borderWidth = 1
+        banner.layer.borderColor = OnePassColor.warning500.cgColor
+        banner.translatesAutoresizingMaskIntoConstraints = false
+
+        let iconCircle = UIView()
+        iconCircle.backgroundColor = OnePassColor.warning500
+        iconCircle.layer.cornerRadius = 10
+        iconCircle.translatesAutoresizingMaskIntoConstraints = false
+        let icon = IconView(segments: IconsaxPath.danger, size: 12, color: .white)
+        iconCircle.addSubview(icon)
+
+        let text = NSMutableAttributedString(
+            string: "Foto KTP yang tidak sesuai atau tidak jelas akan\n",
+            attributes: [
+                .font: OnePassFont.regular(12),
+                .foregroundColor: OnePassColor.tertiary500,
+            ]
+        )
+        text.append(
+            NSAttributedString(
+                string: "DITOLAK",
+                attributes: [
+                    .font: OnePassFont.bold(12),
+                    .foregroundColor: OnePassColor.tertiary900,
+                ]
+            )
+        )
+        text.append(
+            NSAttributedString(
+                string: ", Jadi pastikan foto KTP yang kamu\nunggah terlihat jelas, tidak buram, dan mudah\ndibaca agar proses pengajuan berjalan lancar.",
+                attributes: [
+                    .font: OnePassFont.regular(12),
+                    .foregroundColor: OnePassColor.tertiary500,
+                ]
+            )
+        )
+        let label = UILabel()
+        label.attributedText = text
+        label.numberOfLines = 0
+        label.translatesAutoresizingMaskIntoConstraints = false
+
+        banner.addSubview(iconCircle)
+        banner.addSubview(label)
+        NSLayoutConstraint.activate([
+            iconCircle.leadingAnchor.constraint(equalTo: banner.leadingAnchor, constant: 12),
+            iconCircle.topAnchor.constraint(equalTo: banner.topAnchor, constant: 8),
+            iconCircle.widthAnchor.constraint(equalToConstant: 20),
+            iconCircle.heightAnchor.constraint(equalToConstant: 20),
+            icon.centerXAnchor.constraint(equalTo: iconCircle.centerXAnchor),
+            icon.centerYAnchor.constraint(equalTo: iconCircle.centerYAnchor),
+
+            label.leadingAnchor.constraint(equalTo: iconCircle.trailingAnchor, constant: 12),
+            label.trailingAnchor.constraint(equalTo: banner.trailingAnchor, constant: -12),
+            label.topAnchor.constraint(equalTo: banner.topAnchor, constant: 8),
+            label.bottomAnchor.constraint(equalTo: banner.bottomAnchor, constant: -8),
+        ])
+        return banner
+    }
+
+    @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?.showIntroScreen() }
+                }
+            }
+        default:
+            showIntroScreen()
+        }
+    }
+
+    private func instructionStack() -> UIStackView {
+        let title = UILabel()
+        title.text = "Posisikan KTP anda di dalam Kotak"
+        title.font = OnePassFont.medium(16)
+        title.textColor = OnePassColor.primary25
+        title.textAlignment = .center
+        title.numberOfLines = 0
+
+        let hint = UILabel()
+        hint.text = "Pastikan KTP kamu bisa dibaca dengan jelas"
+        hint.font = OnePassFont.regular(10)
+        hint.textColor = OnePassColor.tertiary50
+        hint.textAlignment = .center
+        hint.numberOfLines = 0
+
+        let stack = UIStackView(arrangedSubviews: [title, hint])
+        stack.axis = .vertical
+        stack.spacing = 4
+        stack.translatesAutoresizingMaskIntoConstraints = false
+        return stack
+    }
+
+    func showCaptureScreen() {
+        capturedJpeg = nil
+        qualityIssue = nil
+        view.backgroundColor = OnePassColor.baseBlack
+        let container = resetRoot()
+
+        let cameraArea = UIView()
+        cameraArea.backgroundColor = .black
+        cameraArea.translatesAutoresizingMaskIntoConstraints = false
+        cameraContainer = cameraArea
+
+        let frameOverlay = KtpFrameOverlayView()
+        frameOverlay.translatesAutoresizingMaskIntoConstraints = false
+        overlay = frameOverlay
+        cameraArea.addSubview(frameOverlay)
+
+        let instructions = instructionStack()
+        cameraArea.addSubview(instructions)
+
+        let closeButton = UIButton(type: .system)
+        closeButton.translatesAutoresizingMaskIntoConstraints = false
+        closeButton.addTarget(self, action: #selector(handleClose), for: .touchUpInside)
+        closeButton.accessibilityLabel = "Tutup"
+        let closeIcon = IconView(segments: IconsaxPath.closeSquare, size: 32, color: .white)
+        closeIcon.isUserInteractionEnabled = false
+        closeButton.addSubview(closeIcon)
+        cameraArea.addSubview(closeButton)
+
+        let controls = UIView()
+        controls.backgroundColor = .white
+        controls.translatesAutoresizingMaskIntoConstraints = false
+
+        let flashButton = UIButton(type: .system)
+        flashButton.backgroundColor = OnePassColor.neutral100
+        flashButton.layer.cornerRadius = Metric.flashSize / 2
+        flashButton.translatesAutoresizingMaskIntoConstraints = false
+        flashButton.addTarget(self, action: #selector(toggleTorch), for: .touchUpInside)
+        flashButton.accessibilityLabel = "Nyalakan atau matikan lampu kamera"
+        let flash = IconView(segments: IconsaxPath.flashSlash, size: 20, color: OnePassColor.tertiary500)
+        flash.isUserInteractionEnabled = false
+        flashButton.addSubview(flash)
+        flashIcon = flash
+
+        let shutter = UIButton(type: .system)
+        shutter.backgroundColor = OnePassColor.primary500
+        shutter.layer.cornerRadius = Metric.shutterSize / 2
+        shutter.translatesAutoresizingMaskIntoConstraints = false
+        shutter.addTarget(self, action: #selector(captureKtp), for: .touchUpInside)
+        shutter.accessibilityLabel = "Ambil foto KTP"
+        let cameraIcon = IconView(segments: IconsaxPath.camera, size: 28, color: .white)
+        cameraIcon.isUserInteractionEnabled = false
+        shutter.addSubview(cameraIcon)
+
+        let spacer = UIView()
+        spacer.translatesAutoresizingMaskIntoConstraints = false
+
+        [flashButton, shutter, spacer].forEach(controls.addSubview)
+        [cameraArea, controls].forEach(container.addSubview)
+
+        NSLayoutConstraint.activate([
+            cameraArea.topAnchor.constraint(equalTo: container.topAnchor),
+            cameraArea.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            cameraArea.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            cameraArea.bottomAnchor.constraint(equalTo: controls.topAnchor),
+
+            frameOverlay.topAnchor.constraint(equalTo: cameraArea.topAnchor),
+            frameOverlay.leadingAnchor.constraint(equalTo: cameraArea.leadingAnchor),
+            frameOverlay.trailingAnchor.constraint(equalTo: cameraArea.trailingAnchor),
+            frameOverlay.bottomAnchor.constraint(equalTo: cameraArea.bottomAnchor),
+
+            instructions.topAnchor.constraint(equalTo: cameraArea.topAnchor, constant: 120),
+            instructions.leadingAnchor.constraint(equalTo: cameraArea.leadingAnchor, constant: 16),
+            instructions.trailingAnchor.constraint(equalTo: cameraArea.trailingAnchor, constant: -16),
+
+            closeButton.topAnchor.constraint(equalTo: cameraArea.topAnchor, constant: 60),
+            closeButton.leadingAnchor.constraint(equalTo: cameraArea.leadingAnchor, constant: 20),
+            closeButton.widthAnchor.constraint(equalToConstant: 32),
+            closeButton.heightAnchor.constraint(equalToConstant: 32),
+            closeIcon.centerXAnchor.constraint(equalTo: closeButton.centerXAnchor),
+            closeIcon.centerYAnchor.constraint(equalTo: closeButton.centerYAnchor),
+
+            controls.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            controls.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            controls.bottomAnchor.constraint(equalTo: container.bottomAnchor),
+
+            flashButton.leadingAnchor.constraint(equalTo: controls.leadingAnchor, constant: 32),
+            flashButton.widthAnchor.constraint(equalToConstant: Metric.flashSize),
+            flashButton.heightAnchor.constraint(equalToConstant: Metric.flashSize),
+            flashButton.centerYAnchor.constraint(equalTo: shutter.centerYAnchor),
+            flash.centerXAnchor.constraint(equalTo: flashButton.centerXAnchor),
+            flash.centerYAnchor.constraint(equalTo: flashButton.centerYAnchor),
+
+            shutter.centerXAnchor.constraint(equalTo: controls.centerXAnchor),
+            shutter.topAnchor.constraint(equalTo: controls.topAnchor, constant: 40),
+            shutter.widthAnchor.constraint(equalToConstant: Metric.shutterSize),
+            shutter.heightAnchor.constraint(equalToConstant: Metric.shutterSize),
+            shutter.bottomAnchor.constraint(
+                equalTo: controls.safeAreaLayoutGuide.bottomAnchor,
+                constant: -40
+            ),
+            cameraIcon.centerXAnchor.constraint(equalTo: shutter.centerXAnchor),
+            cameraIcon.centerYAnchor.constraint(equalTo: shutter.centerYAnchor),
+
+            spacer.trailingAnchor.constraint(equalTo: controls.trailingAnchor, constant: -32),
+            spacer.centerYAnchor.constraint(equalTo: shutter.centerYAnchor),
+            spacer.widthAnchor.constraint(equalToConstant: Metric.flashSize),
+            spacer.heightAnchor.constraint(equalToConstant: Metric.flashSize),
+        ])
+
+        startCamera(in: cameraArea)
+    }
+
+    @objc private func handleClose() {
+        finish(.cancelled)
+    }
+
+    private func startCamera(in container: UIView) {
+        guard
+            let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back),
+            let deviceInput = try? AVCaptureDeviceInput(device: device)
+        else {
+            finish(.failed, message: "Kamera belakang tidak tersedia di perangkat ini")
+            return
+        }
+        captureDevice = device
+        session.beginConfiguration()
+        session.sessionPreset = .photo
+        session.inputs.forEach(session.removeInput)
+        session.outputs.forEach(session.removeOutput)
+        if session.canAddInput(deviceInput) { session.addInput(deviceInput) }
+        if session.canAddOutput(photoOutput) { session.addOutput(photoOutput) }
+        session.commitConfiguration()
+
+        let layer = AVCaptureVideoPreviewLayer(session: session)
+        layer.videoGravity = .resizeAspectFill
+        layer.frame = container.bounds
+        container.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() }
+        if torchOn { setTorch(false) }
+        previewLayer?.removeFromSuperlayer()
+        previewLayer = nil
+        cameraContainer = nil
+        overlay = nil
+        flashIcon = nil
+        captureDevice = nil
+    }
+
+    @objc private func toggleTorch() {
+        setTorch(!torchOn)
+    }
+
+    private func setTorch(_ on: Bool) {
+        guard let device = captureDevice, device.hasTorch else { return }
+        try? device.lockForConfiguration()
+        device.torchMode = on ? .on : .off
+        device.unlockForConfiguration()
+        torchOn = on
+        flashIcon?.color = on ? OnePassColor.warning400 : OnePassColor.tertiary500
+    }
+
+    @objc private func captureKtp() {
+        photoOutput.capturePhoto(with: AVCapturePhotoSettings(), delegate: self)
+    }
+
+    func showPreviewScreen(image: UIImage?, errorMessage: String?, inspecting: Bool = false) {
+        view.backgroundColor = OnePassColor.baseBlack
+        let container = resetRoot()
+
+        let photoArea = UIView()
+        photoArea.backgroundColor = OnePassColor.baseBlack
+        photoArea.translatesAutoresizingMaskIntoConstraints = false
+
+        if let image {
+            let photo = UIImageView(image: image)
+            photo.contentMode = .scaleAspectFill
+            photo.clipsToBounds = true
+            photo.layer.cornerRadius = Metric.photoRadius
+            photo.translatesAutoresizingMaskIntoConstraints = false
+            photoArea.addSubview(photo)
+            NSLayoutConstraint.activate([
+                photo.centerXAnchor.constraint(equalTo: photoArea.centerXAnchor),
+                photo.centerYAnchor.constraint(equalTo: photoArea.centerYAnchor),
+                photo.widthAnchor.constraint(
+                    equalTo: photoArea.widthAnchor,
+                    multiplier: Metric.photoWidthFraction
+                ),
+                photo.heightAnchor.constraint(
+                    equalTo: photo.widthAnchor,
+                    multiplier: 1 / KtpFrameOverlayView.frameRatio
+                ),
+            ])
+        }
+
+        let instructions = instructionStack()
+        photoArea.addSubview(instructions)
+
+        let review = UIView()
+        review.backgroundColor = .white
+        review.translatesAutoresizingMaskIntoConstraints = false
+
+        let stack = UIStackView()
+        stack.axis = .vertical
+        stack.spacing = 12
+        stack.translatesAutoresizingMaskIntoConstraints = false
+
+        if inspecting {
+            let row = UIStackView()
+            row.axis = .horizontal
+            row.spacing = 8
+            row.alignment = .center
+            let spinner = UIActivityIndicatorView(style: .medium)
+            spinner.color = OnePassColor.primary500
+            spinner.startAnimating()
+            let label = UILabel()
+            label.text = "Sedang memproses foto KTP..."
+            label.font = OnePassFont.medium(12)
+            label.textColor = OnePassColor.tertiary700
+            row.addArrangedSubview(spinner)
+            row.addArrangedSubview(label)
+            let center = UIStackView(arrangedSubviews: [row])
+            center.alignment = .center
+            stack.addArrangedSubview(center)
+        }
+
+        if let errorMessage {
+            let banner = UILabel()
+            banner.text = errorMessage
+            banner.font = OnePassFont.regular(14)
+            banner.textColor = OnePassColor.error600
+            banner.backgroundColor = OnePassColor.error50
+            banner.numberOfLines = 0
+            banner.textAlignment = .center
+            banner.layer.cornerRadius = 6
+            banner.layer.masksToBounds = true
+            banner.heightAnchor.constraint(greaterThanOrEqualToConstant: 34).isActive = true
+            stack.addArrangedSubview(banner)
+        }
+
+        let retake = OnePassButton(
+            title: "Ambil Ulang",
+            style: .outline(border: OnePassColor.primary500, text: OnePassColor.primary500),
+            cornerRadius: Metric.buttonRadius,
+            font: OnePassFont.semibold(14)
+        )
+        retake.addTarget(self, action: #selector(handleRetake), for: .touchUpInside)
+
+        let blockedByGate = qualityIssue != nil && gateFailures < Metric.gateFailuresBeforeOverride
+        let save = OnePassButton(
+            title: "Simpan",
+            style: .solid(primaryColor),
+            cornerRadius: Metric.buttonRadius,
+            font: OnePassFont.semibold(14)
+        )
+        save.isEnabled = !blockedByGate
+        save.alpha = blockedByGate ? 0.6 : 1
+        save.addTarget(self, action: #selector(handleSave), for: .touchUpInside)
+
+        let actions = UIStackView(arrangedSubviews: [retake, save])
+        actions.axis = .horizontal
+        actions.spacing = 12
+        actions.distribution = .fillEqually
+        stack.addArrangedSubview(actions)
+        review.addSubview(stack)
+
+        [photoArea, review].forEach(container.addSubview)
+
+        NSLayoutConstraint.activate([
+            photoArea.topAnchor.constraint(equalTo: container.topAnchor),
+            photoArea.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            photoArea.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            photoArea.bottomAnchor.constraint(equalTo: review.topAnchor),
+
+            instructions.topAnchor.constraint(equalTo: photoArea.topAnchor, constant: 120),
+            instructions.leadingAnchor.constraint(equalTo: photoArea.leadingAnchor, constant: 16),
+            instructions.trailingAnchor.constraint(equalTo: photoArea.trailingAnchor, constant: -16),
+
+            review.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            review.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            review.bottomAnchor.constraint(equalTo: container.bottomAnchor),
+
+            stack.topAnchor.constraint(equalTo: review.topAnchor, constant: Metric.contentPadding),
+            stack.leadingAnchor.constraint(
+                equalTo: review.leadingAnchor,
+                constant: Metric.contentPadding
+            ),
+            stack.trailingAnchor.constraint(
+                equalTo: review.trailingAnchor,
+                constant: -Metric.contentPadding
+            ),
+            stack.bottomAnchor.constraint(
+                equalTo: review.safeAreaLayoutGuide.bottomAnchor,
+                constant: -Metric.contentPadding
+            ),
+            actions.heightAnchor.constraint(equalToConstant: Metric.buttonHeight),
+        ])
+    }
+
+    private func inspectThenPreview(_ framed: UIImage) {
+        showPreviewScreen(image: nil, errorMessage: nil, inspecting: true)
+        inspector.inspect(image: framed) { [weak self] inspection in
+            DispatchQueue.main.async {
+                guard let self else { return }
+                let finalImage = KtpImagePreparer.cropToDetectedBounds(
+                    image: framed,
+                    bounds: inspection.textBounds
+                )
+                self.capturedJpeg = finalImage.jpegData(
+                    compressionQuality: KtpImagePreparer.jpegQuality
+                )
+                self.qualityIssue = inspection.quality.passed ? nil : inspection.quality
+                if self.qualityIssue != nil { self.gateFailures += 1 }
+                self.stopCamera()
+                self.showPreviewScreen(
+                    image: finalImage,
+                    errorMessage: self.qualityIssue?.message
+                )
+            }
+        }
+    }
+
+    @objc private func handleRetake() {
+        showCaptureScreen()
+    }
+
+    @objc func handleSave() {
+        guard let jpeg = capturedJpeg else { return }
+        finish(.success, imageBase64: jpeg.base64EncodedString())
+    }
+}
+
+extension KtpOcrViewController: 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?.showPreviewScreen(image: nil, errorMessage: "Gagal mengambil foto, silakan coba lagi.")
+            }
+            return
+        }
+        let displaySize = cameraContainer?.bounds.size ?? .zero
+        let frame = overlay?.frameRect ?? .zero
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            let framed = KtpImagePreparer.cropToFrame(
+                image: image,
+                displaySize: displaySize,
+                frame: frame
+            )
+            DispatchQueue.main.async {
+                guard let self else { return }
+                self.inspectThenPreview(framed.image)
+            }
+        }
+    }
+}