@regulaforensics/cordova-plugin-document-reader-api 5.5.0 → 6.1.0

package/src/android/RegulaConfig.java

@@ -5,6 +5,7 @@ import org.json.JSONObject;
 import org.json.JSONException;
 
 import com.regula.documentreader.api.DocumentReader;
+import com.regula.documentreader.api.params.ImageQA;
 import com.regula.documentreader.api.params.ParamsCustomization;
 import com.regula.documentreader.api.params.Functionality;
 import com.regula.documentreader.api.params.ProcessParam;
@@ -98,6 +99,10 @@ class RegulaConfig {
             editor.setIsCameraTorchCheckDisabled(opts.getBoolean("isCameraTorchCheckDisabled"));
         if (opts.has("recordScanningProcess"))
             editor.setDoRecordProcessingVideo(opts.getBoolean("recordScanningProcess"));
+        if (opts.has("manualMultipageMode"))
+            editor.setManualMultipageMode(opts.getBoolean("manualMultipageMode"));
+        if (opts.has("exposure"))
+            editor.setExposure(BigDecimal.valueOf(opts.getDouble("exposure")).floatValue());
 
         editor.apply();
     }
@@ -163,6 +168,49 @@ class RegulaConfig {
             processParams.checkHologram = opts.getBoolean("checkHologram");
         if (opts.has("checkRequiredTextFields"))
             processParams.checkRequiredTextFields = opts.getBoolean("checkRequiredTextFields");
+        if (opts.has("depersonalizeLog"))
+            processParams.depersonalizeLog = opts.getBoolean("depersonalizeLog");
+        if (opts.has("resultTypeOutput"))
+            processParams.resultTypeOutput = intArrayFromJson(opts.getJSONArray("resultTypeOutput"));
+        if (opts.has("generateDoublePageSpreadImage"))
+            processParams.generateDoublePageSpreadImage = opts.getBoolean("generateDoublePageSpreadImage");
+        if (opts.has("imageDpiOutMax"))
+            processParams.imageDpiOutMax = opts.getInt("imageDpiOutMax");
+        if (opts.has("alreadyCropped"))
+            processParams.alreadyCropped = opts.getBoolean("alreadyCropped");
+        if (opts.has("forceDocID"))
+            processParams.forceDocID = opts.getInt("forceDocID");
+        if (opts.has("matchTextFieldMask"))
+            processParams.matchTextFieldMask = opts.getBoolean("matchTextFieldMask");
+        if (opts.has("fastDocDetect"))
+            processParams.fastDocDetect = opts.getBoolean("fastDocDetect");
+        if (opts.has("updateOCRValidityByGlare"))
+            processParams.updateOCRValidityByGlare = opts.getBoolean("updateOCRValidityByGlare");
+        if (opts.has("imageQA")) {
+            ImageQA img = new ImageQA();
+            img.fromJson(opts.getJSONObject("imageQA"));
+            processParams.imageQA = img;
+        }
+        if (opts.has("forceDocFormat"))
+            processParams.forceDocFormat = opts.getInt("forceDocFormat");
+        if (opts.has("noGraphics"))
+            processParams.noGraphics = opts.getBoolean("noGraphics");
+        if (opts.has("documentAreaMin"))
+            processParams.documentAreaMin = opts.getDouble("documentAreaMin");
+        if (opts.has("multiDocOnImage"))
+            processParams.multiDocOnImage = opts.getBoolean("multiDocOnImage");
+        if (opts.has("shiftExpiryDate"))
+            processParams.shiftExpiryDate = opts.getInt("shiftExpiryDate");
+        if (opts.has("minimalHolderAge"))
+            processParams.minimalHolderAge = opts.getInt("minimalHolderAge");
+        if (opts.has("mrzFormatsFilter"))
+            processParams.mrzFormatsFilter = stringArrayFromJson(opts.getJSONArray("mrzFormatsFilter"));
+        if (opts.has("forceReadMrzBeforeLocate"))
+            processParams.forceReadMrzBeforeLocate = opts.getBoolean("forceReadMrzBeforeLocate");
+        if (opts.has("parseBarcodes"))
+            processParams.parseBarcodes = opts.getBoolean("parseBarcodes");
+        if (opts.has("shouldReturnPackageForReprocess"))
+            processParams.shouldReturnPackageForReprocess = opts.getBoolean("shouldReturnPackageForReprocess");
     }
 
     private static void setCustomization(ParamsCustomization customization, JSONObject opts, Context context) throws JSONException {
@@ -253,10 +301,6 @@ class RegulaConfig {
             editor.setCameraFrameCornerRadius((float) opts.getDouble("cameraFrameCornerRadius"));
         if (opts.has("cameraFrameLineCap"))
             editor.setCameraFrameLineCap(Paint.Cap.values()[(opts.getInt("cameraFrameLineCap"))]);
-        if (opts.has("torchImageOnImage"))
-            editor.setTorchImageOn(drawableFromBase64(opts.getString("torchImageOnImage"), context));
-        if (opts.has("torchImageOffImage"))
-            editor.setTorchImageOff(drawableFromBase64(opts.getString("torchImageOffImage"), context));
         if (opts.has("closeButtonImage"))
             editor.setCloseButtonImage(drawableFromBase64(opts.getString("closeButtonImage"), context));
         if (opts.has("captureButtonImage"))
@@ -277,8 +321,10 @@ class RegulaConfig {
             editor.setChangeFrameCollapseButtonImage(drawableFromBase64(opts.getString("changeFrameButtonCollapseImage"), context));
         if (opts.has("toolbarSize"))
             editor.setToolbarSize(BigDecimal.valueOf(opts.getDouble("toolbarSize")).floatValue());
+        if (opts.has("statusBackgroundColor"))
+            editor.setStatusBackgroundColor(opts.getString("statusBackgroundColor"));
 
-        editor.apply();
+        editor.applyImmediately(context);
     }
 
     private static JSONObject getFunctionality(Functionality functionality) throws JSONException {
@@ -315,6 +361,8 @@ class RegulaConfig {
         object.put("zoomFactor", functionality.getZoomFactor());
         object.put("isCameraTorchCheckDisabled", functionality.isCameraTorchCheckDisabled());
         object.put("recordScanningProcess", functionality.doRecordProcessingVideo());
+        object.put("manualMultipageMode", functionality.isManualMultipageMode());
+        object.put("exposure", functionality.getExposure());
 
         return object;
     }
@@ -364,8 +412,6 @@ class RegulaConfig {
         object.put("cameraFramePortraitAspectRatio", customization.getCameraFramePortraitAspectRatio());
         object.put("cameraFrameCornerRadius", customization.getCameraFrameCornerRadius());
         object.put("cameraFrameLineCap", customization.getCameraFrameLineCap().toString());
-        object.put("torchImageOnImage", bitmapToBase64String(bitmapFromDrawable(customization.getTorchImageOnDrawable())));
-        object.put("torchImageOffImage", bitmapToBase64String(bitmapFromDrawable(customization.getTorchImageOffDrawable())));
         object.put("closeButtonImage", bitmapToBase64String(bitmapFromDrawable(customization.getCloseButtonDrawable())));
         object.put("captureButtonImage", bitmapToBase64String(bitmapFromDrawable(customization.getCaptureButtonDrawable())));
         object.put("changeFrameCollapseButtonImage", bitmapToBase64String(bitmapFromDrawable(customization.getChangeFrameCollapseButtonDrawable())));
@@ -376,12 +422,17 @@ class RegulaConfig {
         object.put("changeFrameButtonExpandImage", bitmapToBase64String(bitmapFromDrawable(customization.getChangeFrameExpandButtonDrawable())));
         object.put("changeFrameButtonCollapseImage", bitmapToBase64String(bitmapFromDrawable(customization.getChangeFrameCollapseButtonDrawable())));
         object.put("toolbarSize", customization.getToolbarSize());
+        object.put("statusBackgroundColor", customization.getStatusBackgroundColor());
 
         return object;
     }
 
     private static JSONObject getProcessParams(ProcessParam processParams) throws JSONException {
         JSONObject object = new JSONObject();
+        object.put("documentIDList", processParams.documentIDList != null ? generateIntArray(processParams.documentIDList) : null);
+        object.put("barcodeTypes", processParams.doBarcodes != null ? generateArray(processParams.doBarcodes) : null);
+        object.put("fieldTypesFilter", processParams.fieldTypesFilter != null ? generateIntArray(processParams.fieldTypesFilter) : null);
+        object.put("faceMetaData", processParams.faceMetaData != null ? generateArray(processParams.faceMetaData, JSONConstructor::generateFaceMetaData) : null);
         object.put("scenario", processParams.scenario);
         object.put("measureSystem", processParams.measureSystem);
         object.put("uvTorchEnabled", processParams.uvTorchEnabled);
@@ -409,14 +460,26 @@ class RegulaConfig {
         object.put("returnCroppedBarcode", processParams.returnCroppedBarcode);
         object.put("checkHologram", processParams.checkHologram);
         object.put("checkRequiredTextFields", processParams.checkRequiredTextFields);
-        if (processParams.documentIDList != null)
-            object.put("documentIDList", generateIntArray(processParams.documentIDList));
-        if (processParams.doBarcodes != null)
-            object.put("barcodeTypes", generateArray(processParams.doBarcodes));
-        if (processParams.fieldTypesFilter != null)
-            object.put("fieldTypesFilter", generateIntArray(processParams.fieldTypesFilter));
-        if (processParams.faceMetaData != null)
-            object.put("faceMetaData", generateArray(processParams.faceMetaData, JSONConstructor::generateFaceMetaData));
+        object.put("depersonalizeLog", processParams.depersonalizeLog);
+        object.put("resultTypeOutput", processParams.resultTypeOutput);
+        object.put("generateDoublePageSpreadImage", processParams.generateDoublePageSpreadImage);
+        object.put("imageDpiOutMax", processParams.imageDpiOutMax);
+        object.put("alreadyCropped", processParams.alreadyCropped);
+        object.put("forceDocID", processParams.forceDocID);
+        object.put("matchTextFieldMask", processParams.matchTextFieldMask);
+        object.put("fastDocDetect", processParams.fastDocDetect);
+        object.put("updateOCRValidityByGlare", processParams.updateOCRValidityByGlare);
+        object.put("imageQA", processParams.imageQA != null ? processParams.imageQA.toJsonObject() : null);
+        object.put("forceDocFormat", processParams.forceDocFormat);
+        object.put("noGraphics", processParams.noGraphics);
+        object.put("documentAreaMin", processParams.documentAreaMin);
+        object.put("multiDocOnImage", processParams.multiDocOnImage);
+        object.put("shiftExpiryDate", processParams.shiftExpiryDate);
+        object.put("minimalHolderAge", processParams.minimalHolderAge);
+        object.put("mrzFormatsFilter", processParams.mrzFormatsFilter != null ? generateArray(processParams.mrzFormatsFilter) : null);
+        object.put("forceReadMrzBeforeLocate", processParams.forceReadMrzBeforeLocate);
+        object.put("parseBarcodes", processParams.parseBarcodes);
+        object.put("shouldReturnPackageForReprocess", processParams.shouldReturnPackageForReprocess);
 
         return object;
     }

package/src/android/build.gradle

@@ -1,18 +1,18 @@
 repositories {
-		jcenter()
-		maven{
-			url "https://maven.google.com"
-		}
-		maven{
-			url "http://maven.regulaforensics.com/RegulaDocumentReader"
-		}
-		maven {
-			url "http://maven.regulaforensics.com/RegulaDocumentReader/Beta"
-		}
+	jcenter()
+	maven{
+		url "https://maven.google.com"
 	}
+	maven{
+		url "https://maven.regulaforensics.com/RegulaDocumentReader"
+	}
+	maven {
+		url "https://maven.regulaforensics.com/RegulaDocumentReader/Beta"
+	}
+}
 
 dependencies {
-	implementation ('com.regula.documentreader:api:5.5.4633'){
+	implementation ('com.regula.documentreader:api:6.1.6564'){
         transitive = true
     }
 }

package/src/ios/RGLDocumentReader.h

@@ -1,14 +1,19 @@
 #import <Cordova/CDVPlugin.h>
 #import <Foundation/Foundation.h>
-#import "JSONConstructor.h"
+#import "RGLWJSONConstructor.h"
 #import "RegulaConfig.h"
 #import <DocumentReader/DocumentReader.h>
 
 @class DocReader;
 
-@interface RGLDocumentReader : CDVPlugin<RGLRecordScanningProcessDelegate>
+@interface RGLDocumentReader : CDVPlugin<RGLRecordScanningProcessDelegate, RGLDocReaderRFIDDelegate>
 
 @property (class) CDVInvokedUrlCommand* _Nullable command;
 @property (class) NSNumber* _Nullable databasePercentageDownloaded;
 
-@end
+- (void) sendEvent:(NSString*_Nullable)data :(NSString*_Nonnull)callbackId;
+
+@end
+
+@interface RFIDDelegateNoPA : NSObject<RGLDocReaderRFIDDelegate>
+@end

package/src/ios/RGLDocumentReader.m

@@ -2,6 +2,40 @@
 #import "RGLDocumentReader.h"
 @import DocumentReader;
 
+RGLRFIDCertificatesCallback paCertificateCompletion;
+RGLRFIDCertificatesCallback taCertificateCompletion;
+typedef void (^RGLRFIDSignatureCallback)(NSData *signature);
+RGLRFIDSignatureCallback taSignatureCompletion;
+RFIDDelegateNoPA* rfidDelegateNoPA;
+RGLDocumentReader* plugin;
+NSString* rfidNotificationCompletionEvent = @"rfidNotificationCompletionEvent";
+NSString* paCertificateCompletionEvent = @"paCertificateCompletionEvent";
+NSString* taCertificateCompletionEvent = @"taCertificateCompletionEvent";
+NSString* taSignatureCompletionEvent = @"taSignatureCompletionEvent";
+
+@implementation RFIDDelegateNoPA
+
+- (void)onRequestTACertificatesWithKey:(NSString *)keyCAR callback:(RGLRFIDCertificatesCallback)callback {
+    taCertificateCompletion = callback;
+    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", taCertificateCompletionEvent, keyCAR] :RGLDocumentReader.command.callbackId];
+}
+
+- (void)onRequestTASignatureWithChallenge:(RGLTAChallenge *)challenge callback:(void(^)(NSData *signature))callback {
+    taSignatureCompletion = callback;
+    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", taSignatureCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLTAChallenge:challenge]]] :RGLDocumentReader.command.callbackId];
+}
+
+- (void)didChipConnected {
+    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", rfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletion:1]]] :RGLDocumentReader.command.callbackId]; // int RFID_EVENT_CHIP_DETECTED = 1;
+}
+
+- (void)didReceivedError:(RGLRFIDErrorCodes)errorCode {
+    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", rfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletionWithError:2:errorCode]]] :RGLDocumentReader.command.callbackId]; // int RFID_EVENT_READING_ERROR = 2;
+}
+
+@end
+
+
 @implementation RGLDocumentReader
 
 static NSNumber* _databasePercentageDownloaded;
@@ -37,36 +71,60 @@ typedef void (^Callback)(NSString* response);
 -(RGLDocumentReaderCompletion _Nonnull)getCompletion {
     NSString* callbackId = RGLDocumentReader.command.callbackId;
     return ^(RGLDocReaderAction action, RGLDocumentReaderResults * _Nullable results, NSError * _Nullable error) {
-        [self sendEvent:[JSONConstructor dictToString:[JSONConstructor generateCompletion:[JSONConstructor generateDocReaderAction: action] :results :error :nil]] :callbackId];
+        [self sendEvent:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateCompletion:[RGLWJSONConstructor generateDocReaderAction: action] :results :error :nil]] :callbackId];
     };
 }
 
 -(RGLRFIDProcessCompletion _Nonnull)getRFIDCompletion {
     NSString* callbackId = RGLDocumentReader.command.callbackId;
     return ^(RGLRFIDCompleteAction action, RGLDocumentReaderResults * _Nullable results, NSError * _Nullable error, RGLRFIDErrorCodes errorCode) {
-        [self sendEvent:[JSONConstructor dictToString:[JSONConstructor generateCompletion:[JSONConstructor generateRFIDCompleteAction: action] :results :error :nil]] :callbackId];
+        [self sendEvent:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateCompletion:[RGLWJSONConstructor generateRFIDCompleteAction: action] :results :error :nil]] :callbackId];
     };
 }
 
 -(RGLRFIDNotificationCallback _Nonnull)getRFIDNotificationCallback {
     NSString* callbackId = RGLDocumentReader.command.callbackId;
     return ^(RGLRFIDNotificationAction notificationAction, RGLRFIDNotify* _Nullable notify) {
-        [self sendEvent:[JSONConstructor dictToString:[JSONConstructor generateCompletion:[JSONConstructor generateRFIDNotificationAction:notificationAction] :nil :nil :notify]] :callbackId];
+        [self sendEvent:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateCompletion:[RGLWJSONConstructor generateRFIDNotificationAction:notificationAction] :nil :nil :notify]] :callbackId];
     };
 }
 
 - (void)didFinishRecordingToFile:(NSURL *)fileURL {
     NSString* callbackId = RGLDocumentReader.command.callbackId;
-    [self sendEvent:[JSONConstructor dictToString:[JSONConstructor generateVideoEncoderCompletion:fileURL :nil]] :callbackId];
+    [self sendEvent:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateVideoEncoderCompletion:fileURL :nil]] :callbackId];
 }
 
 - (void)didFailWithError:(NSError *)error {
     NSString* callbackId = RGLDocumentReader.command.callbackId;
-    [self sendEvent:[JSONConstructor dictToString:[JSONConstructor generateVideoEncoderCompletion:nil :error]] :callbackId];
+    [self sendEvent:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateVideoEncoderCompletion:nil :error]] :callbackId];
+}
+
+- (void)onRequestPACertificatesWithSerial:(NSData *)serialNumber issuer:(RGLPAResourcesIssuer *)issuer callback:(RGLRFIDCertificatesCallback)callback {
+    paCertificateCompletion = callback;
+    [self sendEvent:[NSString stringWithFormat:@"%@%@", paCertificateCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generatePACertificateCompletion:serialNumber :issuer]]] :RGLDocumentReader.command.callbackId];
+}
+
+- (void)onRequestTACertificatesWithKey:(NSString *)keyCAR callback:(RGLRFIDCertificatesCallback)callback {
+    taCertificateCompletion = callback;
+    [self sendEvent:[NSString stringWithFormat:@"%@%@", taCertificateCompletionEvent, keyCAR] :RGLDocumentReader.command.callbackId];
+}
+
+- (void)onRequestTASignatureWithChallenge:(RGLTAChallenge *)challenge callback:(void(^)(NSData *signature))callback {
+    taSignatureCompletion = callback;
+    [self sendEvent:[NSString stringWithFormat:@"%@%@", taSignatureCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLTAChallenge:challenge]]] :RGLDocumentReader.command.callbackId];
+}
+
+- (void)didChipConnected {
+    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", rfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletion:1]]] :RGLDocumentReader.command.callbackId]; // int RFID_EVENT_CHIP_DETECTED = 1;
+}
+
+- (void)didReceivedError:(RGLRFIDErrorCodes)errorCode {
+    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", rfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletionWithError:2:errorCode]]] :RGLDocumentReader.command.callbackId]; // int RFID_EVENT_READING_ERROR = 2;
 }
 
 - (void) exec:(CDVInvokedUrlCommand*)command {
     [RGLDocumentReader setCommand:command];
+    plugin = self;
     NSMutableArray* args = [[NSMutableArray alloc] init];
     NSString* action = [[command arguments] objectAtIndex:0];
     for(int i = 1;i<[command arguments].count;i++)
@@ -78,7 +136,9 @@ typedef void (^Callback)(NSString* response);
         [self.commandDelegate sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:response] callbackId:command.callbackId];
     };
 
