capacitor-microblink 0.0.1 → 0.3.0

package/android/src/main/java/com/otto/microblink/MicroblinkPlugin.java

@@ -1,213 +1,224 @@
 package com.otto.microblink;
 
+import android.content.Intent;
+import android.os.Build;
+
+import androidx.activity.result.ActivityResult;
+
 import com.getcapacitor.JSObject;
 import com.getcapacitor.Plugin;
 import com.getcapacitor.PluginCall;
 import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.ActivityCallback;
 import com.getcapacitor.annotation.CapacitorPlugin;
-import com.microblink.platform.CardScanResult;
-import com.microblink.platform.MicroblinkPlatform;
-import com.microblink.platform.MicroblinkPlatformCancelState;
-import com.microblink.platform.MicroblinkPlatformCardScanResultListener;
-import com.microblink.platform.MicroblinkPlatformConfig;
-import com.microblink.platform.MicroblinkPlatformConsent;
-import com.microblink.platform.MicroblinkPlatformProxySettings;
-import com.microblink.platform.MicroblinkPlatformResult;
-import com.microblink.platform.MicroblinkPlatformResultListener;
-import com.microblink.platform.MicroblinkPlatformServiceSettings;
-import com.microblink.platform.MicroblinkPlatformUiSettings;
-
-import org.json.JSONException;
-
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
+import com.microblink.blinkcard.core.BlinkCardSdkSettings;
+import com.microblink.blinkcard.core.result.CardAccountResult;
+import com.microblink.blinkcard.core.result.DateResult;
+import com.microblink.blinkcard.core.session.BlinkCardScanningResult;
+import com.microblink.blinkcard.core.session.BlinkCardSessionSettings;
+import com.microblink.blinkcard.core.settings.ExtractionSettings;
+import com.microblink.blinkcard.core.settings.ScanningSettings;
+import com.microblink.blinkcard.ux.contract.BlinkCardScanActivityResult;
+import com.microblink.blinkcard.ux.contract.BlinkCardScanActivitySettings;
+import com.microblink.blinkcard.ux.contract.MbBlinkCardScan;
+import com.microblink.blinkcard.ux.contract.ScanActivityResultStatus;
+
+import java.util.List;
+import java.util.function.Consumer;
 
 @CapacitorPlugin(name = "Microblink")
 public class MicroblinkPlugin extends Plugin {
 
-    private PluginCall pendingCall;
-    private JSObject pendingCardScanResult;
+    private boolean isBlinkCardInitialized;
+    private String blinkCardLicenseKey;
+    private String blinkCardLicensee;
 
     @PluginMethod
-    public void startVerification(PluginCall call) {
-        if (pendingCall != null) {
-            call.reject("A verification flow is already running.");
+    public void scanCard(PluginCall call) {
+        String providedLicenseKey = normalized(call.getString("licenseKey"));
+        String providedLicensee = normalized(call.getString("licensee"));
+
+        if (providedLicenseKey != null) {
+            initializeBlinkCardLicense(providedLicenseKey, providedLicensee, errorMessage -> {
+                if (errorMessage != null) {
+                    call.reject(errorMessage);
+                    return;
+                }
+                startBlinkCardScan(call, providedLicenseKey, providedLicensee);
+            });
             return;
         }
 
-        String workflowId = call.getString("workflowId");
-        String url = call.getString("url");
-        String userId = call.getString("userId");
-        Boolean isProcessingStoringAllowed = call.getBoolean("isProcessingStoringAllowed");
-        Boolean isTrainingAllowed = call.getBoolean("isTrainingAllowed");
-        String note = call.getString("note", "");
-        Long givenOn = call.getLong("givenOn", System.currentTimeMillis());
-
-        if (workflowId == null || workflowId.isEmpty()) {
-            call.reject("Missing required field: workflowId.");
+        if (!isBlinkCardInitialized || blinkCardLicenseKey == null) {
+            call.reject("BlinkCard is not initialized. Call initializeBlinkCard first or provide licenseKey in scanCard.");
             return;
         }
-        if (url == null || url.isEmpty()) {
-            call.reject("Missing required field: url.");
-            return;
-        }
-        if (userId == null || userId.isEmpty()) {
-            call.reject("Missing required field: userId.");
-            return;
-        }
-        if (isProcessingStoringAllowed == null) {
-            call.reject("Missing required field: isProcessingStoringAllowed.");
-            return;
-        }
-        if (isTrainingAllowed == null) {
-            call.reject("Missing required field: isTrainingAllowed.");
+
+        startBlinkCardScan(call, blinkCardLicenseKey, blinkCardLicensee);
+    }
+
+    @PluginMethod
+    public void initializeBlinkCard(PluginCall call) {
+        String licenseKey = normalized(call.getString("licenseKey"));
+        if (licenseKey == null) {
+            call.reject("Missing required field: licenseKey.");
             return;
         }
 
-        MicroblinkPlatformConsent consent = new MicroblinkPlatformConsent(
-            userId,
-            isProcessingStoringAllowed,
-            isTrainingAllowed,
-            note,
-            givenOn
-        );
-
-        Map<String, String> additionalHeaders = new HashMap<>();
-        JSObject headersObject = call.getObject("additionalRequestHeaders");
-        if (headersObject != null) {
-            Iterator<String> keys = headersObject.keys();
-            while (keys.hasNext()) {
-                String key = keys.next();
-                try {
-                    Object rawValue = headersObject.get(key);
-                    if (rawValue != null) {
-                        additionalHeaders.put(key, String.valueOf(rawValue));
-                    }
-                } catch (JSONException ignored) {
-                    // Ignore malformed header value.
-                }
+        String licensee = normalized(call.getString("licensee"));
+        initializeBlinkCardLicense(licenseKey, licensee, errorMessage -> {
+            if (errorMessage != null) {
+                call.reject(errorMessage);
+                return;
             }
+
+            JSObject payload = new JSObject();
+            payload.put("initialized", true);
+            call.resolve(payload);
+        });
+    }
+
+    private void startBlinkCardScan(PluginCall call, String licenseKey, String licensee) {
+        if (getContext() == null) {
+            call.reject("Unable to start BlinkCard scan: Context is unavailable.");
+            return;
         }
 
-        String startTransactionPath = call.getString("startTransactionPath", "");
-        String cancelWorkflowPath = call.getString("cancelWorkflowPath", "");
-        String workflowInfoPath = call.getString("workflowInfoPath", "");
+        ExtractionSettings extractionSettings = new ExtractionSettings(
+            call.getBoolean("extractIban", true),
+            call.getBoolean("extractExpiryDate", true),
+            call.getBoolean("extractOwner", true),
+            call.getBoolean("extractCvv", true),
+            call.getBoolean("allowInvalidCardNumber", false)
+        );
 
-        MicroblinkPlatformProxySettings proxySettings = new MicroblinkPlatformProxySettings(
-            url,
-            startTransactionPath,
-            cancelWorkflowPath,
-            workflowInfoPath,
-            additionalHeaders
+        ScanningSettings baseScanningSettings = new ScanningSettings();
+        ScanningSettings scanningSettings = baseScanningSettings.copy(
+            baseScanningSettings.getSkipImagesWithBlur(),
+            baseScanningSettings.getTiltDetectionLevel(),
+            baseScanningSettings.getInputImageMargin(),
+            extractionSettings,
+            baseScanningSettings.getCroppedImageSettings(),
+            baseScanningSettings.getLivenessSettings(),
+            baseScanningSettings.getAnonymizationSettings()
         );
-        MicroblinkPlatformServiceSettings serviceSettings = new MicroblinkPlatformServiceSettings(
-            workflowId,
-            proxySettings,
-            consent
+
+        BlinkCardSessionSettings baseSessionSettings = new BlinkCardSessionSettings();
+        BlinkCardSessionSettings sessionSettings = baseSessionSettings.copy(
+            baseSessionSettings.getInputImageSource(),
+            scanningSettings
         );
-        MicroblinkPlatformUiSettings uiSettings = new MicroblinkPlatformUiSettings();
-
-        MicroblinkPlatformResultListener resultListener = new MicroblinkPlatformResultListener() {
-            @Override
-            public void onVerificationFinished(MicroblinkPlatformResult result) {
-                JSObject payload = new JSObject();
-                payload.put("canceled", false);
-                payload.put("transactionId", result.getTransactionId());
-                payload.put("status", toResultStatus(result.getState()));
-                if (pendingCardScanResult != null) {
-                    payload.put("cardScanResult", pendingCardScanResult);
-                }
-                resolvePending(payload);
-            }
 
-            @Override
-            public void onVerificationCanceled(MicroblinkPlatformCancelState cancelState) {
-                JSObject payload = new JSObject();
-                payload.put("canceled", true);
-                payload.put("transactionId", cancelState.getTransactionId());
-                payload.put("cancelReason", toCancelReason(cancelState.getCancelReason()));
-                if (pendingCardScanResult != null) {
-                    payload.put("cardScanResult", pendingCardScanResult);
-                }
-                resolvePending(payload);
-            }
-        };
-
-        MicroblinkPlatformCardScanResultListener cardScanResultListener = new MicroblinkPlatformCardScanResultListener() {
-            @Override
-            public void onCardScanned(CardScanResult cardResult) {
-                JSObject cardScan = new JSObject();
-                cardScan.put("cardNumber", cardResult.getCardNumber());
-                cardScan.put("expiryDate", formatExpiry(cardResult));
-                cardScan.put("owner", cardResult.getOwner());
-                cardScan.put("cvv", cardResult.getCvv());
-                pendingCardScanResult = cardScan;
-            }
-        };
+        BlinkCardSdkSettings sdkSettings = licensee == null
+            ? new BlinkCardSdkSettings(licenseKey)
+            : new BlinkCardSdkSettings(licenseKey, licensee);
 
-        MicroblinkPlatformConfig config = new MicroblinkPlatformConfig(
-            resultListener,
-            serviceSettings,
-            uiSettings,
-            cardScanResultListener
-        );
+        BlinkCardScanActivitySettings activitySettings = new BlinkCardScanActivitySettings(sdkSettings, sessionSettings);
+        MbBlinkCardScan scanContract = new MbBlinkCardScan();
+        Intent scanIntent = scanContract.createIntent(getContext(), activitySettings);
+        startActivityForResult(call, scanIntent, "handleBlinkCardScanResult");
+    }
 
-        pendingCall = call;
-        pendingCardScanResult = null;
+    @ActivityCallback
+    private void handleBlinkCardScanResult(PluginCall call, ActivityResult activityResult) {
+        MbBlinkCardScan scanContract = new MbBlinkCardScan();
+        BlinkCardScanActivityResult scanResult = scanContract.parseResult(
+            activityResult.getResultCode(),
+            activityResult.getData()
+        );
 
-        if (getActivity() == null) {
-            clearPendingState();
-            call.reject("Unable to start verification: Activity is unavailable.");
+        if (scanResult == null) {
+            call.reject("BlinkCard scan did not return any result data.");
             return;
         }
 
-        getActivity().runOnUiThread(() -> MicroblinkPlatform.INSTANCE.startVerification(getActivity(), config));
-    }
+        ScanActivityResultStatus status = scanResult.getStatus();
+        if (status == ScanActivityResultStatus.Canceled) {
+            JSObject payload = new JSObject();
+            payload.put("canceled", true);
+            call.resolve(payload);
+            return;
+        }
 
-    private String toResultStatus(MicroblinkPlatformResult.FinishedState state) {
-        if (state == MicroblinkPlatformResult.FinishedState.Accept) {
-            return "accept";
+        if (status == ScanActivityResultStatus.ErrorSdkInit) {
+            call.reject("BlinkCard scan failed because SDK initialization in scan activity failed.");
+            return;
         }
-        if (state == MicroblinkPlatformResult.FinishedState.Reject) {
-            return "reject";
+
+        BlinkCardScanningResult result = scanResult.getResult();
+        if (result == null) {
+            call.reject("BlinkCard scan finished without scan result.");
+            return;
         }
-        return "review";
-    }
 
-    private String toCancelReason(MicroblinkPlatformCancelState.CancelReason reason) {
-        if (reason == MicroblinkPlatformCancelState.CancelReason.ConsentDenied) {
-            return "consentDenied";
+        JSObject payload = new JSObject();
+        payload.put("canceled", false);
+        payload.put("resultState", "valid");
+        payload.put("processingStatus", "success");
+        payload.put("owner", result.getCardholderName());
+        payload.put("iban", result.getIban());
+
+        List<CardAccountResult> cardAccounts = result.getCardAccounts();
+        if (cardAccounts != null && !cardAccounts.isEmpty()) {
+            CardAccountResult primaryAccount = null;
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+                primaryAccount = cardAccounts.getFirst();
+                payload.put("cardNumber", primaryAccount.getCardNumber());
+                payload.put("cardNumberValid", primaryAccount.getCardNumberValid());
+                payload.put("cardNumberPrefix", primaryAccount.getCardNumberPrefix());
+                payload.put("cvv", primaryAccount.getCvv());
+                payload.put("expiryDate", toBlinkCardDate(primaryAccount.getExpiryDate()));
+            } else {
+                primaryAccount = cardAccounts.get(0);
+                payload.put("cardNumber", primaryAccount.getCardNumber());
+                payload.put("cardNumberValid", primaryAccount.getCardNumberValid());
+                payload.put("cardNumberPrefix", primaryAccount.getCardNumberPrefix());
+                payload.put("cvv", primaryAccount.getCvv());
+                payload.put("expiryDate", toBlinkCardDate(primaryAccount.getExpiryDate()));
+            }
+
         }
-        return "userCanceled";
+
+        call.resolve(payload);
     }
 
-    private String formatExpiry(CardScanResult cardResult) {
-        if (cardResult.getExpiryDate() == null) {
-            return "";
-        }
-        Integer month = cardResult.getExpiryDate().getMonth();
-        Integer year = cardResult.getExpiryDate().getYear();
-        if (month == null && year == null) {
-            return "";
+    private JSObject toBlinkCardDate(DateResult<String> dateResult) {
+        if (dateResult == null || dateResult.getDay() == null || dateResult.getMonth() == null || dateResult.getYear() == null) {
+            return null;
         }
-        String monthPart = month == null ? "00" : String.format("%02d", month);
-        String yearPart = year == null ? "0000" : String.valueOf(year);
-        return monthPart + "/" + yearPart;
+
+        JSObject date = new JSObject();
+        date.put("day", dateResult.getDay());
+        date.put("month", dateResult.getMonth());
+        date.put("year", dateResult.getYear());
+        return date;
     }
 
-    private synchronized void resolvePending(JSObject payload) {
-        if (pendingCall == null) {
-            clearPendingState();
+    private void initializeBlinkCardLicense(String licenseKey, String licensee, Consumer<String> callback) {
+        if (getContext() == null) {
+            callback.accept("Unable to initialize BlinkCard SDK: Context is unavailable.");
             return;
         }
-        PluginCall call = pendingCall;
-        clearPendingState();
-        call.resolve(payload);
+
+        BlinkCardInitBridge.initialize(getContext(), licenseKey, licensee, error -> {
+            if (error != null) {
+                isBlinkCardInitialized = false;
+                callback.accept("Init failed: " + error.getMessage());
+                return null;
+            }
+
+            isBlinkCardInitialized = true;
+            blinkCardLicenseKey = licenseKey;
+            blinkCardLicensee = licensee;
+            callback.accept(null);
+            return null;
+        });
     }
 
-    private synchronized void clearPendingState() {
-        pendingCall = null;
-        pendingCardScanResult = null;
+    private String normalized(String value) {
+        if (value == null || value.isEmpty()) {
+            return null;
+        }
+        return value;
     }
 }