@regulaforensics/face-sdk 8.2.855-nightly → 8.2.856-rc

package/ios/RFSWMain.h

@@ -0,0 +1,24 @@
+#import "RFSWJSONConstructor.h"
+@import FaceSDK;
+
+typedef void (^RFSWCallback)(id _Nullable response);
+typedef void (^RFSWEventSender)(NSString* _Nonnull event, id _Nullable data);
+extern UIViewController*_Nonnull(^ _Nonnull RFSWRootViewController)(void);
+
+@interface RFSWMain: NSObject<RFSURLRequestInterceptingDelegate,
+                              RFSVideoUploadingDelegate,
+                              RFSCustomizationActionDelegate,
+                              RFSFaceCaptureDelegate,
+                              RFSLivenessDelegate>
+
++(void)methodCall:(NSString* _Nonnull)method
+                 :(NSArray* _Nonnull)args
+                 :(RFSWCallback _Nonnull)callback
+                 :(RFSWEventSender _Nonnull)eventSender;
+
+@end
+
+static NSString* _Nonnull cameraSwitchEvent = @"cameraSwitchEvent";
+static NSString* _Nonnull livenessNotificationEvent = @"livenessNotificationEvent";
+static NSString* _Nonnull videoEncoderCompletionEvent = @"video_encoder_completion";
+static NSString* _Nonnull onCustomButtonTappedEvent = @"onCustomButtonTappedEvent";

package/ios/RFSWMain.m