-    if([action isEqualToString:@"getAPIVersion"])
+    if([action isEqualToString:@"initializeReaderAutomatically"])
+        [self initializeReaderAutomatically :successCallback :errorCallback];
+    else if([action isEqualToString:@"getAPIVersion"])
         [self getAPIVersion :successCallback :errorCallback];
     else if([action isEqualToString:@"getAvailableScenarios"])
         [self getAvailableScenarios :successCallback :errorCallback];
@@ -148,6 +208,8 @@ typedef void (^Callback)(NSString* response);
         [self readRFID :successCallback :errorCallback];
     else if([action isEqualToString:@"getRfidSessionStatus"])
         [self getRfidSessionStatus :successCallback :errorCallback];
+    else if([action isEqualToString:@"setRfidDelegate"])
+        [self setRfidDelegate :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"setEnableCoreLogs"])
         [self setEnableCoreLogs :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"addPKDCertificates"])
@@ -174,8 +236,18 @@ typedef void (^Callback)(NSString* response);
         [self recognizeImage :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"setRfidSessionStatus"])
         [self setRfidSessionStatus :[args objectAtIndex:0] :successCallback :errorCallback];
+    else if([action isEqualToString:@"providePACertificates"])
+        [self providePACertificates :[args objectAtIndex:0] :successCallback :errorCallback];
+    else if([action isEqualToString:@"provideTACertificates"])
+        [self provideTACertificates :[args objectAtIndex:0] :successCallback :errorCallback];
+    else if([action isEqualToString:@"provideTASignature"])
+        [self provideTASignature :[args objectAtIndex:0] :successCallback :errorCallback];
+    else if([action isEqualToString:@"parseCoreResults"])
+        [self parseCoreResults :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"initializeReaderWithDatabasePath"])
         [self initializeReaderWithDatabasePath :[args objectAtIndex:0] :[args objectAtIndex:1] :successCallback :errorCallback];
