@simasfin/smmf-sdk 0.0.0-stage → 0.2.3

package/ios/OnePassSDK/Ocr/KtpPhotoInspector.swift

@@ -0,0 +1,93 @@
+import UIKit
+import Vision
+
+final class KtpPhotoInspector {
+
+    private static let metricSampleWidth = 640
+
+    struct Inspection {
+        let quality: KtpQualityResult
+        let textBounds: CGRect?
+    }
+
+    func inspect(image: UIImage, completion: @escaping (Inspection) -> Void) {
+        guard let cgImage = image.cgImage else {
+            completion(Inspection(quality: passthrough(), textBounds: nil))
+            return
+        }
+        let imageSize = CGSize(width: cgImage.width, height: cgImage.height)
+        let request = VNRecognizeTextRequest { request, _ in
+            let observations = request.results as? [VNRecognizedTextObservation] ?? []
+            let boxes = observations.map { observation in
+                CGRect(
+                    x: observation.boundingBox.minX * imageSize.width,
+                    y: (1 - observation.boundingBox.maxY) * imageSize.height,
+                    width: observation.boundingBox.width * imageSize.width,
+                    height: observation.boundingBox.height * imageSize.height
+                )
+            }
+            let text = observations
+                .compactMap { $0.topCandidates(1).first?.string }
+                .joined(separator: "\n")
+            let bounds = KtpAutoCrop.union(boxes)
+            let luma = Self.grayscaleSamples(cgImage)
+            let quality = KtpQualityGate.evaluate(
+                recognizedText: text,
+                textCoverage: bounds.map { KtpAutoCrop.coverage($0, imageSize: imageSize) } ?? 0,
+                textTouchesEdge: bounds.map { KtpAutoCrop.touchesEdge($0, imageSize: imageSize) } ?? false,
+                sharpness: ImageQualityMetrics.sharpness(
+                    luma: luma.values,
+                    width: luma.width,
+                    height: luma.height
+                ),
+                glareRatio: ImageQualityMetrics.glareRatio(luma: luma.values)
+            )
+            completion(Inspection(quality: quality, textBounds: bounds))
+        }
+        request.recognitionLevel = .accurate
+        request.usesLanguageCorrection = false
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            let handler = VNImageRequestHandler(cgImage: cgImage, orientation: .up)
+            do {
+                try handler.perform([request])
+            } catch {
+                completion(Inspection(quality: self?.passthrough() ?? KtpQualityResult(passed: true, issue: nil, message: nil), textBounds: nil))
+            }
+        }
+    }
+
+    private func passthrough() -> KtpQualityResult {
+        KtpQualityResult(passed: true, issue: nil, message: nil)
+    }
+
+    private struct Grayscale {
+        let values: [Int]
+        let width: Int
+        let height: Int
+    }
+
+    private static func grayscaleSamples(_ cgImage: CGImage) -> Grayscale {
+        let scale = CGFloat(metricSampleWidth) / CGFloat(cgImage.width)
+        let width = scale < 1 ? metricSampleWidth : cgImage.width
+        let height = scale < 1 ? Int(CGFloat(cgImage.height) * scale) : cgImage.height
+        guard width > 0, height > 0 else { return Grayscale(values: [], width: 0, height: 0) }
+
+        var pixels = [UInt8](repeating: 0, count: width * height)
+        guard
+            let context = CGContext(
+                data: &pixels,
+                width: width,
+                height: height,
+                bitsPerComponent: 8,
+                bytesPerRow: width,
+                space: CGColorSpaceCreateDeviceGray(),
+                bitmapInfo: CGImageAlphaInfo.none.rawValue
+            )
+        else {
+            return Grayscale(values: [], width: 0, height: 0)
+        }
+        context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
+        return Grayscale(values: pixels.map { Int($0) }, width: width, height: height)
+    }
+}

package/ios/OnePassSDK/Ocr/KtpQualityGate.swift