@@ -0,0 +1,381 @@
+#import "RFSWMain.h"
+
+@implementation RFSWMain
+
++(void)methodCall:(NSString*)method :(NSArray*)args :(RFSWCallback)callback :(RFSWEventSender)eventSender {
+    if(!this) this = [RFSWMain new];
+    sendEvent = eventSender;
+    NSDictionary* Switch = @{
+        @"getVersion": ^{ [self getVersion :callback]; },
+        @"getServiceUrl": ^{ [self getServiceUrl :callback]; },
+        @"setServiceUrl": ^{ [self setServiceUrl :args[0] :callback]; },
+        @"getTenant": ^{ [self getTenant :callback]; },
+        @"setTenant": ^{ [self setTenant :args[0]]; },
+        @"getEnv": ^{ [self getEnv :callback]; },
+        @"setEnv": ^{ [self setEnv :args[0]]; },
+        @"getLocale": ^{ [self getLocale :callback]; },
+        @"setLocale": ^{ [self setLocale :args[0]]; },
+        @"setLocalizationDictionary": ^{ [self setLocalizationDictionary :args[0]]; },
+        @"setRequestHeaders": ^{ [self setRequestHeaders :args[0]]; },
+        @"setCustomization": ^{ [self setCustomization :args[0]]; },
+        @"isInitialized": ^{ [self isInitialized :callback]; },
+        @"initialize": ^{ [self initialize :args[0] :callback]; },
+        @"deinitialize": ^{ [self deinitialize]; },
+        @"startFaceCapture": ^{ [self startFaceCapture :args[0] :callback]; },
+        @"stopFaceCapture": ^{ [self stopFaceCapture]; },
+        @"startLiveness": ^{ [self startLiveness :args[0] :callback]; },
+        @"stopLiveness": ^{ [self stopLiveness]; },
+        @"matchFaces": ^{ [self matchFaces :args[0] :args[1] :callback]; },
+        @"splitComparedFaces": ^{ [self splitComparedFaces :args[0] :args[1] :callback]; },
+        @"detectFaces": ^{ [self detectFaces :args[0] :callback]; },
+        @"createPerson": ^{ [self createPerson :args[0] :args[1] :args[2] :callback]; },
+        @"updatePerson": ^{ [self updatePerson :args[0] :callback]; },
+        @"deletePerson": ^{ [self deletePerson :args[0] :callback]; },
+        @"getPerson": ^{ [self getPerson :args[0] :callback]; },
+        @"addPersonImage": ^{ [self addPersonImage :args[0] :args[1] :callback]; },
+        @"deletePersonImage": ^{ [self deletePersonImage :args[0] :args[1] :callback]; },
+        @"getPersonImage": ^{ [self getPersonImage :args[0] :args[1] :callback]; },
+        @"getPersonImages": ^{ [self getPersonImages :args[0] :callback]; },
+        @"getPersonImagesForPage": ^{ [self getPersonImagesForPage :args[0] :args[1] :args[2] :callback]; },
+        @"createGroup": ^{ [self createGroup :args[0] :args[1] :callback]; },
+        @"updateGroup": ^{ [self updateGroup :args[0] :callback]; },
+        @"editPersonsInGroup": ^{ [self editPersonsInGroup :args[0] :args[1] :callback]; },
+        @"deleteGroup": ^{ [self deleteGroup :args[0] :callback]; },
+        @"getGroup": ^{ [self getGroup :args[0] :callback]; },
+        @"getGroups": ^{ [self getGroups :callback]; },
+        @"getGroupsForPage": ^{ [self getGroupsForPage :args[0] :args[1] :callback]; },
+        @"getPersonGroups": ^{ [self getPersonGroups :args[0] :callback]; },
+        @"getPersonGroupsForPage": ^{ [self getPersonGroupsForPage :args[0] :args[1] :args[2] :callback]; },
+        @"getPersonsInGroup": ^{ [self getPersonsInGroup :args[0] :callback]; },
+        @"getPersonsInGroupForPage": ^{ [self getPersonsInGroupForPage :args[0] :args[1] :args[2] :callback]; },
+        @"searchPerson": ^{ [self searchPerson :args[0] :callback]; },
+    };
+    ((void(^)(void))Switch[method])();
+}
+
+static RFSWMain* this;
+static RFSWEventSender sendEvent;
+static NSDictionary* headers;
+
++(void)getVersion:(RFSWCallback)callback {
+    callback([RFSWJSONConstructor generateFaceSDKVersion:RFSFaceSDK.service.version]);
+}
+
++(void)getServiceUrl:(RFSWCallback)callback {
+    callback([RFSFaceSDK.service serviceURL]);
+}
+
++(void)setServiceUrl:(NSString*)url :(RFSWCallback)callback {
+    [RFSFaceSDK.service setServiceURL:url];
+    callback(@"");
+}
+
++(void)getTenant:(RFSWCallback)callback {
+    callback([RFSFaceSDK.service tenant]);
+}
+
++(void)setTenant:(NSString*)tag {
+    [RFSFaceSDK.service setTenant:tag];
+}
+
++(void)getEnv:(RFSWCallback)callback {
+    callback([RFSFaceSDK.service env]);
+}
+
++(void)setEnv:(NSString*)tag {
+    [RFSFaceSDK.service setEnv:tag];
+}
+
++(void)getLocale:(RFSWCallback)callback {
+    callback([RFSFaceSDK.service languageLocaleCode]);
+}
+
++(void)setLocale:(NSString*)locale {
+    [RFSFaceSDK.service setLanguageLocaleCode:locale];
+}
+
++(void)setLocalizationDictionary:(NSDictionary*)dictionary {
+    RFSFaceSDK.service.localizationHandler = ^NSString* (NSString* localizationKey) {
+        if (dictionary[localizationKey]) return dictionary[localizationKey];
+        return nil;
+    };
+}
+
++(void)setRequestHeaders:(NSDictionary*)headersDict {
+    headers = headersDict;
+    RFSFaceSDK.service.requestInterceptingDelegate = this;
+}
+
+-(NSURLRequest*)interceptorPrepareRequest:(NSURLRequest*)request {
+    NSMutableURLRequest *interceptedRequest = [request mutableCopy];
+    for (NSString* key in headers.allKeys)
+        [interceptedRequest addValue:[headers valueForKey:key] forHTTPHeaderField:key];
+    return interceptedRequest;
+}
+
++(void)setCustomization:(NSDictionary*)config {
+    [RFSWConfig setCustomization:config :RFSFaceSDK.service.customization];
+}
+
++(void)isInitialized:(RFSWCallback)callback {
+    callback(@([RFSFaceSDK.service isInitialized]));
+}
+
++(void)initialize:(NSDictionary*)config :(RFSWCallback)callback {
+    [RFSFaceSDK.service initializeWithConfiguration:[RFSWJSONConstructor initConfigFromJSON:config]
+                                         completion:[RFSWMain initCompletion:callback]];
+}
+
++(void)deinitialize {
+    [RFSFaceSDK.service deinitialize];
+}
+
++(void)startFaceCapture:(NSDictionary*)config :(RFSWCallback)callback {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [RFSFaceSDK.service presentFaceCaptureViewControllerFrom:RFSWRootViewController()
+                                                            animated:true
+                                                       configuration:[RFSWConfig faceCaptureConfigFromJSON:config]
+                                                           onCapture:[self faceCaptureCompletion:callback]
+                                                          completion:nil];
+    });
+}
+
++(void)stopFaceCapture {
+    [RFSFaceSDK.service stopFaceCaptureViewController];
+}
+
++(void)startLiveness:(NSDictionary*)config :(RFSWCallback)callback {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [RFSFaceSDK.service startLivenessFrom:RFSWRootViewController()
+                                                animated:true
+                                           configuration:[RFSWConfig livenessConfigFromJSON:config]
+                                              onLiveness:[self livenessCompletion:callback]
+                                              completion:nil];
+    });
+}
+
++(void)stopLiveness {
+    [RFSFaceSDK.service stopLivenessProcessing];
+}
+
++(void)matchFaces:(NSDictionary*)request :(NSDictionary*)config :(RFSWCallback)callback {
+    [RFSFaceSDK.service matchFaces:[RFSWJSONConstructor matchFacesRequestFromJSON:request]
+                     configuration:[RFSWConfig matchFacesConfigFromJSON:config]
+                        completion:[self matchFacesCompletion:callback]];
+}
+
++(void)splitComparedFaces:(NSArray*)faces :(NSNumber*)similarity :(RFSWCallback)callback {
+    NSArray* array = [RFSWJSONConstructor arrayFromJSON:faces :@selector(comparedFacesPairFromJSON:)];
+    RFSMatchFacesSimilarityThresholdSplit *split = [RFSMatchFacesSimilarityThresholdSplit splitPairs:array bySimilarityThreshold:similarity];
+    callback([RFSWJSONConstructor generateComparedFacesSplit:split]);
+}
+
++(void)detectFaces:(NSDictionary*)request :(RFSWCallback)callback {
+    [RFSFaceSDK.service detectFacesByRequest:[RFSWJSONConstructor detectFacesRequestFromJSON:request]
+                                  completion:[self detectFacesCompletion:callback]];
+}
+
++(void)createPerson:(NSString*)name :(NSArray<NSString*>*)groupIds :(NSDictionary*)metadata :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase createPersonWithName:name
+                                                   metadata:metadata
+                                                   groupIds:groupIds
+                                                 completion:[self databaseItemCompletion :callback :@selector(generatePerson:)]];
+}
+
++(void)updatePerson:(NSDictionary*)person :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonByPersonId:[RFSWJSONConstructor idFromJSON:person] completion:^(RFSItemResponse<RFSPerson *> * response) {
+        if (response.error) callback([RFSWJSONConstructor generatePersonDBResponse:nil :response.error]);
+        else [RFSFaceSDK.service.personDatabase updatePerson:[RFSWJSONConstructor updatePersonFromJSON:response.item :person]
+                                                 completion:[self databaseCompletion:callback]];
+    }];
+}
+
++(void)deletePerson:(NSString*)personId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase deletePersonByPersonId:personId
+                                                   completion:[self databaseCompletion:callback]];
+}
+
++(void)getPerson:(NSString*)personId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonByPersonId:personId
+                                                completion:[self databaseItemCompletion :callback :@selector(generatePerson:)]];
+}
+
++(void)addPersonImage:(NSString*)personId :(NSDictionary*)image :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase addPersonImageByPersonId:personId
+                                                    imageUpload:[RFSWJSONConstructor imageUploadFromJSON:image]
+                                                     completion:[self databaseItemCompletion :callback :@selector(generatePersonImage:)]];
+}
+
++(void)deletePersonImage:(NSString*)personId :(NSString*)imageId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase deletePersonImageByPersonId:personId
+                                                           imageId: imageId
+                                                        completion:[self databaseCompletion:callback]];
+}
+
++(void)getPersonImage:(NSString*)personId :(NSString*)imageId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonImageByPersonId:personId imageId:imageId completion:^(RFSDataResponse* response) {
+        callback([RFSWJSONConstructor generatePersonDBResponse:[RFSWJSONConstructor base64Encode:response.data] :response.error]);
+    }];
+}
+
++(void)getPersonImages:(NSString*)personId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonImagesByPersonId:personId
+                                                      completion:[self databasePageCompletion :callback :@selector(generatePersonImage:)]];
+}
+
++(void)getPersonImagesForPage:(NSString*)personId :(NSNumber*)page :(NSNumber*)size :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonImagesByPersonId:personId
+                                                            page:[page integerValue]
+                                                            size:[size integerValue]
+                                                      completion:[self databasePageCompletion :callback :@selector(generatePersonImage:)]];
+}
+
++(void)createGroup:(NSString*)name :(NSDictionary*)metadata :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase createGroupWithName:name
+                                                  metadata:metadata
+                                                completion:[self databaseItemCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)updateGroup:(NSDictionary*)group :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroupByGroupId:[RFSWJSONConstructor idFromJSON:group] completion:^(RFSItemResponse<RFSPersonGroup *> * response) {
+        if (response.error) callback([RFSWJSONConstructor generatePersonDBResponse:nil :response.error]);
+        else [RFSFaceSDK.service.personDatabase updateGroup:[RFSWJSONConstructor updatePersonGroupFromJSON:response.item :group]
+                                                 completion:[self databaseCompletion:callback]];
+    }];
+}
+
++(void)editPersonsInGroup:(NSString*)groupId :(NSDictionary*)editGroupPersonsRequest :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase editGroupPersonsByGroupId:groupId
+                                                         request:[RFSWJSONConstructor editGroupPersonsRequestFromJSON:editGroupPersonsRequest]
+                                                      completion:[self databaseCompletion:callback]];
+}
+
++(void)deleteGroup:(NSString*)groupId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase deleteGroupByGroupId:groupId
+                                                 completion:[self databaseCompletion:callback]];
+}
+
++(void)getGroup:(NSString*)groupId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroupByGroupId:groupId
+                                              completion:[self databaseItemCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)getGroups:(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroups:[self databasePageCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)getGroupsForPage:(NSNumber*)page :(NSNumber*)size :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroupsForPage:[page integerValue]
+                                                   size:[size integerValue]
+                                             completion:[self databasePageCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)getPersonGroups:(NSString*)personId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonGroupsByPersonId:personId
+                                                      completion:[self databasePageCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)getPersonGroupsForPage:(NSString*)personId :(NSNumber*)page :(NSNumber*)size :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonGroupsByPersonId:personId
+                                                            page:[page integerValue]
+                                                            size:[size integerValue]
+                                                      completion:[self databasePageCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)getPersonsInGroup:(NSString*)groupId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroupPersonsByGroupId:groupId
+                                                     completion:[self databasePageCompletion :callback :@selector(generatePerson:)]];
+}
+
++(void)getPersonsInGroupForPage:(NSString*)groupId :(NSNumber*)page :(NSNumber*)size :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroupPersonsByGroupId:groupId
+                                                           page:[page integerValue]
+                                                           size:[size integerValue]
+                                                     completion:[self databasePageCompletion :callback :@selector(generatePerson:)]];
+}
+
++(void)searchPerson:(NSDictionary*)searchPersonRequest :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase searchPerson:[RFSWJSONConstructor searchPersonRequestFromJSON:searchPersonRequest]
+                                         completion:^(RFSSearchPersonResponse *response) {
+        callback([RFSWJSONConstructor generatePersonDBResponse:[RFSWJSONConstructor generateArray:response.results :@selector(generateSearchPerson:)] :response.error]);
+    }];
+}
+
++(RFSInitializationCompletion)initCompletion:(RFSWCallback)callback {
+    return ^(BOOL success, NSError* error) {
+        RFSFaceSDK.service.customization.configuration = [RFSUIConfiguration defaultConfiguration];
+        [RFSFaceSDK.service setVideoUploadingDelegate:this];
+        [RFSFaceSDK.service setFaceCaptureDelegate:this];
+        [RFSFaceSDK.service setLivenessDelegate:this];
+        RFSFaceSDK.service.customization.actionDelegate = this;
+        callback([RFSWJSONConstructor generateInitCompletion:success :error]);
+    };
+}
+
++(void (^)(RFSFaceCaptureResponse*)) faceCaptureCompletion:(RFSWCallback)callback {
+    return ^(RFSFaceCaptureResponse* response) {
+        callback([RFSWJSONConstructor generateFaceCaptureResponse:response]);
+    };
+}
+
++(void (^)(RFSLivenessResponse*)) livenessCompletion:(RFSWCallback)callback {
+    return ^(RFSLivenessResponse* response) {
+        callback([RFSWJSONConstructor generateLivenessResponse:response]);
+    };
+}
+
++(void (^)(RFSMatchFacesResponse*)) matchFacesCompletion:(RFSWCallback)callback {
+    return ^(RFSMatchFacesResponse* response) {
+        callback([RFSWJSONConstructor generateMatchFacesResponse:response]);
+    };
+}
+
++(void (^)(RFSDetectFacesResponse*)) detectFacesCompletion:(RFSWCallback)callback {
+    return ^(RFSDetectFacesResponse* response) {
+        callback([RFSWJSONConstructor generateDetectFacesResponse:response]);
+    };
+}
+
++(void (^)(RFSComfirmResponse *response))databaseCompletion:(RFSWCallback)callback {
+    return ^(RFSComfirmResponse *response) {
+        callback([RFSWJSONConstructor generatePersonDBResponse:@YES :response.error]);
+    };
+}
+
++(void (^)(RFSItemResponse<RFSDBBaseItem *> *response))databaseItemCompletion:(RFSWCallback)callback :(SEL)toJson {
+    return ^(RFSItemResponse<RFSDBBaseItem *> *response) {
+        callback([RFSWJSONConstructor generatePersonDBResponse:[RFSWJSONConstructor performSelector:toJson withObject:response.item] :response.error]);
+    };
+}
+
++(void (^)(RFSPageResponse<RFSDBBaseItem *> *response))databasePageCompletion:(RFSWCallback)callback :(SEL)toJson {
+    return ^(RFSPageResponse<RFSDBBaseItem *> *response) {
+        callback([RFSWJSONConstructor generatePersonDBResponse:@{
+            @"items": [RFSWJSONConstructor generateArray:response.items :toJson],
+            @"page": @(response.page),
+            @"totalPages": @(response.totalPages),
+        } :response.error]);
+    };
+}
+
+// RFSFaceCaptureDelegate & RFSLivenessDelegate
+-(void)cameraPositionChanged:(RFSCameraPosition)cameraPosition {
+    sendEvent(cameraSwitchEvent, @(cameraPosition));
+}
+
+// RFSLivenessDelegate
+-(void)processStatusChanged:(RFSLivenessProcessStatus)status result:(RFSLivenessResponse*)result {
+    sendEvent(livenessNotificationEvent, [RFSWJSONConstructor generateLivenessNotification:status result:result]);
+}
+
+// RFSVideoUploadingDelegate
+-(void)videoUploadingForTransactionId:(NSString*)transactionId didFinishedWithSuccess:(BOOL)success {
+    sendEvent(videoEncoderCompletionEvent, [RFSWJSONConstructor generateVideoEncoderCompletion:transactionId :success]);
+}
+
+// RFSCustomizationActionDelegate
+-(void)onFaceCustomButtonTappedWithTag:(NSInteger)tag {
+    sendEvent(onCustomButtonTappedEvent, @(tag));
+}
+
+@end