+    else if([action isEqualToString:@"initializeReaderWithDatabase"])
+        [self initializeReaderWithDatabase :[args objectAtIndex:0] :[args objectAtIndex:1] :successCallback :errorCallback];
     else if([action isEqualToString:@"recognizeImageFrame"])
         [self recognizeImageFrame :[args objectAtIndex:0] :[args objectAtIndex:1] :successCallback :errorCallback];
     else if([action isEqualToString:@"recognizeImageWithOpts"])
@@ -192,6 +264,12 @@ typedef void (^Callback)(NSString* response);
         [self result:[NSString stringWithFormat:@"%@/%@", @"method not implemented: ", action] :errorCallback];
 }
 
+- (void) initializeReaderAutomatically:(Callback)successCallback :(Callback)errorCallback{
+    NSString *dataPath = [[NSBundle mainBundle] pathForResource:@"regula.license" ofType:nil];
+    NSData *licenseData = [NSData dataWithContentsOfFile:dataPath];
+    [RGLDocReader.shared initializeReaderWithConfig:[RGLConfig configWithLicenseData:licenseData] completion:[self getInitCompletion :successCallback :errorCallback]];
+}
+
 - (void) resetConfiguration:(Callback)successCallback :(Callback)errorCallback{
     [self result:@"resetConfiguration() is an android-only method" :errorCallback];
 }
