@regulaforensics/react-native-document-reader-api 6.6.0 → 6.7.1

package/RNDocumentReaderApi.podspec

@@ -14,6 +14,6 @@ Pod::Spec.new do |s|
   s.source       = { :http => 'file:' + __dir__ }
   s.ios.deployment_target = '11.0'
   s.source_files  = "ios/*.{h,m}"
-  s.dependency 'DocumentReader', '6.6.2753'
+  s.dependency 'DocumentReader', '6.7.2848'
   s.dependency 'React'
 end

package/android/build.gradle

@@ -24,7 +24,7 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+'
     //noinspection GradleDependency
-    implementation('com.regula.documentreader:api:6.6.8072') {
+    implementation('com.regula.documentreader:api:6.7.8311') {
         transitive = true
     }
 }

package/android/src/main/java/com/regula/documentreader/Helpers.java

@@ -63,6 +63,8 @@ class Helpers {
     }
 
     static String bitmapToBase64String(Bitmap bitmap) {
+        if(bitmap == null) return null;
+
         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
         bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream);
         byte[] byteArray = byteArrayOutputStream.toByteArray();

package/android/src/main/java/com/regula/documentreader/JSONConstructor.java

@@ -149,6 +149,14 @@ class JSONConstructor {
         return result;
     }
 