@@ -0,0 +1,185 @@
+import CoreGraphics
+import Foundation
+
+public enum KtpQualityIssue {
+    case textNotReadable
+    case cropped
+    case tooSmall
+    case glare
+    case blurry
+}
+
+public struct KtpQualityResult: Equatable {
+    public let passed: Bool
+    public let issue: KtpQualityIssue?
+    public let message: String?
+}
+
+public enum KtpQualityGate {
+
+    public static let minLabelMatches = 3
+    public static let minTextCoverage: Float = 0.12
+    public static let minSharpness: Double = 60
+    public static let maxGlareRatio: Float = 0.12
+
+    private static let requiredLabels = [
+        "PROVINSI",
+        "NIK",
+        "NAMA",
+        "LAHIR",
+        "KELAMIN",
+        "ALAMAT",
+        "AGAMA",
+        "PEKERJAAN",
+        "KEWARGANEGARAAN",
+        "BERLAKU",
+    ]
+
+    public static func evaluate(
+        recognizedText: String,
+        textCoverage: Float,
+        textTouchesEdge: Bool,
+        sharpness: Double,
+        glareRatio: Float
+    ) -> KtpQualityResult {
+        guard isReadable(recognizedText) else {
+            return failure(
+                .textNotReadable,
+                "Teks KTP belum terbaca jelas. Pastikan KTP tidak tertutup dan cahaya cukup."
+            )
+        }
+        if textTouchesEdge {
+            return failure(.cropped, "KTP terpotong. Masukkan seluruh KTP ke dalam kotak.")
+        }
+        if textCoverage < minTextCoverage {
+            return failure(.tooSmall, "KTP terlalu jauh. Dekatkan KTP hingga memenuhi kotak.")
+        }
+        if glareRatio > maxGlareRatio {
+            return failure(
+                .glare,
+                "Ada cahaya menyilaukan di KTP. Miringkan sedikit lalu ambil ulang."
+            )
+        }
+        if sharpness < minSharpness {
+            return failure(.blurry, "Foto buram. Tahan HP lebih stabil lalu ambil ulang.")
+        }
+        return KtpQualityResult(passed: true, issue: nil, message: nil)
+    }
+
+    private static func isReadable(_ recognizedText: String) -> Bool {
+        let upper = recognizedText.uppercased()
+        if containsNik(upper) { return true }
+        return requiredLabels.filter { upper.contains($0) }.count >= minLabelMatches
+    }
+
+    private static func containsNik(_ text: String) -> Bool {
+        var digitRun = 0
+        for character in text {
+            if character.isNumber {
+                digitRun += 1
+                if digitRun == 16 { return true }
+            } else {
+                digitRun = 0
+            }
+        }
+        return false
+    }
+
+    private static func failure(_ issue: KtpQualityIssue, _ message: String) -> KtpQualityResult {
+        KtpQualityResult(passed: false, issue: issue, message: message)
+    }
+}
+
+public enum KtpAutoCrop {
+
+    public static let paddingRatio: CGFloat = 0.06
+    public static let edgeMarginRatio: CGFloat = 0.02
+
+    public static func union(_ boxes: [CGRect]) -> CGRect? {
+        guard let first = boxes.first else { return nil }
+        return boxes.dropFirst().reduce(first) { $0.union($1) }
+    }
+
+    public static func coverage(_ bounds: CGRect, imageSize: CGSize) -> Float {
+        let area = imageSize.width * imageSize.height
+        guard area > 0 else { return 0 }
+        return Float((bounds.width * bounds.height) / area)
+    }
+
+    public static func touchesEdge(_ bounds: CGRect, imageSize: CGSize) -> Bool {
+        let marginX = imageSize.width * edgeMarginRatio
+        let marginY = imageSize.height * edgeMarginRatio
+        return bounds.minX <= marginX
+            || bounds.minY <= marginY
+            || bounds.maxX >= imageSize.width - marginX
+            || bounds.maxY >= imageSize.height - marginY
+    }
+
+    public static func cropTo(
+        bounds: CGRect,
+        imageSize: CGSize,
+        targetRatio: CGFloat
+    ) -> CropRegion {
+        let padded = bounds.insetBy(
+            dx: -bounds.width * paddingRatio,
+            dy: -bounds.height * paddingRatio
+        )
+        var width = padded.width
+        var height = padded.height
+        if width / height > targetRatio {
+            height = width / targetRatio
+        } else {
+            width = height * targetRatio
+        }
+        let cappedWidth = min(width, imageSize.width)
+        let cappedHeight = min(cappedWidth / targetRatio, imageSize.height)
+        let finalWidth = min(cappedWidth, cappedHeight * targetRatio)
+        let finalHeight = finalWidth / targetRatio
+
+        let left = max(0, min(padded.midX - finalWidth / 2, imageSize.width - finalWidth))
+        let top = max(0, min(padded.midY - finalHeight / 2, imageSize.height - finalHeight))
+
+        return CropRegion(
+            left: Int(left.rounded()),
+            top: Int(top.rounded()),
+            width: max(1, Int(finalWidth.rounded())),
+            height: max(1, Int(finalHeight.rounded()))
+        )
+    }
+}
+
+public enum ImageQualityMetrics {
+
+    private static let overexposedLuma = 250
+
+    public static func sharpness(luma: [Int], width: Int, height: Int) -> Double {
+        guard width >= 3, height >= 3, luma.count >= width * height else { return 0 }
+        var sum = 0.0
+        var sumSquares = 0.0
+        var count = 0
+        for y in 1..<(height - 1) {
+            for x in 1..<(width - 1) {
+                let index = y * width + x
+                let value = Double(
+                    4 * luma[index]
+                        - luma[index - 1]
+                        - luma[index + 1]
+                        - luma[index - width]
+                        - luma[index + width]
+                )
+                sum += value
+                sumSquares += value * value
+                count += 1
+            }
+        }
+        guard count > 0 else { return 0 }
+        let mean = sum / Double(count)
+        return sumSquares / Double(count) - mean * mean
+    }
+
+    public static func glareRatio(luma: [Int]) -> Float {
+        guard !luma.isEmpty else { return 0 }
+        let overexposed = luma.filter { $0 >= overexposedLuma }.count
+        return Float(overexposed) / Float(luma.count)
+    }
+}