@@ -228,8 +306,16 @@ typedef void (^Callback)(NSString* response);
     [self result:@"getLicenseMessage() is an android-only method" :successCallback];
 }
 
+- (void) initializeReaderWithDatabase:(NSString*)licenseString :(NSString*)databaseString :(Callback)successCallback :(Callback)errorCallback{
+    [self result:@"initializeReaderWithDatabase() is an android-only method" :successCallback];
+}
+
 - (void) initializeReader:(NSString*)licenseString :(Callback)successCallback :(Callback)errorCallback{
-    [RGLDocReader.shared initializeReader:[[NSData alloc] initWithBase64EncodedString:licenseString options:0] completion:[self getInitCompletion :successCallback :errorCallback]];
+    [RGLDocReader.shared initializeReaderWithConfig:[RGLConfig configWithLicenseData:[[NSData alloc] initWithBase64EncodedString:licenseString options:0]] completion:[self getInitCompletion :successCallback :errorCallback]];
+}
+
+- (void) parseCoreResults:(NSString*)json :(Callback)successCallback :(Callback)errorCallback{
+    [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLDocumentReaderResults:[RGLDocumentReaderResults initWithRawString: json]]] :successCallback];
 }
 
 - (void) startRFIDReader:(Callback)successCallback :(Callback)errorCallback{
@@ -239,7 +325,7 @@ typedef void (^Callback)(NSString* response);
 }
 
 - (void) initializeReaderWithDatabasePath:(NSString*)licenseString :(NSString*)databasePath :(Callback)successCallback :(Callback)errorCallback{
-    [RGLDocReader.shared initializeReader:[[NSData alloc] initWithBase64EncodedString:licenseString options:0] databasePath:databasePath completion:[self getInitCompletion :successCallback :errorCallback]];
+    [RGLDocReader.shared initializeReaderWithConfig:[RGLConfig configWithLicenseData:[[NSData alloc] initWithBase64EncodedString:licenseString options:0] licenseUpdateCheck:true databasePath:databasePath delayedNNLoadEnabled:false] completion:[self getInitCompletion :successCallback :errorCallback]];
 }
 
 - (void) prepareDatabase:(NSString*)dbID :(Callback)successCallback :(Callback)errorCallback{
@@ -329,7 +415,7 @@ typedef void (^Callback)(NSString* response);
 - (void) addPKDCertificates:(NSArray*)input :(Callback)successCallback :(Callback)errorCallback{
     NSMutableArray *certificates = [[NSMutableArray alloc] init];
     for(NSDictionary* certificateJSON in input)
-        [certificates addObject:[JSONConstructor RGLPKDCertificateFromJson:certificateJSON]];
+        [certificates addObject:[RGLWJSONConstructor RGLPKDCertificateFromJson:certificateJSON]];
     [RGLDocReader.shared addPKDCertificates:certificates];
     [self result:@"" :successCallback];
 }
@@ -340,7 +426,7 @@ typedef void (^Callback)(NSString* response);
 }
 
 - (void) selectedScenario:(Callback)successCallback :(Callback)errorCallback{
-    [self result:[JSONConstructor dictToString:[JSONConstructor generateRGLScenario:RGLDocReader.shared.selectedScenario]] :successCallback];
+    [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLScenario:RGLDocReader.shared.selectedScenario]] :successCallback];
 }
 
 - (void) stopScanner:(Callback)successCallback :(Callback)errorCallback{
@@ -462,7 +548,7 @@ typedef void (^Callback)(NSString* response);
     BOOL success = false;
     for(RGLScenario *scenario in RGLDocReader.shared.availableScenarios)
         if([scenario.identifier isEqualToString:scenarioID]){
-            [self result:[JSONConstructor dictToString:[JSONConstructor generateRGLScenario:scenario]] :successCallback];
+            [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLScenario:scenario]] :successCallback];
             success = true;
             break;
         }
