capacitor-microblink 0.2.0 → 0.3.1

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

@@ -1,376 +1,293 @@
 package com.otto.microblink;
 
+import android.Manifest;
 import android.content.Intent;
-
+import android.util.Log;
 import androidx.activity.result.ActivityResult;
 
 import com.getcapacitor.JSObject;
+import com.getcapacitor.PermissionState;
 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.blinkcard.MicroblinkSDK;
-import com.microblink.blinkcard.activity.result.ResultStatus;
-import com.microblink.blinkcard.activity.result.ScanResult;
-import com.microblink.blinkcard.activity.result.contract.MbScan;
-import com.microblink.blinkcard.entities.recognizers.Recognizer;
-import com.microblink.blinkcard.entities.recognizers.RecognizerBundle;
-import com.microblink.blinkcard.entities.recognizers.blinkcard.BlinkCardProcessingStatus;
-import com.microblink.blinkcard.entities.recognizers.blinkcard.BlinkCardRecognizer;
-import com.microblink.blinkcard.results.date.SimpleDate;
-import com.microblink.blinkcard.uisettings.BlinkCardUISettings;
-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;
-
-@CapacitorPlugin(name = "Microblink")
+import com.getcapacitor.annotation.Permission;
+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",
+    permissions = {
+        @Permission(alias = "camera", strings = { Manifest.permission.CAMERA })
+    }
+)
 public class MicroblinkPlugin extends Plugin {
+    private static final String TAG = "MicroblinkPlugin";
 
-    private PluginCall pendingVerificationCall;
-    private JSObject pendingVerificationCardScanResult;
+    private boolean isBlinkCardInitialized;
+    private String blinkCardLicenseKey;
+    private String blinkCardLicensee;
 
-    @PluginMethod
-    public void startVerification(PluginCall call) {
-        if (pendingVerificationCall != null) {
-            call.reject("A verification flow is already running.");
+    @Override
+    public void load() {
+        super.load();
+
+        String configuredLicenseKey = normalized(getConfig().getString("licenseKey"));
+        if (configuredLicenseKey == null) {
             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());
+        String configuredLicensee = normalized(getConfig().getString("licensee"));
+        initializeBlinkCardLicense(configuredLicenseKey, configuredLicensee, errorMessage -> {
+            if (errorMessage != null) {
+                Log.w(TAG, "Auto initializeBlinkCard on load failed: " + errorMessage);
+            } else {
+                Log.i(TAG, "BlinkCard auto-initialized from plugin config.");
+            }
+        });
+    }
 
-        if (workflowId == null || workflowId.isEmpty()) {
-            call.reject("Missing required field: workflowId.");
-            return;
-        }
-        if (url == null || url.isEmpty()) {
-            call.reject("Missing required field: url.");
-            return;
-        }
-        if (userId == null || userId.isEmpty()) {
-            call.reject("Missing required field: userId.");
+    @PluginMethod
+    public void scanCard(PluginCall call) {
+        if (getPermissionState("camera") != PermissionState.GRANTED) {
+            requestPermissionForAlias("camera", call, "cameraPermissionCallback");
             return;
         }
-        if (isProcessingStoringAllowed == null) {
-            call.reject("Missing required field: isProcessingStoringAllowed.");
+
+        performScanCard(call);
+    }
+
+    @com.getcapacitor.annotation.PermissionCallback
+    private void cameraPermissionCallback(PluginCall call) {
+        if (call == null) {
             return;
         }
-        if (isTrainingAllowed == null) {
-            call.reject("Missing required field: isTrainingAllowed.");
+
+        if (getPermissionState("camera") != PermissionState.GRANTED) {
+            call.reject("Camera permission is required to scan cards.");
             return;
         }
 
-        MicroblinkPlatformConsent consent = new MicroblinkPlatformConsent(
-            userId,
-            isProcessingStoringAllowed,
-            isTrainingAllowed,
-            note,
-            givenOn
-        );
+        performScanCard(call);
+    }
+
+    private void performScanCard(PluginCall call) {
+        String providedLicenseKey = normalized(call.getString("licenseKey"));
+        String providedLicensee = normalized(call.getString("licensee"));
 
-        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.
+        if (providedLicenseKey != null) {
+            initializeBlinkCardLicense(providedLicenseKey, providedLicensee, errorMessage -> {
+                if (errorMessage != null) {
+                    call.reject(errorMessage);
+                    return;
                 }
-            }
+                startBlinkCardScan(call, providedLicenseKey, providedLicensee);
+            });
+            return;
         }
 
-        String startTransactionPath = call.getString("startTransactionPath", "");
-        String cancelWorkflowPath = call.getString("cancelWorkflowPath", "");
-        String workflowInfoPath = call.getString("workflowInfoPath", "");
+        if (!isBlinkCardInitialized || blinkCardLicenseKey == null) {
+            call.reject("BlinkCard is not initialized. Call initializeBlinkCard first or provide licenseKey in scanCard.");
+            return;
+        }
 
-        MicroblinkPlatformProxySettings proxySettings = new MicroblinkPlatformProxySettings(
-            url,
-            startTransactionPath,
-            cancelWorkflowPath,
-            workflowInfoPath,
-            additionalHeaders
-        );
-        MicroblinkPlatformServiceSettings serviceSettings = new MicroblinkPlatformServiceSettings(
-            workflowId,
-            proxySettings,
-            consent
-        );
-        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 (pendingVerificationCardScanResult != null) {
-                    payload.put("cardScanResult", pendingVerificationCardScanResult);
-                }
-                resolvePending(payload);
+        initializeBlinkCardLicense(blinkCardLicenseKey, blinkCardLicensee, errorMessage -> {
+            if (errorMessage != null) {
+                call.reject(errorMessage);
+                return;
             }
+            startBlinkCardScan(call, blinkCardLicenseKey, blinkCardLicensee);
+        });
+    }
 
-            @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 (pendingVerificationCardScanResult != null) {
-                    payload.put("cardScanResult", pendingVerificationCardScanResult);
-                }
-                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());
-                pendingVerificationCardScanResult = cardScan;
+    @PluginMethod
+    public void initializeBlinkCard(PluginCall call) {
+        String licenseKey = normalized(call.getString("licenseKey"));
+        if (licenseKey == null) {
+            call.reject("Missing required field: licenseKey.");
+            return;
+        }
+
+        String licensee = normalized(call.getString("licensee"));
+        initializeBlinkCardLicense(licenseKey, licensee, errorMessage -> {
+            if (errorMessage != null) {
+                call.reject(errorMessage);
+                return;
             }
-        };
 
-        MicroblinkPlatformConfig config = new MicroblinkPlatformConfig(
-            resultListener,
-            serviceSettings,
-            uiSettings,
-            cardScanResultListener
-        );
+            JSObject payload = new JSObject();
+            payload.put("initialized", true);
+            call.resolve(payload);
+        });
+    }
 
-        pendingVerificationCall = call;
-        pendingVerificationCardScanResult = null;
+    @PluginMethod
+    public void terminateBlinkCard(PluginCall call) {
+        BlinkCardInitBridge.terminate(error -> {
+            if (error != null) {
+                call.reject("Failed to terminate BlinkCard SDK: " + error.getMessage());
+                return null;
+            }
 
-        if (getActivity() == null) {
-            clearPendingState();
-            call.reject("Unable to start verification: Activity is unavailable.");
-            return;
-        }
+            isBlinkCardInitialized = false;
+            blinkCardLicenseKey = null;
+            blinkCardLicensee = null;
 
-        getActivity().runOnUiThread(() -> MicroblinkPlatform.INSTANCE.startVerification(getActivity(), config));
+            JSObject payload = new JSObject();
+            payload.put("terminated", true);
+            call.resolve(payload);
+            return null;
+        });
     }
 
-    @PluginMethod
-    public void scanCard(PluginCall call) {
-        if (pendingVerificationCall != null) {
-            call.reject("A verification flow is already running.");
+    private void startBlinkCardScan(PluginCall call, String licenseKey, String licensee) {
+        if (getContext() == null) {
+            call.reject("Unable to start BlinkCard scan: Context is unavailable.");
             return;
         }
 
-        String licenseKey = call.getString("licenseKey");
-        if (licenseKey == null || licenseKey.isEmpty()) {
-            call.reject("Missing required field: licenseKey.");
-            return;
-        }
-        String licensee = call.getString("licensee");
+        ExtractionSettings extractionSettings = new ExtractionSettings(
+            call.getBoolean("extractIban", true),
+            call.getBoolean("extractExpiryDate", true),
+            call.getBoolean("extractOwner", true),
+            call.getBoolean("extractCvv", true),
+            call.getBoolean("allowInvalidCardNumber", false)
+        );
 
-        try {
-            if (licensee != null && !licensee.isEmpty()) {
-                MicroblinkSDK.setLicenseKey(licenseKey, licensee, getContext());
-            } else {
-                MicroblinkSDK.setLicenseKey(licenseKey, getContext());
-            }
-        } catch (RuntimeException ex) {
-            call.reject("Failed to initialize BlinkCard license: " + ex.getMessage());
-            return;
-        }
+        ScanningSettings baseScanningSettings = new ScanningSettings();
+        ScanningSettings scanningSettings = baseScanningSettings.copy(
+            baseScanningSettings.getSkipImagesWithBlur(),
+            baseScanningSettings.getTiltDetectionLevel(),
+            baseScanningSettings.getInputImageMargin(),
+            extractionSettings,
+            baseScanningSettings.getCroppedImageSettings(),
+            baseScanningSettings.getLivenessSettings(),
+            baseScanningSettings.getAnonymizationSettings()
+        );
 
-        BlinkCardRecognizer recognizer = new BlinkCardRecognizer();
-        recognizer.setExtractOwner(call.getBoolean("extractOwner", true));
-        recognizer.setExtractExpiryDate(call.getBoolean("extractExpiryDate", true));
-        recognizer.setExtractCvv(call.getBoolean("extractCvv", true));
-        recognizer.setExtractIban(call.getBoolean("extractIban", true));
-        recognizer.setAllowInvalidCardNumber(call.getBoolean("allowInvalidCardNumber", false));
+        BlinkCardSessionSettings baseSessionSettings = new BlinkCardSessionSettings();
+        BlinkCardSessionSettings sessionSettings = baseSessionSettings.copy(
+            baseSessionSettings.getInputImageSource(),
+            scanningSettings
+        );
 
-        RecognizerBundle recognizerBundle = new RecognizerBundle(recognizer);
-        BlinkCardUISettings uiSettings = new BlinkCardUISettings(recognizerBundle);
-        uiSettings.setEditScreenEnabled(call.getBoolean("enableEditScreen", true));
+        BlinkCardSdkSettings sdkSettings = licensee == null
+            ? new BlinkCardSdkSettings(licenseKey)
+            : new BlinkCardSdkSettings(licenseKey, licensee);
 
-        MbScan scanContract = new MbScan();
-        Intent scanIntent = scanContract.createIntent(getContext(), uiSettings);
+        BlinkCardScanActivitySettings activitySettings = new BlinkCardScanActivitySettings(sdkSettings, sessionSettings);
+        MbBlinkCardScan scanContract = new MbBlinkCardScan();
+        Intent scanIntent = scanContract.createIntent(getContext(), activitySettings);
         startActivityForResult(call, scanIntent, "handleBlinkCardScanResult");
     }
 
     @ActivityCallback
     private void handleBlinkCardScanResult(PluginCall call, ActivityResult activityResult) {
-        MbScan scanContract = new MbScan();
-        ScanResult scanResult = scanContract.parseResult(activityResult.getResultCode(), activityResult.getData());
-
-        if (scanResult.getResultStatus() == ResultStatus.CANCELLED) {
-            JSObject payload = new JSObject();
-            payload.put("canceled", true);
-            call.resolve(payload);
-            return;
-        }
+        MbBlinkCardScan scanContract = new MbBlinkCardScan();
+        BlinkCardScanActivityResult scanResult = scanContract.parseResult(
+            activityResult.getResultCode(),
+            activityResult.getData()
+        );
 
-        if (scanResult.getResultStatus() == ResultStatus.EXCEPTION) {
-            Throwable exception = scanResult.getException();
-            String message = exception != null ? exception.getMessage() : "BlinkCard scan failed with unknown exception.";
-            call.reject(message);
+        if (scanResult == null) {
+            call.reject("BlinkCard scan did not return any result data.");
             return;
         }
 
-        Intent resultIntent = scanResult.getResult();
-        if (resultIntent == null) {
-            call.reject("BlinkCard scan did not return any result data.");
+        ScanActivityResultStatus status = scanResult.getStatus();
+        if (status == ScanActivityResultStatus.Canceled) {
+            JSObject payload = new JSObject();
+            payload.put("canceled", true);
+            call.resolve(payload);
             return;
         }
 
-        RecognizerBundle resultBundle = RecognizerBundle.createFromIntent(resultIntent);
-        if (resultBundle == null || resultBundle.getRecognizers() == null || resultBundle.getRecognizers().length == 0) {
-            call.reject("BlinkCard result bundle is empty.");
+        if (status == ScanActivityResultStatus.ErrorSdkInit) {
+            isBlinkCardInitialized = false;
+            call.reject("BlinkCard scan failed because SDK initialization in scan activity failed.");
             return;
         }
 
-        BlinkCardRecognizer blinkCardRecognizer = null;
-        for (Recognizer<?> recognizer : resultBundle.getRecognizers()) {
-            if (recognizer instanceof BlinkCardRecognizer) {
-                blinkCardRecognizer = (BlinkCardRecognizer) recognizer;
-                break;
-            }
-        }
-        if (blinkCardRecognizer == null) {
-            call.reject("BlinkCard recognizer result was not found.");
+        BlinkCardScanningResult result = scanResult.getResult();
+        if (result == null) {
+            call.reject("BlinkCard scan finished without scan result.");
             return;
         }
 
-        BlinkCardRecognizer.Result result = blinkCardRecognizer.getResult();
         JSObject payload = new JSObject();
         payload.put("canceled", false);
-        payload.put("resultState", toBlinkCardResultState(result.getResultState()));
-        payload.put("processingStatus", toBlinkCardProcessingStatus(result.getProcessingStatus()));
-        payload.put("cardNumber", result.getCardNumber());
-        payload.put("cardNumberValid", result.isCardNumberValid());
-        payload.put("cardNumberPrefix", result.getCardNumberPrefix());
-        payload.put("owner", result.getOwner());
-        payload.put("cvv", result.getCvv());
+        payload.put("resultState", "valid");
+        payload.put("processingStatus", "success");
+        payload.put("owner", result.getCardholderName());
         payload.put("iban", result.getIban());
-        payload.put("expiryDate", toBlinkCardDate(result.getExpiryDate() != null ? result.getExpiryDate().getDate() : null));
+
+        List<CardAccountResult> cardAccounts = result.getCardAccounts();
+        if (cardAccounts != null && !cardAccounts.isEmpty()) {
+            CardAccountResult 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()));
+        }
+
         call.resolve(payload);
     }
 
-    private JSObject toBlinkCardDate(SimpleDate simpleDate) {
-        if (simpleDate == null) {
+    private JSObject toBlinkCardDate(DateResult<String> dateResult) {
+        if (dateResult == null || dateResult.getDay() == null || dateResult.getMonth() == null || dateResult.getYear() == null) {
             return null;
         }
+
         JSObject date = new JSObject();
-        date.put("day", simpleDate.getDay());
-        date.put("month", simpleDate.getMonth());
-        date.put("year", simpleDate.getYear());
+        date.put("day", dateResult.getDay());
+        date.put("month", dateResult.getMonth());
+        date.put("year", dateResult.getYear());
         return date;
     }
 
-    private String toBlinkCardResultState(Recognizer.Result.State state) {
-        if (state == Recognizer.Result.State.Valid) {
-            return "valid";
-        }
-        if (state == Recognizer.Result.State.Uncertain) {
-            return "uncertain";
-        }
-        if (state == Recognizer.Result.State.StageValid) {
-            return "stageValid";
-        }
-        return "empty";
-    }
-
-    private String toBlinkCardProcessingStatus(BlinkCardProcessingStatus status) {
-        if (status == BlinkCardProcessingStatus.Success) {
-            return "success";
-        }
-        if (status == BlinkCardProcessingStatus.DetectionFailed) {
-            return "detectionFailed";
-        }
-        if (status == BlinkCardProcessingStatus.ImagePreprocessingFailed) {
-            return "imagePreprocessingFailed";
-        }
-        if (status == BlinkCardProcessingStatus.StabilityTestFailed) {
-            return "stabilityTestFailed";
-        }
-        if (status == BlinkCardProcessingStatus.ScanningWrongSide) {
-            return "scanningWrongSide";
-        }
-        if (status == BlinkCardProcessingStatus.FieldIdentificationFailed) {
-            return "fieldIdentificationFailed";
-        }
-        if (status == BlinkCardProcessingStatus.ImageReturnFailed) {
-            return "imageReturnFailed";
+    private void initializeBlinkCardLicense(String licenseKey, String licensee, Consumer<String> callback) {
+        if (getContext() == null) {
+            callback.accept("Unable to initialize BlinkCard SDK: Context is unavailable.");
+            return;
         }
-        return "unsupportedCard";
-    }
 
-    private String toResultStatus(MicroblinkPlatformResult.FinishedState state) {
-        if (state == MicroblinkPlatformResult.FinishedState.Accept) {
-            return "accept";
-        }
-        if (state == MicroblinkPlatformResult.FinishedState.Reject) {
-            return "reject";
-        }
-        return "review";
-    }
+        BlinkCardInitBridge.initialize(getContext(), licenseKey, licensee, error -> {
+            if (error != null) {
+                isBlinkCardInitialized = false;
+                callback.accept("Init failed: " + error.getMessage());
+                return null;
+            }
 
-    private String toCancelReason(MicroblinkPlatformCancelState.CancelReason reason) {
-        if (reason == MicroblinkPlatformCancelState.CancelReason.ConsentDenied) {
-            return "consentDenied";
-        }
-        return "userCanceled";
+            isBlinkCardInitialized = true;
+            blinkCardLicenseKey = licenseKey;
+            blinkCardLicensee = licensee;
+            callback.accept(null);
+            return null;
+        });
     }
 
-    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 String normalized(String value) {
+        if (value == null) {
+            return null;
         }
-        String monthPart = month == null ? "00" : String.format("%02d", month);
-        String yearPart = year == null ? "0000" : String.valueOf(year);
-        return monthPart + "/" + yearPart;
-    }
-
-    private synchronized void resolvePending(JSObject payload) {
-        if (pendingVerificationCall == null) {
-            clearPendingState();
-            return;
+        String trimmed = value.trim();
+        if (trimmed.isEmpty()) {
+            return null;
         }
-        PluginCall call = pendingVerificationCall;
-        clearPendingState();
-        call.resolve(payload);
-    }
-
-    private synchronized void clearPendingState() {
-        pendingVerificationCall = null;
-        pendingVerificationCardScanResult = null;
+        return trimmed;
     }
 }