package/ios/OnePassSDK/OnePass.swift

@@ -0,0 +1,28 @@
+import UIKit
+
+public enum OnePass {
+
+    public static func startLiveness(
+        from presenter: UIViewController,
+        input: LivenessInput = LivenessInput(),
+        completion: @escaping (LivenessResult) -> Void
+    ) {
+        let controller = LivenessViewController(input: input) { result in
+            presenter.dismiss(animated: true) { completion(result) }
+        }
+        controller.modalPresentationStyle = .fullScreen
+        presenter.present(controller, animated: true)
+    }
+
+    public static func startKtpOcr(
+        from presenter: UIViewController,
+        input: KtpOcrInput = KtpOcrInput(),
+        completion: @escaping (KtpOcrResult) -> Void
+    ) {
+        let controller = KtpOcrViewController(input: input) { result in
+            presenter.dismiss(animated: true) { completion(result) }
+        }
+        controller.modalPresentationStyle = .fullScreen
+        presenter.present(controller, animated: true)
+    }
+}

package/ios/OnePassSDK/Signature/SignaturePadView.swift

@@ -0,0 +1,144 @@
+import UIKit
+
+public final class SignaturePadView: UIView {
+
+    public var onBegin: (() -> Void)?
+    public var onEnd: (() -> Void)?
+
+    public var penColor: UIColor = .black {
+        didSet { setNeedsDisplay() }
+    }
+
+    public var strokeWidth: CGFloat = 2 {
+        didSet { setNeedsDisplay() }
+    }
+
+    private var strokes: [UIBezierPath] = []
+    private var dots: [CGPoint] = []
+    private var current: UIBezierPath?
+    private var moved = false
+    private var lastPoint: CGPoint = .zero
+    private var lockedScrollViews: [UIScrollView] = []
+
+    public var isEmpty: Bool { strokes.isEmpty && dots.isEmpty }
+
+    public override init(frame: CGRect) {
+        super.init(frame: frame)
+        backgroundColor = .clear
+        isOpaque = false
+        isMultipleTouchEnabled = false
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) { fatalError("tidak dipakai") }
+
+    public func clear() {
+        strokes.removeAll()
+        dots.removeAll()
+        current = nil
+        setNeedsDisplay()
+    }
+
+    public func toBase64Png() -> String? {
+        guard !isEmpty, bounds.width > 0, bounds.height > 0 else { return nil }
+        let format = UIGraphicsImageRendererFormat.default()
+        format.opaque = false
+        let image = UIGraphicsImageRenderer(bounds: bounds, format: format).image { _ in
+            drawStrokes()
+        }
+        return image.pngData()?.base64EncodedString()
+    }
+
+    public override func draw(_ rect: CGRect) {
+        drawStrokes()
+    }
+
+    private func drawStrokes() {
+        penColor.setStroke()
+        penColor.setFill()
+        for path in strokes {
+            path.lineWidth = strokeWidth
+            path.lineCapStyle = .round
+            path.lineJoinStyle = .round
+            path.stroke()
+        }
+        for dot in dots {
+            UIBezierPath(
+                arcCenter: dot,
+                radius: strokeWidth / 2,
+                startAngle: 0,
+                endAngle: .pi * 2,
+                clockwise: true
+            ).fill()
+        }
+    }
+
+    func beginStroke(at point: CGPoint) {
+        let path = UIBezierPath()
+        path.move(to: point)
+        current = path
+        moved = false
+        lastPoint = point
+        lockScrollViews()
+        onBegin?()
+        setNeedsDisplay()
+    }
+
+    func continueStroke(to point: CGPoint) {
+        guard let path = current else { return }
+        if !moved {
+            strokes.append(path)
+            moved = true
+        }
+        let mid = CGPoint(x: (point.x + lastPoint.x) / 2, y: (point.y + lastPoint.y) / 2)
+        path.addQuadCurve(to: mid, controlPoint: lastPoint)
+        lastPoint = point
+        setNeedsDisplay()
+    }
+
+    func endStroke(at point: CGPoint) {
+        guard let path = current else { return }
+        if moved { path.addLine(to: point) } else { dots.append(point) }
+        current = nil
+        unlockScrollViews()
+        onEnd?()
+        setNeedsDisplay()
+    }
+
+    private func lockScrollViews() {
+        var view = superview
+        while let candidate = view {
+            if let scroll = candidate as? UIScrollView, scroll.isScrollEnabled {
+                scroll.isScrollEnabled = false
+                lockedScrollViews.append(scroll)
+            }
+            view = candidate.superview
+        }
+    }
+
+    private func unlockScrollViews() {
+        lockedScrollViews.forEach { $0.isScrollEnabled = true }
+        lockedScrollViews.removeAll()
+    }
+
+    public override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
+        guard let touch = touches.first else { return }
+        beginStroke(at: touch.location(in: self))
+    }
+
+    public override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
+        guard let touch = touches.first else { return }
+        let samples = event?.coalescedTouches(for: touch) ?? [touch]
+        samples.forEach { continueStroke(to: $0.location(in: self)) }
+    }
+
+    public override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
+        guard let touch = touches.first else { return }
+        endStroke(at: touch.location(in: self))
+    }
+
+    public override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {
+        guard let touch = touches.first else { return }
+        endStroke(at: touch.location(in: self))
+    }
+}