@@ -470,10 +556,64 @@ typedef void (^Callback)(NSString* response);
         [self result:@"Scenario unavailable" :errorCallback];
 }
 
+- (void) providePACertificates:(NSArray*)input :(Callback)successCallback :(Callback)errorCallback{
+    if(paCertificateCompletion == nil){
+        [self result:@"paCertificateCompletion is nil" :errorCallback];
+        return;
+    }
+    NSMutableArray *certificates = [[NSMutableArray alloc] init];
+    for(NSDictionary* certificateJSON in input)
+        [certificates addObject:[RGLWJSONConstructor RGLPKDCertificateFromJson:certificateJSON]];
+    paCertificateCompletion(certificates);
+    [self result:@"" :successCallback];
+}
+
+- (void) provideTACertificates:(NSArray*)input :(Callback)successCallback :(Callback)errorCallback{
+    if(taCertificateCompletion == nil){
+        [self result:@"taCertificateCompletion is nil" :errorCallback];
+        return;
+    }
+    NSMutableArray *certificates = [[NSMutableArray alloc] init];
+    for(NSDictionary* certificateJSON in input)
+        [certificates addObject:[RGLWJSONConstructor RGLPKDCertificateFromJson:certificateJSON]];
+    taCertificateCompletion(certificates);
+    [self result:@"" :successCallback];
+}
+
+- (void) provideTASignature:(NSString*)input :(Callback)successCallback :(Callback)errorCallback{
+    if(taSignatureCompletion == nil){
+        [self result:@"taSignatureCompletion is nil" :errorCallback];
+        return;
+    }
+    taSignatureCompletion([[NSData alloc] initWithBase64EncodedString:input options:0]);
+    [self result:@"" :successCallback];
+}
+
+- (void) setRfidDelegate:(NSNumber*)input :(Callback)successCallback :(Callback)errorCallback{
+    switch([input integerValue]){
+        case 0:
+            [RGLDocReader shared].rfidDelegate = nil;
+            break;
+        case 1:
+            if(rfidDelegateNoPA == nil)
+                rfidDelegateNoPA = [RFIDDelegateNoPA new];
+            [RGLDocReader shared].rfidDelegate = rfidDelegateNoPA;
+            break;
+        case 2:
+            [RGLDocReader shared].rfidDelegate = self;
+            break;
+        default:
+            [self result:@"wrong input" :errorCallback];
+            return;
+    }
+
+    [self result:@"" :successCallback];
+}
+
 - (void) getAvailableScenarios:(Callback)successCallback :(Callback)errorCallback{
     NSMutableArray *availableScenarios = [[NSMutableArray alloc] init];
     for(RGLScenario *scenario in RGLDocReader.shared.availableScenarios)
-        [availableScenarios addObject:[JSONConstructor dictToString:[JSONConstructor generateRGLScenario:scenario]]];
+        [availableScenarios addObject:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLScenario:scenario]]];
     [self result:[[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:availableScenarios options:NSJSONWritingPrettyPrinted error:nil] encoding:NSUTF8StringEncoding] :successCallback];
 }
 