package/ios/RNFaceSDK.h

@@ -0,0 +1,8 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTUtils.h>
+#import "RFSWMain.h"
+@import UIKit;
+
+@interface RNFaceSDK : RCTEventEmitter <RCTBridgeModule>
+@end

package/ios/RNFaceSDK.m

@@ -1,11 +1,43 @@
-#import <React/RCTEventEmitter.h>
-#import <React/RCTBridgeModule.h>
+#import "RNFaceSDK.h"
 
-@interface RCT_EXTERN_MODULE(RNFaceSDK, RCTEventEmitter)
+@implementation RNFaceSDK
+RCT_EXPORT_MODULE();
 
-RCT_EXTERN_METHOD(exec: (NSString*)method
-                  newArgs:(NSArray*)newArgs
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
+static NSMutableArray<RCTResponseSenderBlock>* _firedCallbacks = nil;
+- (NSMutableArray<RCTResponseSenderBlock>*)firedCallbacks {
+    if (_firedCallbacks == nil) _firedCallbacks = @[].mutableCopy;
+    return _firedCallbacks;
+}
+
+- (NSArray<NSString*>*)supportedEvents {
+    return @[cameraSwitchEvent,
+             livenessNotificationEvent,
+             videoEncoderCompletionEvent,
+             onCustomButtonTappedEvent];
+}
+
+static bool hasListeners;
+- (void)startObserving { hasListeners = YES; }
+- (void)stopObserving { hasListeners = NO; }
+
+UIViewController*(^RFSWRootViewController)(void) = ^UIViewController*(){
+    return RCTPresentedViewController();
+};
+
+RCT_EXPORT_METHOD(exec:(NSString*)method:(NSArray*)args:(RCTPromiseResolveBlock)resolve:(RCTPromiseRejectBlock)reject) {
+    RFSWCallback callback = ^(id _Nullable data) {
+        if ([self.firedCallbacks containsObject:resolve]) return;
+        [self.firedCallbacks addObject:resolve];
+        resolve([RFSWJSONConstructor toSendable:data]);
+    };
+    
+    RFSWEventSender sendEvent = ^(NSString* event, id data) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            if (hasListeners) [self sendEventWithName:event body:[RFSWJSONConstructor toSendable:data]];
+        });
+    };
+    
+    [RFSWMain methodCall:method :args :callback :sendEvent];
+}
 
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@regulaforensics/face-sdk",
-  "version": "8.2.855-nightly",
+  "version": "8.2.856-rc",
   "description": "This is an npm module for Regula Face SDK. It allows you to easily compaire faces using your phone's camera.",
   "main": "www/react-native/index.js",
   "module": "www/capacitor/index.js",

