capacitor-microblink 0.2.0 → 0.3.1

package/ios/Sources/MicroblinkPlugin/MicroblinkPlugin.swift

@@ -1,332 +1,257 @@
 import Foundation
 import Capacitor
+import Combine
+import SwiftUI
+import AVFoundation
 import BlinkCard
-import MicroblinkPlatform
+import BlinkCardUX
 
 @objc(MicroblinkPlugin)
-public class MicroblinkPlugin: CAPPlugin, CAPBridgedPlugin, MicroblinkPlatformSDKDelegate, MBCBlinkCardOverlayViewControllerDelegate {
+public class MicroblinkPlugin: CAPPlugin, CAPBridgedPlugin {
     public let identifier = "MicroblinkPlugin"
     public let jsName = "Microblink"
     public let pluginMethods: [CAPPluginMethod] = [
-        CAPPluginMethod(name: "startVerification", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "scanCard", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "initializeBlinkCard", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "scanCard", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "terminateBlinkCard", returnType: CAPPluginReturnPromise)
     ]
-    private var pendingVerificationCallId: String?
-    private var verificationSDK: MicroblinkPlatformSDK?
-    private var pendingVerificationCardScanResult: [String: Any]?
 
-    private var pendingBlinkCardCallId: String?
-    private var blinkCardRecognizer: MBCBlinkCardRecognizer?
-    private weak var blinkCardRunnerViewController: UIViewController?
+    private enum PluginError: LocalizedError {
+        case sdkNotInitialized
 
-    @objc public func startVerification(_ call: CAPPluginCall) {
-        if pendingVerificationCallId != nil || pendingBlinkCardCallId != nil {
-            call.reject("A native flow is already running.")
-            return
-        }
-        guard let workflowId = call.getString("workflowId"), !workflowId.isEmpty else {
-            call.reject("Missing required field: workflowId.")
-            return
-        }
-        guard let url = call.getString("url"), !url.isEmpty else {
-            call.reject("Missing required field: url.")
-            return
-        }
-        guard let userId = call.getString("userId"), !userId.isEmpty else {
-            call.reject("Missing required field: userId.")
-            return
-        }
-        guard let isProcessingStoringAllowed = call.getBool("isProcessingStoringAllowed") else {
-            call.reject("Missing required field: isProcessingStoringAllowed.")
-            return
-        }
-        guard let isTrainingAllowed = call.getBool("isTrainingAllowed") else {
-            call.reject("Missing required field: isTrainingAllowed.")
-            return
-        }
-        guard let vc = bridge?.viewController else {
-            call.reject("No view controller available")
-            return
+        var errorDescription: String? {
+            switch self {
+            case .sdkNotInitialized:
+                return "BlinkCard is not initialized. Call initializeBlinkCard first or provide licenseKey in scanCard."
+            }
         }
+    }
 
-        let givenOnMs = call.getDouble("givenOn") ?? Date().timeIntervalSince1970 * 1000
-        let givenOn = Date(timeIntervalSince1970: givenOnMs / 1000)
-        let consent = MicroblinkPlatformConsent(
-            userId: userId,
-            isProcessingStoringAllowed: isProcessingStoringAllowed,
-            isTrainingAllowed: isTrainingAllowed,
-            isGivenOn: givenOn,
-            note: call.getString("note")
-        )
+    private var pendingBlinkCardCallId: String?
+    private weak var blinkCardHostingController: UIViewController?
+    private var blinkCardResultObserver: AnyCancellable?
 
-        let serviceSettings = MicroblinkPlatformServiceSettings(
-            workflowId: workflowId,
-            url: url,
-            consent: consent,
-            additionalRequestHeaders: call.getObject("additionalRequestHeaders") as? [String: String]
-        )
-        if let startTransaction = call.getString("startTransactionPath"), !startTransaction.isEmpty {
-            serviceSettings.startTransaction = startTransaction
-        }
-        if let cancelWorkflow = call.getString("cancelWorkflowPath"), !cancelWorkflow.isEmpty {
-            serviceSettings.cancelWorkflow = cancelWorkflow
-        }
-        if let workflowInfo = call.getString("workflowInfoPath"), !workflowInfo.isEmpty {
-            serviceSettings.getWorkflowInfo = workflowInfo
+    private var blinkCardSdk: BlinkCardSdk?
+    private var isBlinkCardInitialized = false
+
+    @objc public func initializeBlinkCard(_ call: CAPPluginCall) {
+        guard let licenseKey = call.getString("licenseKey"), !licenseKey.isEmpty else {
+            call.reject("Missing required field: licenseKey.")
+            return
         }
 
-        pendingVerificationCardScanResult = nil
-        bridge?.saveCall(call)
-        pendingVerificationCallId = call.callbackId
-        verificationSDK = MicroblinkPlatformSDK(serviceSettings: serviceSettings, delegate: self)
+        let licensee = normalized(call.getString("licensee"))
 
-        let sdkViewController = verificationSDK?.startSDK()
-        guard let sdkViewController else {
-            clearPendingVerificationState()
-            call.reject("Unable to start verification.")
-            return
+        Task {
+            do {
+                let sdk = try await createBlinkCardSdk(licenseKey: licenseKey, licensee: licensee)
+                await MainActor.run {
+                    self.blinkCardSdk = sdk
+                    self.isBlinkCardInitialized = true
+                    call.resolve(["initialized": true])
+                }
+            } catch {
+                await MainActor.run {
+                    self.isBlinkCardInitialized = false
+                    call.reject("Failed to initialize BlinkCard SDK: \(error.localizedDescription)")
+                }
+            }
         }
-        vc.present(sdkViewController, animated: true)
     }
 
     @objc public func scanCard(_ call: CAPPluginCall) {
-        if pendingVerificationCallId != nil || pendingBlinkCardCallId != nil {
-            call.reject("A native flow is already running.")
-            return
+        ensureCameraPermission(call) { [weak self] in
+            self?.performScanCard(call)
         }
-        guard let licenseKey = call.getString("licenseKey"), !licenseKey.isEmpty else {
-            call.reject("Missing required field: licenseKey.")
+    }
+
+    private func performScanCard(_ call: CAPPluginCall) {
+        if pendingBlinkCardCallId != nil {
+            call.reject("A BlinkCard flow is already running.")
             return
         }
-        guard let vc = bridge?.viewController else {
+
+        guard let viewController = bridge?.viewController else {
             call.reject("No view controller available")
             return
         }
 
-        bridge?.saveCall(call)
-        pendingBlinkCardCallId = call.callbackId
+        let providedLicenseKey = normalized(call.getString("licenseKey"))
+        let providedLicensee = normalized(call.getString("licensee"))
 
-        let licenseErrorHandler: MBCLicenseErrorBlock = { [weak self] licenseError in
-            guard let self, let pendingBlinkCardCallId, let pendingCall = self.bridge?.savedCall(withID: pendingBlinkCardCallId) else {
-                return
-            }
-            self.clearPendingBlinkCardState()
-            pendingCall.reject("Failed to initialize BlinkCard license (\(licenseError.rawValue)).")
-            self.bridge?.releaseCall(withID: pendingBlinkCardCallId)
-        }
-
-        if let licensee = call.getString("licensee"), !licensee.isEmpty {
-            MBCMicroblinkSDK.shared().setLicenseKey(licenseKey, andLicensee: licensee, errorCallback: licenseErrorHandler)
-        } else {
-            MBCMicroblinkSDK.shared().setLicenseKey(licenseKey, errorCallback: licenseErrorHandler)
-        }
+        Task {
+            do {
+                let sdk: BlinkCardSdk
+                if let providedLicenseKey {
+                    sdk = try await createBlinkCardSdk(licenseKey: providedLicenseKey, licensee: providedLicensee)
+                    await MainActor.run {
+                        self.blinkCardSdk = sdk
+                        self.isBlinkCardInitialized = true
+                    }
+                } else {
+                    guard let existingSdk = await MainActor.run(body: { self.blinkCardSdk }), self.isBlinkCardInitialized else {
+                        throw PluginError.sdkNotInitialized
+                    }
+                    sdk = existingSdk
+                }
 
-        let recognizer = MBCBlinkCardRecognizer()
-        recognizer.extractOwner = call.getBool("extractOwner") ?? true
-        recognizer.extractExpiryDate = call.getBool("extractExpiryDate") ?? true
-        recognizer.extractCvv = call.getBool("extractCvv") ?? true
-        recognizer.extractIban = call.getBool("extractIban") ?? true
-        recognizer.allowInvalidCardNumber = call.getBool("allowInvalidCardNumber") ?? false
-
-        let recognizerCollection = MBCRecognizerCollection(recognizers: [recognizer])
-        let overlaySettings = MBCBlinkCardOverlaySettings()
-        overlaySettings.enableEditScreen = call.getBool("enableEditScreen") ?? true
-
-        let overlayViewController = MBCBlinkCardOverlayViewController(
-            settings: overlaySettings,
-            recognizerCollection: recognizerCollection,
-            delegate: self
-        )
-        guard let runnerViewController = MBCViewControllerFactory.recognizerRunnerViewController(withOverlayViewController: overlayViewController) else {
-            clearPendingBlinkCardState()
-            bridge?.releaseCall(withID: call.callbackId)
-            call.reject("Unable to create BlinkCard runner view controller.")
-            return
+                try await startBlinkCardScan(call: call, sdk: sdk, presentingViewController: viewController)
+            } catch let error as PluginError {
+                await MainActor.run {
+                    call.reject(error.localizedDescription)
+                }
+            } catch {
+                await MainActor.run {
+                    call.reject("Failed to start BlinkCard scan: \(error.localizedDescription)")
+                }
+            }
         }
-
-        blinkCardRecognizer = recognizer
-        blinkCardRunnerViewController = runnerViewController
-
-        vc.present(runnerViewController, animated: true)
     }
 
-    public func microblinkPlatformSDKDidFinish(
-        viewController: UIViewController,
-        result: MicroblinkPlatformResult
-    ) {
-        var payload: [String: Any] = [
-            "canceled": false,
-            "transactionId": result.transactionId,
-            "status": mapStatus(result.status)
-        ]
-        if let pendingVerificationCardScanResult {
-            payload["cardScanResult"] = pendingVerificationCardScanResult
+    private func ensureCameraPermission(_ call: CAPPluginCall, onGranted: @escaping () -> Void) {
+        let status = AVCaptureDevice.authorizationStatus(for: .video)
+        switch status {
+        case .authorized:
+            onGranted()
+        case .notDetermined:
+            AVCaptureDevice.requestAccess(for: .video) { granted in
+                DispatchQueue.main.async {
+                    if granted {
+                        onGranted()
+                    } else {
+                        call.reject("Camera permission is required to scan cards.")
+                    }
+                }
+            }
+        case .denied, .restricted:
+            call.reject("Camera permission is required to scan cards. Enable it in iOS Settings.")
+        @unknown default:
+            call.reject("Unable to determine camera permission status.")
         }
-        finalize(viewController: viewController, payload: payload)
     }
 
-    public func microblinkPlatformSDKDidClose(
-        viewController: UIViewController,
-        cancelState: MicroblinkPlatformCancelState
-    ) {
-        var payload: [String: Any] = [
-            "canceled": true,
-            "transactionId": cancelState.transactionId as Any,
-            "cancelReason": mapCancelReason(cancelState.cancelReason)
-        ]
-        if let pendingVerificationCardScanResult {
-            payload["cardScanResult"] = pendingVerificationCardScanResult
+    @objc public func terminateBlinkCard(_ call: CAPPluginCall) {
+        Task {
+            await BlinkCardSdk.terminateBlinkCardSdk()
+            await MainActor.run {
+                self.blinkCardSdk = nil
+                self.isBlinkCardInitialized = false
+                call.resolve(["terminated": true])
+            }
         }
-        finalize(viewController: viewController, payload: payload)
     }
 
-    public func microblinkPlatformSDKDidFinishCardScanStep(
-        viewController: UIViewController,
-        cardScanResult: MicroblinkPlatformResultCardScanResult
-    ) {
-        pendingVerificationCardScanResult = [
-            "cardNumber": cardScanResult.cardNumber,
-            "expiryDate": cardScanResult.expiryDate,
-            "owner": cardScanResult.owner,
-            "cvv": cardScanResult.cvv
-        ]
-    }
+    private func startBlinkCardScan(call: CAPPluginCall, sdk: BlinkCardSdk, presentingViewController: UIViewController) async throws {
+        let extractionSettings = ExtractionSettings(
+            extractIban: call.getBool("extractIban") ?? true,
+            extractExpiryDate: call.getBool("extractExpiryDate") ?? true,
+            extractCardholderName: call.getBool("extractOwner") ?? true,
+            extractCvv: call.getBool("extractCvv") ?? true,
+            extractInvalidCardNumber: call.getBool("allowInvalidCardNumber") ?? false
+        )
+        let scanningSettings = ScanningSettings(extractionSettings: extractionSettings)
+        let sessionSettings = BlinkCardSessionSettings(inputImageSource: .video, scanningSettings: scanningSettings)
 
-    public func blinkCardOverlayViewControllerDidFinishScanning(
-        _ blinkCardOverlayViewController: MBCBlinkCardOverlayViewController,
-        state: MBCRecognizerResultState
-    ) {
-        let result = blinkCardRecognizer?.result
-        var payload: [String: Any] = [
-            "canceled": false,
-            "resultState": mapBlinkCardResultState(state)
-        ]
-        if let result {
-            payload["processingStatus"] = mapBlinkCardProcessingStatus(result.processingStatus)
-            payload["cardNumber"] = result.cardNumber
-            payload["cardNumberValid"] = result.cardNumberValid
-            payload["cardNumberPrefix"] = result.cardNumberPrefix
-            payload["owner"] = result.owner
-            payload["cvv"] = result.cvv
-            payload["iban"] = result.iban
-            payload["expiryDate"] = mapBlinkCardDate(result.expiryDate)
-        }
-        finalizeBlinkCard(payload: payload)
-    }
+        let analyzer = try await BlinkCardAnalyzer(
+            sdk: sdk,
+            blinkCardSessionSettings: sessionSettings,
+            eventStream: BlinkCardEventStream()
+        )
 
-    public func blinkCardOverlayViewControllerDidTapClose(
-        _ blinkCardOverlayViewController: MBCBlinkCardOverlayViewController
-    ) {
-        finalizeBlinkCard(payload: ["canceled": true])
-    }
+        await MainActor.run {
+            let viewModel = BlinkCardUXModel(analyzer: analyzer)
+            let hostingController = UIHostingController(rootView: BlinkCardUXView(viewModel: viewModel))
+            hostingController.modalPresentationStyle = .fullScreen
 
-    private func mapStatus(_ status: MicroblinkPlatformResultStatus) -> String {
-        switch status {
-        case .accept:
-            return "accept"
-        case .review:
-            return "review"
-        case .reject:
-            return "reject"
-        @unknown default:
-            return "review"
-        }
-    }
+            self.bridge?.saveCall(call)
+            self.pendingBlinkCardCallId = call.callbackId
+            self.blinkCardHostingController = hostingController
 
-    private func mapCancelReason(_ reason: MicroblinkPlatformCancelReason) -> String {
-        switch reason {
-        case .userCanceled:
-            return "userCanceled"
-        case .consentDenied:
-            return "consentDenied"
-        @unknown default:
-            return "userCanceled"
+            self.blinkCardResultObserver = viewModel.$result
+                .dropFirst()
+                .sink { [weak self] resultState in
+                    self?.handleBlinkCardResult(resultState)
+                }
+
+            presentingViewController.present(hostingController, animated: true)
         }
     }
 
-    private func finalize(viewController: UIViewController, payload: [String: Any]) {
-        viewController.dismiss(animated: true)
-        guard let pendingVerificationCallId, let call = bridge?.savedCall(withID: pendingVerificationCallId) else {
-            clearPendingVerificationState()
+    private func handleBlinkCardResult(_ resultState: BlinkCardResultState?) {
+        guard let scanningResult = resultState?.scanningResult else {
+            finalizeBlinkCard(payload: ["canceled": true])
             return
         }
-        clearPendingVerificationState()
-        call.resolve(payload)
-        bridge?.releaseCall(withID: pendingVerificationCallId)
-    }
 
-    private func clearPendingVerificationState() {
-        pendingVerificationCallId = nil
-        pendingVerificationCardScanResult = nil
-        verificationSDK = nil
-    }
+        var payload: [String: Any] = [
+            "canceled": false,
+            "resultState": "valid",
+            "processingStatus": "success",
+            "owner": scanningResult.cardholderName as Any,
+            "iban": scanningResult.iban as Any
+        ]
 
-    private func clearPendingBlinkCardState() {
-        pendingBlinkCardCallId = nil
-        blinkCardRecognizer = nil
-        blinkCardRunnerViewController = nil
+        if let cardAccount = scanningResult.cardAccounts.first {
+            payload["cardNumber"] = cardAccount.cardNumber
+            payload["cardNumberValid"] = cardAccount.cardNumberValid
+            payload["cardNumberPrefix"] = cardAccount.cardNumberPrefix as Any
+            payload["cvv"] = cardAccount.cvv as Any
+            payload["expiryDate"] = mapBlinkCardDate(cardAccount.expiryDate) as Any
+        }
+
+        finalizeBlinkCard(payload: payload)
     }
 
     private func finalizeBlinkCard(payload: [String: Any]) {
         DispatchQueue.main.async {
             let pendingCallId = self.pendingBlinkCardCallId
-            self.blinkCardRunnerViewController?.dismiss(animated: true)
+            self.blinkCardHostingController?.dismiss(animated: true)
+
             guard let pendingCallId, let call = self.bridge?.savedCall(withID: pendingCallId) else {
                 self.clearPendingBlinkCardState()
                 return
             }
+
             self.clearPendingBlinkCardState()
             call.resolve(payload)
             self.bridge?.releaseCall(withID: pendingCallId)
         }
     }
 
-    private func mapBlinkCardResultState(_ state: MBCRecognizerResultState) -> String {
-        switch state {
-        case .empty:
-            return "empty"
-        case .uncertain:
-            return "uncertain"
-        case .valid:
-            return "valid"
-        case .stageValid:
-            return "stageValid"
-        @unknown default:
-            return "empty"
-        }
+    private func clearPendingBlinkCardState() {
+        pendingBlinkCardCallId = nil
+        blinkCardHostingController = nil
+        blinkCardResultObserver = nil
     }
 
-    private func mapBlinkCardProcessingStatus(_ status: MBCBlinkCardProcessingStatus) -> String {
-        switch status {
-        case .success:
-            return "success"
-        case .detectionFailed:
-            return "detectionFailed"
-        case .imagePreprocessingFailed:
-            return "imagePreprocessingFailed"
-        case .stabilityTestFailed:
-            return "stabilityTestFailed"
-        case .scanningWrongSide:
-            return "scanningWrongSide"
-        case .fieldIdentificationFailed:
-            return "fieldIdentificationFailed"
-        case .imageReturnFailed:
-            return "imageReturnFailed"
-        case .unsupportedCard:
-            return "unsupportedCard"
-        @unknown default:
-            return "unsupportedCard"
+    private func normalized(_ value: String?) -> String? {
+        guard let value, !value.isEmpty else {
+            return nil
         }
+        return value
     }
 
-    private func mapBlinkCardDate(_ date: MBCDate?) -> [String: Int]? {
-        guard let date else {
+    private func mapBlinkCardDate(_ date: DateResult?) -> [String: Int]? {
+        guard let date,
+              let day = date.day,
+              let month = date.month,
+              let year = date.year else {
             return nil
         }
         return [
-            "day": Int(date.day),
-            "month": Int(date.month),
-            "year": Int(date.year)
+            "day": day,
+            "month": month,
+            "year": year
         ]
     }
+
+    private func createBlinkCardSdk(licenseKey: String, licensee: String?) async throws -> BlinkCardSdk {
+        await BlinkCardSdk.terminateBlinkCardSdk()
+        let settings = BlinkCardSdkSettings(
+            licenseKey: licenseKey,
+            licensee: licensee,
+            downloadResources: true
+        )
+        return try await BlinkCardSdk.createBlinkCardSdk(withSettings: settings)
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-microblink",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Capacitor plugin for microblink",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -31,7 +31,7 @@
   ],
   "scripts": {
     "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
-    "verify:ios": "xcodebuild -scheme CapacitorMicroblink -destination generic/platform=iOS",
+    "verify:ios": "xcodebuild -scheme CapacitorMicroblink -destination generic/platform=iOS -derivedDataPath /tmp/capacitor-microblink-deriveddata clean build",
     "verify:android": "cd android && ./gradlew clean build test && cd ..",
     "verify:web": "npm run build",
     "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",