capacitor-microblink 0.0.1 → 0.3.0

package/ios/Sources/MicroblinkPlugin/MicroblinkPlugin.swift

@@ -1,168 +1,216 @@
 import Foundation
 import Capacitor
-import MicroblinkPlatform
+import Combine
+import SwiftUI
+import BlinkCard
+import BlinkCardUX
 
 @objc(MicroblinkPlugin)
-public class MicroblinkPlugin: CAPPlugin, CAPBridgedPlugin, MicroblinkPlatformSDKDelegate {
+public class MicroblinkPlugin: CAPPlugin, CAPBridgedPlugin {
     public let identifier = "MicroblinkPlugin"
     public let jsName = "Microblink"
     public let pluginMethods: [CAPPluginMethod] = [
-        CAPPluginMethod(name: "startVerification", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "initializeBlinkCard", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "scanCard", returnType: CAPPluginReturnPromise)
     ]
-    private var pendingCallId: String?
-    private var sdk: MicroblinkPlatformSDK?
-    private var pendingCardScanResult: [String: Any]?
 
-    @objc public func startVerification(_ call: CAPPluginCall) {
-        if pendingCallId != nil {
-            call.reject("A verification 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
+    private enum PluginError: LocalizedError {
+        case sdkNotInitialized
+
+        var errorDescription: String? {
+            switch self {
+            case .sdkNotInitialized:
+                return "BlinkCard is not initialized. Call initializeBlinkCard first or provide licenseKey in scanCard."
+            }
         }
-        guard let userId = call.getString("userId"), !userId.isEmpty else {
-            call.reject("Missing required field: userId.")
+    }
+
+    private var pendingBlinkCardCallId: String?
+    private weak var blinkCardHostingController: UIViewController?
+    private var blinkCardResultObserver: AnyCancellable?
+
+    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
         }
-        guard let isProcessingStoringAllowed = call.getBool("isProcessingStoringAllowed") else {
-            call.reject("Missing required field: isProcessingStoringAllowed.")
-            return
+
+        let licensee = normalized(call.getString("licensee"))
+
+        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)")
+                }
+            }
         }
-        guard let isTrainingAllowed = call.getBool("isTrainingAllowed") else {
-            call.reject("Missing required field: isTrainingAllowed.")
+    }
+
+    @objc public func scanCard(_ 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
         }
 
-        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")
+        let providedLicenseKey = normalized(call.getString("licenseKey"))
+        let providedLicensee = normalized(call.getString("licensee"))
+
+        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
+                }
+
+                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)")
+                }
+            }
+        }
+    }
+
+    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)
 
-        let serviceSettings = MicroblinkPlatformServiceSettings(
-            workflowId: workflowId,
-            url: url,
-            consent: consent,
-            additionalRequestHeaders: call.getObject("additionalRequestHeaders") as? [String: String]
+        let analyzer = try await BlinkCardAnalyzer(
+            sdk: sdk,
+            blinkCardSessionSettings: sessionSettings,
+            eventStream: BlinkCardEventStream()
         )
-        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
-        }
 
-        pendingCardScanResult = nil
-        bridge?.saveCall(call)
-        pendingCallId = call.callbackId
-        sdk = MicroblinkPlatformSDK(serviceSettings: serviceSettings, delegate: self)
+        await MainActor.run {
+            let viewModel = BlinkCardUXModel(analyzer: analyzer)
+            let hostingController = UIHostingController(rootView: BlinkCardUXView(viewModel: viewModel))
+            hostingController.modalPresentationStyle = .fullScreen
 
-        let sdkViewController = sdk?.startSDK()
-        guard let sdkViewController else {
-            clearPendingState()
-            call.reject("Unable to start verification.")
-            return
+            self.bridge?.saveCall(call)
+            self.pendingBlinkCardCallId = call.callbackId
+            self.blinkCardHostingController = hostingController
+
+            self.blinkCardResultObserver = viewModel.$result
+                .dropFirst()
+                .sink { [weak self] resultState in
+                    self?.handleBlinkCardResult(resultState)
+                }
+
+            presentingViewController.present(hostingController, animated: true)
         }
-        vc.present(sdkViewController, animated: true)
     }
 
-    public func microblinkPlatformSDKDidFinish(
-        viewController: UIViewController,
-        result: MicroblinkPlatformResult
-    ) {
-        var payload: [String: Any] = [
-            "canceled": false,
-            "transactionId": result.transactionId,
-            "status": mapStatus(result.status)
-        ]
-        if let pendingCardScanResult {
-            payload["cardScanResult"] = pendingCardScanResult
+    private func handleBlinkCardResult(_ resultState: BlinkCardResultState?) {
+        guard let scanningResult = resultState?.scanningResult else {
+            finalizeBlinkCard(payload: ["canceled": true])
+            return
         }
-        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)
+            "canceled": false,
+            "resultState": "valid",
+            "processingStatus": "success",
+            "owner": scanningResult.cardholderName as Any,
+            "iban": scanningResult.iban as Any
         ]
-        if let pendingCardScanResult {
-            payload["cardScanResult"] = pendingCardScanResult
+
+        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
         }
-        finalize(viewController: viewController, payload: payload)
-    }
 
-    public func microblinkPlatformSDKDidFinishCardScanStep(
-        viewController: UIViewController,
-        cardScanResult: MicroblinkPlatformResultCardScanResult
-    ) {
-        pendingCardScanResult = [
-            "cardNumber": cardScanResult.cardNumber,
-            "expiryDate": cardScanResult.expiryDate,
-            "owner": cardScanResult.owner,
-            "cvv": cardScanResult.cvv
-        ]
+        finalizeBlinkCard(payload: payload)
     }
 
-    private func mapStatus(_ status: MicroblinkPlatformResultStatus) -> String {
-        switch status {
-        case .accept:
-            return "accept"
-        case .review:
-            return "review"
-        case .reject:
-            return "reject"
-        @unknown default:
-            return "review"
+    private func finalizeBlinkCard(payload: [String: Any]) {
+        DispatchQueue.main.async {
+            let pendingCallId = self.pendingBlinkCardCallId
+            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 mapCancelReason(_ reason: MicroblinkPlatformCancelReason) -> String {
-        switch reason {
-        case .userCanceled:
-            return "userCanceled"
-        case .consentDenied:
-            return "consentDenied"
-        @unknown default:
-            return "userCanceled"
-        }
+    private func clearPendingBlinkCardState() {
+        pendingBlinkCardCallId = nil
+        blinkCardHostingController = nil
+        blinkCardResultObserver = nil
     }
 
-    private func finalize(viewController: UIViewController, payload: [String: Any]) {
-        viewController.dismiss(animated: true)
-        guard let pendingCallId, let call = bridge?.savedCall(withID: pendingCallId) else {
-            clearPendingState()
-            return
+    private func normalized(_ value: String?) -> String? {
+        guard let value, !value.isEmpty else {
+            return nil
         }
-        clearPendingState()
-        call.resolve(payload)
-        bridge?.releaseCall(withID: pendingCallId)
+        return value
     }
 
-    private func clearPendingState() {
-        pendingCallId = nil
-        pendingCardScanResult = nil
-        sdk = nil
+    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": 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.0.1",
+  "version": "0.3.0",
   "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",