package/plugin.xml

@@ -1,5 +1,5 @@
 <?xml version='1.0' encoding='utf-8'?>
-<plugin id="@regulaforensics/face-sdk" version="8.2.855-nightly" xmlns="http://apache.org/cordova/ns/plugins/1.0">
+<plugin id="@regulaforensics/face-sdk" version="8.2.856-rc" xmlns="http://apache.org/cordova/ns/plugins/1.0">
   <name>FaceSDK</name>
   <description>Cordova plugin for Regula Face SDK</description>
   <license>commercial</license>
@@ -12,22 +12,24 @@
   <platform name="ios">
     <config-file target="config.xml" parent="/widget">
       <feature name="FaceSDK">
-        <param name="ios-package" value="CDVFaceSDK" />
+        <param name="ios-package" value="CVDFaceSDK" />
       </feature>
       <preference name="deployment-target" value="13.0" />
-      <preference name="SwiftVersion" value="5" />
     </config-file>
-    <source-file src="ios/CDVFaceSDK.swift" />
-    <source-file src="ios/Main.swift" />
-    <source-file src="ios/Decoder.swift" />
-    <source-file src="ios/Config.swift" />
-    <source-file src="ios/Utils.swift" />
+    <header-file src="ios/CVDFaceSDK.h" />
+    <source-file src="ios/CVDFaceSDK.m" />
+    <header-file src="ios/RFSWMain.h" />
+    <source-file src="ios/RFSWMain.m" />
+    <header-file src="ios/RFSWJSONConstructor.h" />
+    <source-file src="ios/RFSWJSONConstructor.m" />
+    <header-file src="ios/RFSWConfig.h" />
+    <source-file src="ios/RFSWConfig.m" />
     <podspec>
       <config>
         <source url="https://github.com/CocoaPods/Specs.git" />
       </config>
       <pods>