package/src/ios/{JSONConstructor.h → RGLWJSONConstructor.h}

@@ -1,12 +1,14 @@
-#ifndef JSONConstructor_h
-#define JSONConstructor_h
+#ifndef RGLWJSONConstructor_h
+#define RGLWJSONConstructor_h
 
 #import <DocumentReader/DocumentReader.h>
 @import CoreGraphics;
 @import UIKit;
 
-@interface JSONConstructor : NSObject
+@interface RGLWJSONConstructor : NSObject
 +(NSString* _Nonnull)dictToString:(NSMutableDictionary* _Nonnull)input;
++(NSMutableDictionary* _Nonnull)generateRfidNotificationCompletion:(NSInteger)notification;
++(NSMutableDictionary* _Nonnull)generateRfidNotificationCompletionWithError:(NSInteger)notification : (NSInteger)value;
 +(NSMutableDictionary* _Nonnull)generateNSDictionary:(NSDictionary<NSNumber*, NSNumber*>* _Nullable)input;
 +(RGLPKDCertificate* _Nullable)RGLPKDCertificateFromJson:(NSDictionary* _Nullable) dict;
 +(NSInteger)generateDocReaderAction:(RGLDocReaderAction)action;
@@ -14,6 +16,8 @@
 +(NSInteger)generateRFIDNotificationAction:(RGLRFIDNotificationAction)action;
 +(NSMutableDictionary* _Nullable)generateCompletion:(NSInteger)action :(RGLDocumentReaderResults*_Nullable)results :(NSError*_Nullable)error :(RGLRFIDNotify*_Nullable)notify;
 +(NSMutableDictionary* _Nonnull)generateVideoEncoderCompletion:(NSURL* _Nullable)input :(NSError* _Nullable)error;