+    static int[] intArrayFromJSON(JSONArray input) throws JSONException {
+        int[] result = new int[input.length()];
+        for (int i = 0; i < input.length(); i++)
+            result[i] = input.getInt(i);
+
+        return result;
+    }
+
     static JSONArray generateByteArray(byte[] array) throws JSONException {
         JSONArray result = new JSONArray();
         if (array == null) return result;
@@ -186,18 +194,18 @@ class JSONConstructor {
         try {
             result.put("action", action);
             switch (action) {
-                case DocReaderAction.PROCESS:
-                case DocReaderAction.PROCESS_WHITE_UV_IMAGES:
-                    break;
-                case DocReaderAction.NOTIFICATION:
-                    result.put("results", generateDocumentReaderResultsNotification(results));
-                    break;
                 case DocReaderAction.COMPLETE:
                 case DocReaderAction.MORE_PAGES_AVAILABLE:
                 case DocReaderAction.CANCEL:
                 case DocReaderAction.ERROR:
+                case DocReaderAction.TIMEOUT:
                     result.put("results", generateDocumentReaderResults(results, context));
                     break;
+                case DocReaderAction.NOTIFICATION:
+                    result.put("results", generateDocumentReaderResultsNotification(results));
+                    break;
+                default:
+                    break;
             }
             if (error != null)
                 result.put("error", generateDocumentReaderException(error));
@@ -470,6 +478,8 @@ class JSONConstructor {
             result.put("values", generateList(input.values, JSONConstructor::generateDocumentReaderValue, context));
             result.put("comparisonList", generateList(input.comparisonList, JSONConstructor::generateDocumentReaderComparison));
             result.put("validityList", generateList(input.validityList, JSONConstructor::generateDocumentReaderValidity));
+            result.put("comparisonStatus", input.comparisonStatus);
+            result.put("validityStatus", input.validityStatus);
         } catch (JSONException e) {
             e.printStackTrace();
         }
@@ -581,9 +591,11 @@ class JSONConstructor {
         JSONObject result = new JSONObject();
         if (input == null) return null;
         try {
-            result.put("code", input.getNotificationCode());
-            result.put("attachment", input.getDataFileType());
-            result.put("value", input.getProgress());
+            result.put("code", input.code);
+            result.put("value", input.value);
+            result.put("notificationCode", input.getNotificationCode());
+            result.put("dataFileType", input.getDataFileType());
+            result.put("progress", input.getProgress());
         } catch (JSONException e) {
             e.printStackTrace();
         }
@@ -1150,7 +1162,9 @@ class JSONConstructor {
         JSONObject result = new JSONObject();
         if (input == null) return null;
         try {
+            result.put("videoCaptureSessionId", input.videoCaptureSessionId);
             result.put("chipPage", input.chipPage);
+            result.put("irElapsedTime", input.irElapsedTime);
             result.put("processingFinishedStatus", input.processingFinishedStatus);
             result.put("elapsedTime", input.elapsedTime);
             result.put("elapsedTimeRFID", input.elapsedTimeRFID);
@@ -1168,6 +1182,7 @@ class JSONConstructor {
             result.put("rfidSessionData", generateRFIDSessionData(input.rfidSessionData));
             result.put("authenticityResult", generateDocumentReaderAuthenticityResult(input.authenticityResult, context));
             result.put("barcodeResult", generateDocumentReaderBarcodeResult(input.barcodeResult));
+            result.put("ppmIn", input.ppmIn);
             result.put("documentType", generateList(input.documentType, JSONConstructor::generateDocumentReaderDocumentType));
             result.put("status", generateDocumentReaderResultsStatus(input.status));
             result.put("vdsncData", generateVDSNCData(input.vdsncData));

package/android/src/main/java/com/regula/documentreader/RNRegulaDocumentReaderModule.java

@@ -9,6 +9,7 @@ import android.content.IntentFilter;
 import android.graphics.Bitmap;
 import android.nfc.NfcAdapter;
 import android.nfc.tech.IsoDep;
+import android.os.Build;
 import android.os.Bundle;
 import android.util.Base64;
 
@@ -40,7 +41,9 @@ import com.regula.documentreader.api.internal.params.ImageInputParam;
 import com.regula.documentreader.api.params.rfid.PKDCertificate;
 import com.regula.documentreader.api.params.rfid.authorization.PAResourcesIssuer;
 import com.regula.documentreader.api.params.rfid.authorization.TAChallenge;
+import com.regula.documentreader.api.results.DocumentReaderGraphicField;
 import com.regula.documentreader.api.results.DocumentReaderResults;
+import com.regula.documentreader.api.results.DocumentReaderTextField;
 import com.regula.documentreader.api.internal.parser.DocReaderResultsJsonParser;
 
 import org.json.JSONArray;
@@ -127,7 +130,17 @@ public class RNRegulaDocumentReaderModule extends ReactContextBaseJavaModule imp
     public void onHostDestroy() {
     }
 
+    @SuppressWarnings({"WrapperTypeMayBePrimitive", "unchecked"})
     private <T> T args(int index) throws JSONException {
+        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        // Rewrite it according to react native documentation!!!
+        // the is no int or double in js so all ints are sent as double by default
+        Object value = data.get(index);
+        if (value instanceof Double)
+            if ((Double) value % 1 == 0) {
+                Integer intValue = ((Double) value).intValue();
+                return (T) intValue;
+            }
         //noinspection unchecked
         return (T) data.get(index);
     }
@@ -414,6 +427,57 @@ public class RNRegulaDocumentReaderModule extends ReactContextBaseJavaModule imp
                 case "recognizeImagesWithImageInputs":
                     recognizeImagesWithImageInputs(callback, args(0));
                     break;
+                case "textFieldValueByType":
+                    textFieldValueByType(callback, args(0), args(1));
+                    break;
+                case "textFieldValueByTypeLcid":
+                    textFieldValueByTypeLcid(callback, args(0), args(1), args(2));
+                    break;
+                case "textFieldValueByTypeSource":
+                    textFieldValueByTypeSource(callback, args(0), args(1), args(2));
+                    break;
+                case "textFieldValueByTypeLcidSource":
+                    textFieldValueByTypeLcidSource(callback, args(0), args(1), args(2), args(3));
+                    break;
+                case "textFieldValueByTypeSourceOriginal":
+                    textFieldValueByTypeSourceOriginal(callback, args(0), args(1), args(2), args(3));
+                    break;
+                case "textFieldValueByTypeLcidSourceOriginal":
+                    textFieldValueByTypeLcidSourceOriginal(callback, args(0), args(1), args(2), args(3), args(4));
+                    break;
+                case "textFieldByType":
+                    textFieldByType(callback, args(0), args(1));
+                    break;
+                case "textFieldByTypeLcid":
+                    textFieldByTypeLcid(callback, args(0), args(1), args(2));
+                    break;
+                case "graphicFieldByTypeSource":
+                    graphicFieldByTypeSource(callback, args(0), args(1), args(2));
+                    break;
+                case "graphicFieldByTypeSourcePageIndex":
+                    graphicFieldByTypeSourcePageIndex(callback, args(0), args(1), args(2), args(3));
+                    break;
+                case "graphicFieldByTypeSourcePageIndexLight":
+                    graphicFieldByTypeSourcePageIndexLight(callback, args(0), args(1), args(2), args(3), args(4));
+                    break;
+                case "graphicFieldImageByType":
+                    graphicFieldImageByType(callback, args(0), args(1));
+                    break;
+                case "graphicFieldImageByTypeSource":
+                    graphicFieldImageByTypeSource(callback, args(0), args(1), args(2));
+                    break;
+                case "graphicFieldImageByTypeSourcePageIndex":
+                    graphicFieldImageByTypeSourcePageIndex(callback, args(0), args(1), args(2), args(3));
+                    break;
+                case "graphicFieldImageByTypeSourcePageIndexLight":
+                    graphicFieldImageByTypeSourcePageIndexLight(callback, args(0), args(1), args(2), args(3), args(4));
+                    break;
+                case "containers":
+                    containers(callback, args(0), args(1));
+                    break;
+                case "encryptedContainers":
+                    encryptedContainers(callback, args(0));
+                    break;
             }
         } catch (Exception e) {
             e.printStackTrace();
@@ -430,8 +494,10 @@ public class RNRegulaDocumentReaderModule extends ReactContextBaseJavaModule imp
         };
         Intent intent = new Intent(activity.getApplicationContext(), activity.getClass());
         intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
-        @SuppressLint("UnspecifiedImmutableFlag")
-        PendingIntent pendingIntent = PendingIntent.getActivity(activity.getApplicationContext(), 0, intent, 0);
+        int flags = 0;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+            flags = PendingIntent.FLAG_IMMUTABLE;
+        PendingIntent pendingIntent = PendingIntent.getActivity(activity.getApplicationContext(), 0, intent, flags);
         NfcAdapter.getDefaultAdapter(getActivity()).enableForegroundDispatch(activity, pendingIntent, filters, techList);
     }
 
@@ -482,6 +548,7 @@ public class RNRegulaDocumentReaderModule extends ReactContextBaseJavaModule imp
         callback.success();
     }
 
+    @SuppressLint("MissingPermission")
     private void initializeReaderBleDeviceConfig(Callback callback) {
         if (BluetoothUtil.Companion.getBleManager() == null) callback.error("bleManager is null");
         if (!Instance().isReady())
@@ -794,15 +861,126 @@ public class RNRegulaDocumentReaderModule extends ReactContextBaseJavaModule imp
         callback.success();
     }
 
-    private void setCameraSessionIsPaused(Callback callback, @SuppressWarnings("unused") boolean ignored) {
-        callback.error("setCameraSessionIsPaused() is an ios-only method");
-    }
-
     private void setRfidDelegate(Callback callback, int delegate) {
         rfidDelegate = delegate;
         callback.success();
     }
 
+    private void textFieldValueByType(Callback callback, String raw, int fieldType) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(results.getTextFieldValueByType(fieldType));
+    }
+
+    private void textFieldValueByTypeLcid(Callback callback, String raw, int fieldType, int lcid) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(results.getTextFieldValueByType(fieldType, lcid));
+    }
+
+    private void textFieldValueByTypeSource(Callback callback, String raw, int fieldType, int source) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(results.getTextFieldValueByTypeAndSource(fieldType, source));
+    }
+
+    private void textFieldValueByTypeLcidSource(Callback callback, String raw, int fieldType, int lcid, int source) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(results.getTextFieldValueByType(fieldType, lcid, source));
+    }
+
+    private void textFieldValueByTypeSourceOriginal(Callback callback, String raw, int fieldType, int source, boolean original) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(results.getTextFieldValueByTypeAndSource(fieldType, source, original));
+    }
+
+    private void textFieldValueByTypeLcidSourceOriginal(Callback callback, String raw, int fieldType, int lcid, int source, boolean original) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(results.getTextFieldValueByType(fieldType, lcid, source, original));
+    }
+
+    private void textFieldByType(Callback callback, String raw, int fieldType) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        DocumentReaderTextField result = results.getTextFieldByType(fieldType);
+        if (result == null)
+            callback.success(null);
+        else
+            callback.success(JSONConstructor.generateDocumentReaderTextField(result, getContext()).toString());
+    }
+
+    private void textFieldByTypeLcid(Callback callback, String raw, int fieldType, int lcid) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        DocumentReaderTextField result = results.getTextFieldByType(fieldType, lcid);
+        if (result == null)
+            callback.success(null);
+        else
+            callback.success(JSONConstructor.generateDocumentReaderTextField(result, getContext()).toString());
+    }
+
+    private void graphicFieldByTypeSource(Callback callback, String raw, int fieldType, int source) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        DocumentReaderGraphicField result = results.getGraphicFieldByType(fieldType, source);
+        if (result == null)
+            callback.success(null);
+        else
+            callback.success(JSONConstructor.generateDocumentReaderGraphicField(result, getContext()).toString());
+    }
+
+    private void graphicFieldByTypeSourcePageIndex(Callback callback, String raw, int fieldType, int source, int pageIndex) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        DocumentReaderGraphicField result = results.getGraphicFieldByType(fieldType, source, pageIndex);
+        if (result == null)
+            callback.success(null);
+        else
+            callback.success(JSONConstructor.generateDocumentReaderGraphicField(result, getContext()).toString());
+    }
+
+    private void graphicFieldByTypeSourcePageIndexLight(Callback callback, String raw, int fieldType, int source, int pageIndex, int light) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        DocumentReaderGraphicField result = results.getGraphicFieldByType(fieldType, source, pageIndex, light);
+        if (result == null)
+            callback.success(null);
+        else
+            callback.success(JSONConstructor.generateDocumentReaderGraphicField(result, getContext()).toString());
+    }
+
+    private void graphicFieldImageByType(Callback callback, String raw, int fieldType) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(Helpers.bitmapToBase64String(results.getGraphicFieldImageByType(fieldType)));
+    }
+
+    private void graphicFieldImageByTypeSource(Callback callback, String raw, int fieldType, int source) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(Helpers.bitmapToBase64String(results.getGraphicFieldImageByType(fieldType, source)));
+    }
+
+    private void graphicFieldImageByTypeSourcePageIndex(Callback callback, String raw, int fieldType, int source, int pageIndex) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(Helpers.bitmapToBase64String(results.getGraphicFieldImageByType(fieldType, source, pageIndex)));
+    }
+
+    private void graphicFieldImageByTypeSourcePageIndexLight(Callback callback, String raw, int fieldType, int source, int pageIndex, int light) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(Helpers.bitmapToBase64String(results.getGraphicFieldImageByType(fieldType, source, pageIndex, light)));
+    }
+
+    @SuppressLint("WrongConstant")
+    private void containers(Callback callback, String raw, JSONArray resultType) {
+        try {
+            DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+            callback.success(results.getContainers(JSONConstructor.intArrayFromJSON(resultType)));
+        } catch (JSONException e) {
+            e.printStackTrace();
+            callback.error(e.toString());
+        }
+    }
+
+    private void encryptedContainers(Callback callback, String raw) {
+        DocumentReaderResults results = DocumentReaderResults.fromRawResults(raw);
+        callback.success(results.getEncryptedContainers());
+    }
+
+    private void setCameraSessionIsPaused(Callback callback, @SuppressWarnings("unused") boolean ignored) {
+        callback.error("setCameraSessionIsPaused() is an ios-only method");
+    }
+
     private void getCameraSessionIsPaused(Callback callback) {
         callback.error("getCameraSessionIsPaused() is an ios-only method");
     }