-        <pod name="FaceSDKNightly" spec="8.2.3862" />
+        <pod name="FaceSDKStage" spec="8.2.3864" />
       </pods>
     </podspec>
   </platform>
@@ -35,11 +37,11 @@
   <platform name="android">
     <config-file parent="/*" target="res/xml/config.xml">
       <feature name="FaceSDK">
-        <param name="android-package" value="com.regula.plugin.facesdk.CDVFaceSDK" />
+        <param name="android-package" value="com.regula.plugin.facesdk.CVDFaceSDK" />
       </feature>
     </config-file>
     <framework src="android/cordova.gradle" custom="true" type="gradleReference" />
-    <source-file src="android/CDVFaceSDK.kt" target-dir="java/com.regula.plugin.facesdk" />
+    <source-file src="android/CVDFaceSDK.kt" target-dir="java/com.regula.plugin.facesdk" />
     <source-file src="android/src/main/java/com/regula/plugin/facesdk/Main.kt" target-dir="java/com.regula.plugin.facesdk" />
     <source-file src="android/src/main/java/com/regula/plugin/facesdk/JSONConstructor.kt" target-dir="java/com.regula.plugin.facesdk" />
     <source-file src="android/src/main/java/com/regula/plugin/facesdk/Config.kt" target-dir="java/com.regula.plugin.facesdk" />