++(NSString*_Nonnull)generateNSData:(NSData *_Nullable)input;
++(NSMutableDictionary* _Nonnull)generatePACertificateCompletion:(NSData *_Nullable)serialNumber :(RGLPAResourcesIssuer *_Nullable)issuer;
 +(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderResults:(RGLDocumentReaderResults* _Nullable)input;
 +(NSMutableDictionary* _Nonnull)generateRGLPosition:(RGLPosition* _Nullable)input;
 +(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderBarcodeResult:(RGLDocumentReaderBarcodeResult* _Nullable)input;
@@ -49,6 +53,13 @@
 +(NSMutableDictionary* _Nonnull)generateRGLCertificateChain:(RGLCertificateChain* _Nullable)input;
 +(NSMutableDictionary* _Nonnull)generateRGLValidity:(RGLValidity* _Nullable)input;
 +(NSMutableDictionary* _Nonnull)generateNSError:(NSError* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLPAResourcesIssuer:(RGLPAResourcesIssuer* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLPAAttribute:(RGLPAAttribute* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLTAChallenge:(RGLTAChallenge* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderResultsStatus:(RGLDocumentReaderResultsStatus* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLOpticalStatus:(RGLOpticalStatus* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLVDSNCData:(RGLVDSNCData* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLBytesData:(RGLBytesData* _Nullable)input;
 +(NSMutableDictionary* _Nonnull)generateRGLRFIDNotify:(RGLRFIDNotify* _Nullable)input;
 
 @end