package/android/src/main/java/com/regula/documentreader/RegulaConfig.java

@@ -227,6 +227,8 @@ class RegulaConfig {
             processParams.respectImageQuality = opts.getBoolean("respectImageQuality");
         if (opts.has("splitNames"))
             processParams.splitNames = opts.getBoolean("splitNames");
+        if (opts.has("convertCase"))
+            processParams.convertCase = opts.getInt("convertCase");
     }
 
     private static void setCustomization(ParamsCustomization customization, JSONObject opts, Context context) throws JSONException {
@@ -516,6 +518,7 @@ class RegulaConfig {
         object.put("documentGroupFilter", generateIntArray(processParams.documentGroupFilter));
         object.put("respectImageQuality", processParams.respectImageQuality);
         object.put("splitNames", processParams.splitNames);
+        object.put("convertCase", processParams.convertCase);
 
         return object;
     }

package/example/App.js

@@ -159,7 +159,7 @@ export default class App extends Component {
 
   updateRfidUI(results) {
     if (results.code === Enum.eRFID_NotificationCodes.RFID_NOTIFICATION_PCSC_READING_DATAGROUP)
-      this.setState({ rfidDescription: Enum.eRFID_DataFile_Type.getTranslation(results.number) })
+      this.setState({ rfidDescription: Enum.eRFID_DataFile_Type.getTranslation(results.dataFileType) })
     this.setState({ rfidUIHeader: "Reading RFID", rfidUIHeaderColor: "black", rfidProgress: results.value / 100 })
     if (Platform.OS === 'ios')
       DocumentReader.setRfidSessionStatus(this.state.rfidDescription + "\n" + results.value + "%", e => { }, e => { })
@@ -171,11 +171,20 @@ export default class App extends Component {
 
   displayResults(results) {
     if(results == null) return
-    this.setState({ fullName: results.getTextFieldValueByType({ fieldType: Enum.eVisualFieldType.FT_SURNAME_AND_GIVEN_NAMES }) })
-    if (results.getGraphicFieldImageByType({ fieldType: Enum.eGraphicFieldType.GF_DOCUMENT_IMAGE }) != null)
-      this.setState({ docFront: { uri: "data:image/png;base64," + results.getGraphicFieldImageByType({ fieldType: Enum.eGraphicFieldType.GF_DOCUMENT_IMAGE }) } })
-    if (results.getGraphicFieldImageByType({ fieldType: Enum.eGraphicFieldType.GF_PORTRAIT }) != null)
-      this.setState({ portrait: { uri: "data:image/png;base64," + results.getGraphicFieldImageByType({ fieldType: Enum.eGraphicFieldType.GF_PORTRAIT }) } })
+
+    results.textFieldValueByType(Enum.eVisualFieldType.FT_SURNAME_AND_GIVEN_NAMES, (value) => {
+      this.setState({ fullName: value })
+    }, error => console.log(error))
+
+    results.graphicFieldImageByType(Enum.eGraphicFieldType.GF_DOCUMENT_IMAGE, (value) => {
+      if(value != null && value != "")
+        this.setState({ docFront: { uri: "data:image/png;base64," + value } })
+    }, error => console.log(error))
+
+    results.graphicFieldImageByType(Enum.eGraphicFieldType.GF_PORTRAIT, (value) => {
+      if(value != null && value != "")
+        this.setState({ portrait: { uri: "data:image/png;base64," + value } })
+    }, error => console.log(error))
   }
 
   customRFID() {

package/example/metro.config.js

@@ -1,6 +1,5 @@
 const path = require('path');
 const folders = [
-  "../",
   path.resolve(path.join(__dirname, './node_modules'))
 ];
 module.exports = {

package/example/package.json

@@ -10,8 +10,8 @@
     "lint": "eslint ."
   },
   "dependencies": {
-    "@regulaforensics/react-native-document-reader-api": "6.6.0",
-    "@regulaforensics/react-native-document-reader-core-fullrfid": "6.6.0",
+    "@regulaforensics/react-native-document-reader-api": "6.7.1",
+    "@regulaforensics/react-native-document-reader-core-fullrfid": "6.7.0",
     "react": "17.0.2",
     "react-native": "^0.67.0",
     "react-native-check-box": "^2.1.7",