package/test/package-lock.json

@@ -13,7 +13,7 @@
     },
     "..": {
       "name": "@regulaforensics/face-sdk",
-      "version": "8.2.855-nightly",
+      "version": "8.2.856-rc",
       "dev": true,
       "license": "commercial"
     },

package/examples/ionic/patches/cordova-plugin-ionic-webview+5.0.1.patch

@@ -1,23 +0,0 @@
-diff --git a/node_modules/cordova-plugin-ionic-webview/src/ios/CDVWKWebViewEngine.m b/node_modules/cordova-plugin-ionic-webview/src/ios/CDVWKWebViewEngine.m
-index 2acb99b..900a04c 100644
---- a/node_modules/cordova-plugin-ionic-webview/src/ios/CDVWKWebViewEngine.m
-+++ b/node_modules/cordova-plugin-ionic-webview/src/ios/CDVWKWebViewEngine.m
-@@ -731,6 +731,18 @@ - (BOOL)defaultResourcePolicyForURL:(NSURL*)url
-         return YES;
-     }
- 
-+    // Allow internal local-server navigation even when no plugin overrides the request.
-+    NSURL *localServerUrl = [NSURL URLWithString:self.CDV_LOCAL_SERVER];
-+    if (localServerUrl != nil && url != nil) {
-+        NSString *localScheme = localServerUrl.scheme.lowercaseString;
-+        NSString *localHost = localServerUrl.host.lowercaseString;
-+        NSString *urlScheme = url.scheme.lowercaseString;
-+        NSString *urlHost = url.host.lowercaseString;
-+        if ([localScheme isEqualToString:urlScheme] && [localHost isEqualToString:urlHost]) {
-+            return YES;
-+        }
-+    }
-+
-     return NO;
- }
- 