package/ios/OnePassSignatureExpoView.swift

@@ -0,0 +1,22 @@
+import ExpoModulesCore
+import UIKit
+
+public final class OnePassSignatureExpoView: ExpoView {
+
+    let pad = SignaturePadView(frame: .zero)
+    let onBegin = EventDispatcher()
+    let onEnd = EventDispatcher()
+
+    public required init(appContext: AppContext? = nil) {
+        super.init(appContext: appContext)
+        clipsToBounds = true
+        addSubview(pad)
+        pad.onBegin = { [weak self] in self?.onBegin([:]) }
+        pad.onEnd = { [weak self] in self?.onEnd([:]) }
+    }
+
+    public override func layoutSubviews() {
+        super.layoutSubviews()
+        pad.frame = bounds
+    }
+}

package/ios/OnepassExpo.podspec

@@ -0,0 +1,23 @@
+Pod::Spec.new do |s|
+  s.name           = 'OnepassExpo'
+  s.version        = '0.1.0'
+  s.summary        = 'Expo module untuk liveness wajah, foto KTP, dan kanvas tanda tangan'
+  s.description    = 'Binding Expo untuk liveness wajah, foto KTP, dan kanvas tanda tangan.'
+  s.author         = 'simasfin'
+  s.homepage       = 'https://www.npmjs.com/package/@simasfin/smmf-sdk'
+  s.platforms      = { :ios => '13.4' }
+  s.source         = { :git => '' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  s.source_files = 'OnepassExpoModule.swift', 'OnePassSignatureExpoView.swift', 'OnePassSDK/**/*.swift'
+  s.resource_bundles = {
+    'OnePassSDK' => ['OnePassSDK/Resources/*']
+  }
+end

package/ios/OnepassExpoModule.swift

@@ -0,0 +1,77 @@
+import ExpoModulesCore
+import UIKit
+
+public class OnepassExpoModule: Module {
+
+    public func definition() -> ModuleDefinition {
+        Name("OnepassExpo")
+
+        AsyncFunction("startLiveness") { (options: [String: Any], promise: Promise) in
+            guard let presenter = self.appContext?.utilities?.currentViewController() else {
+                promise.reject("ONEPASS_NO_VIEW_CONTROLLER", "Tidak ada view controller aktif")
+                return
+            }
+            let input = LivenessInput(primaryColorHex: options["primaryColorHex"] as? String)
+            OnePass.startLiveness(from: presenter, input: input) { result in
+                promise.resolve([
+                    "status": Self.statusName(result.status),
+                    "imageBase64": result.imageBase64 as Any?,
+                    "errorMessage": result.errorMessage as Any?,
+                ])
+            }
+        }
+        .runOnQueue(.main)
+
+        AsyncFunction("startKtpOcr") { (options: [String: Any], promise: Promise) in
+            guard let presenter = self.appContext?.utilities?.currentViewController() else {
+                promise.reject("ONEPASS_NO_VIEW_CONTROLLER", "Tidak ada view controller aktif")
+                return
+            }
+            let input = KtpOcrInput(primaryColorHex: options["primaryColorHex"] as? String)
+            OnePass.startKtpOcr(from: presenter, input: input) { result in
+                promise.resolve([
+                    "status": Self.statusName(result.status),
+                    "imageBase64": result.imageBase64 as Any?,
+                    "errorMessage": result.errorMessage as Any?,
+                ])
+            }
+        }
+        .runOnQueue(.main)
+
+        View(OnePassSignatureExpoView.self) {
+            Events("onBegin", "onEnd")
+
+            Prop("penColor") { (view: OnePassSignatureExpoView, color: String?) in
+                view.pad.penColor = color.map { UIColor(hex: $0) } ?? .black
+            }
+
+            Prop("strokeWidth") { (view: OnePassSignatureExpoView, width: Double?) in
+                view.pad.strokeWidth = CGFloat(width ?? 2)
+            }
+
+            AsyncFunction("clear") { (view: OnePassSignatureExpoView) in
+                view.pad.clear()
+            }
+
+            AsyncFunction("readSignature") { (view: OnePassSignatureExpoView) -> String? in
+                view.pad.toBase64Png()
+            }
+        }
+    }
+
+    private static func statusName(_ status: LivenessStatus) -> String {
+        switch status {
+        case .success: return "SUCCESS"
+        case .failed: return "FAILED"
+        case .cancelled: return "CANCELLED"
+        }
+    }
+
+    private static func statusName(_ status: KtpOcrStatusCode) -> String {
+        switch status {
+        case .success: return "SUCCESS"
+        case .failed: return "FAILED"
+        case .cancelled: return "CANCELLED"
+        }
+    }
+}

package/licenses/Iconsax-MIT.txt

@@ -0,0 +1,26 @@
+Iconsax icon set
+Copyright (c) Vuesax (https://iconsax.io)
+
+Didistribusikan melalui paket npm "iconsax-react-native" yang berlisensi MIT.
+Ikon Camera, Flash, FlashSlash, CloseSquare, Danger, dan User pada SDK ini
+dihasilkan dari data path SVG paket tersebut.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.