package/ios/CDVFaceSDK.swift

@@ -1,42 +0,0 @@
-@objc(CDVFaceSDK)
-class CDVFaceSDK: CDVPlugin {
-    @objc(exec:)
-    func exec(_ command: CDVInvokedUrlCommand) {
-        this = self
-        let method = command.arguments.first as! String
-        args = Array(command.arguments.dropFirst())
-        
-        if method == "setEvent" {
-            eventCallbackIds[args.first as! String] = command.callbackId
-            return
-        }
-        
-        methodCall(method, { data in sendEvent(command.callbackId, data) })
-    }
-}
-
-var this: CDVFaceSDK?
-var eventCallbackIds: [String: String] = [:]
-func sendEvent(_ event: String, _ data: Any? = "") {
-    var callbackId = event
-    let eventId = eventCallbackIds[event]
-    if eventId != nil { callbackId = eventId! }
-    
-    // In this section unreasonable casts and optionals are made to
-    // ensure that this code works with both cordova-ios@7 and cordova-ios@8.
-    var sendable = data.toSendable()
-    if sendable is NSNull { sendable = "" }
-    let message = sendable as! String
-    let result: CDVPluginResult? = CDVPluginResult(status: CDVCommandStatus.ok, messageAs: message)
-    result!.setKeepCallbackAs(true)
-    
-    this!.commandDelegate.send(result!, callbackId: callbackId)
-}
-
-let rootViewController: () -> UIViewController? = {
-    return UIApplication.shared.connectedScenes
-        .compactMap { $0 as? UIWindowScene }
-        .flatMap { $0.windows }
-        .first { $0.isKeyWindow }?
-        .rootViewController
-}