uqudosdk-capacitor 2.2.1

package/ios/Plugin/UqudoId.m

@@ -0,0 +1,518 @@
+#import <Capacitor/Capacitor.h>
+#import <UqudoSDK/UqudoSDK.h>
+#import "MyTracer.h"
+
+@interface UqudoId : CAPPlugin<UQBuilderControllerDelegate> {}
+@property CAPPluginCall * pluginCall;
+@end
+
+@implementation UqudoId
+@synthesize pluginCall;
+
+- (void)init:(CAPPluginCall*)call {
+    MyTracer *tracer = [[MyTracer alloc] init];
+    tracer.bridge = self.bridge;
+    [[UQBuilderController alloc] initWithTracer:tracer];
+}
+
+- (void)setLocale:(CAPPluginCall*)call {
+    NSString* locale = call.options[@"value"];
+    NSLog(@"%@", locale);
+    [[NSUserDefaults standardUserDefaults] setObject:[NSArray arrayWithObjects:locale, nil]forKey:@"AppleLanguages"];
+    [[NSUserDefaults standardUserDefaults] synchronize];
+}
+
+- (void)enroll:(CAPPluginCall*)call
+{
+    self.pluginCall = call;
+    NSString* enrollObj = call.options[@"value"];
+    @try {
+        if (enrollObj != nil && [enrollObj length] > 0) {
+            NSData* data = [enrollObj dataUsingEncoding:NSUTF8StringEncoding];
+            id json = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
+
+            NSString* authorizationToken = json[@"authorizationToken"];
+            NSString* nonce = json[@"nonce"];
+            NSDictionary* documentList = json[@"documentList"];
+            NSDictionary* facialRecognitionSpecification = json[@"facialRecognitionSpecification"];
+            NSDictionary* backgroundCheckConfiguration = json[@"backgroundCheckConfiguration"];
+            NSDictionary* lookupConfiguration = json[@"lookupConfiguration"];
+
+            // Config enrollment builder
+            UQEnrollmentBuilder *enrollmentBuilder = [[UQEnrollmentBuilder alloc] init];
+            NSString* sessionId = json[@"sessionId"];
+            if (sessionId && sessionId.length > 0) {
+                [enrollmentBuilder setSessionID:sessionId];
+            }
+            NSString* userIdentifier = json[@"userIdentifier"];
+            if (userIdentifier && userIdentifier.length > 0) {
+                NSUUID *uuid = [[NSUUID UUID] initWithUUIDString:userIdentifier];
+                [enrollmentBuilder setUserIdentifier:uuid];
+            }
+            if (json[@"isRootedDeviceAllowed"]) {
+                enrollmentBuilder.isRootedDeviceAllowed = [[json valueForKey:@"isRootedDeviceAllowed"] boolValue];
+            }
+            if (json[@"isReturnDataForIncompleteSession"]) {
+                enrollmentBuilder.returnDataForIncompleteSession = [[json valueForKey:@"isReturnDataForIncompleteSession"] boolValue];
+            }
+            if (facialRecognitionSpecification) {
+                // Enable help page for face recognition
+                enrollmentBuilder.enableFacialRecognition = TRUE;
+
+                // Enable enroll face option
+                if (facialRecognitionSpecification[@"enrollFace"]) {
+                    enrollmentBuilder.enrollFace = [[facialRecognitionSpecification valueForKey:@"enrollFace"] boolValue];
+                }
+
+                if (facialRecognitionSpecification[@"scanMinimumMatchLevel"]) {
+                    enrollmentBuilder.scanMinimumMatchLevel = [[facialRecognitionSpecification valueForKey:@"scanMinimumMatchLevel"] integerValue];
+                }
+
+                if (facialRecognitionSpecification[@"readMinimumMatchLevel"]) {
+                    enrollmentBuilder.readMinimumMatchLevel = [[facialRecognitionSpecification valueForKey:@"readMinimumMatchLevel"] integerValue];
+                }
+
+                if (facialRecognitionSpecification[@"maxAttempts"]) {
+                   int maxAttempts = [[facialRecognitionSpecification valueForKey:@"maxAttempts"] intValue];
+                   if (maxAttempts > 0) {
+                      enrollmentBuilder.facialRecognitionMaxAttempts = maxAttempts;
+                   }
+                }
+
+            }
+
+            if(lookupConfiguration){
+                NSMutableArray *lookupDocumentTypes = [[NSMutableArray alloc] init];
+                 if(lookupConfiguration[@"documentList"]){
+                    for (NSString *document in lookupConfiguration[@"documentList"]) {
+                         UQDocumentConfig *documentConfig = [[UQDocumentConfig alloc] initWithDocumentTypeName:document];
+                        [lookupDocumentTypes addObject:[NSNumber numberWithInteger:[documentConfig documentType]]];
+                      }
+                  }
+                  if (lookupDocumentTypes.count) {
+                       [enrollmentBuilder enableLookup:lookupDocumentTypes];
+                   }
+                   else {
+                        [enrollmentBuilder enableLookup];
+                     }
+            }
+
+            if (backgroundCheckConfiguration) {
+                BOOL isDisableConsent = FALSE;
+                if (backgroundCheckConfiguration[@"disableConsent"]) {
+                    isDisableConsent = [[backgroundCheckConfiguration valueForKey:@"disableConsent"] boolValue];
+                }
+                BOOL isMonitoringEnabled = FALSE;
+                if (backgroundCheckConfiguration[@"monitoringEnabled"]) {
+                    isMonitoringEnabled = [[backgroundCheckConfiguration valueForKey:@"monitoringEnabled"] boolValue];
+                }
+                BackgroundCheckType type = RDC;
+                if (backgroundCheckConfiguration[@"backgroundCheckType"]) {
+                    type = [backgroundCheckConfiguration[@"backgroundCheckType"]  isEqual: @"RDC"] ? RDC : DOW_JONES;
+                }
+                BOOL isSkipView = FALSE;
+                if (backgroundCheckConfiguration[@"skipView"]) {
+                    isSkipView = [[backgroundCheckConfiguration valueForKey:@"skipView"] boolValue];
+                }
+                [enrollmentBuilder enableBackgroundCheck:isDisableConsent type:type monitoring:isMonitoringEnabled skipView:isSkipView];
+            }
+            for (NSDictionary *document in documentList) {
+                NSString* documentType = document[@"documentType"];
+                UQDocumentConfig *documentObject = [[UQDocumentConfig alloc] initWithDocumentTypeName:documentType];
+                if(documentObject.documentType == UNSPECIFY){
+                    continue;
+                }
+
+                UQScanConfig *scanConfig = [[UQScanConfig alloc] init];
+                if (document[@"isHelpPageDisabled"]) {
+                    scanConfig.disableHelpPage = [[document valueForKey:@"isHelpPageDisabled"] boolValue];
+                }
+                if (document[@"faceScanMinimumMatchLevel"]) {
+                    scanConfig.faceMinimumMatchLevel = [[document valueForKey:@"faceScanMinimumMatchLevel"] intValue];
+                }
+                if (document[@"minimumAge"]) {
+                     int minimumAge = [[document valueForKey:@"minimumAge"] intValue];
+                     if (minimumAge > 0) {
+                         documentObject.enableAgeVerification = minimumAge;
+                     }
+                 }
+                BOOL isEnabelFrontSideReview = false;
+                BOOL isEnabelBackSideReview = false;
+
+                if (document[@"isFrontSideReviewEnabled"]) {
+                    isEnabelFrontSideReview = [[document valueForKey:@"isFrontSideReviewEnabled"] boolValue];
+                }
+                if (document[@"isBackSideReviewEnabled"]) {
+                    isEnabelBackSideReview = [[document valueForKey:@"isBackSideReviewEnabled"] boolValue];
+                }
+                [scanConfig enableScanReview:isEnabelFrontSideReview backSide:isEnabelBackSideReview];
+                if (document[@"isUploadEnabled"]) {
+                    scanConfig.enableUpload = [[document valueForKey:@"isUploadEnabled"] boolValue];
+                }
+                documentObject.scan = scanConfig;
+
+                if (document[@"isExpiredDocumentValidateDisabled"]) {
+                    documentObject.disableExpiryValidation = [[document valueForKey:@"isExpiredDocumentValidateDisabled"] boolValue];
+                }
+
+                if (document[@"readingConfiguration"]) {
+                    if (@available(iOS 13, *)) {
+                        NSDictionary *readingConfiguration = document[@"readingConfiguration"];
+
+                        UQReadingConfig *readConfig = [[UQReadingConfig alloc] init];
+                        readConfig.enableReading = TRUE;
+                        if (readingConfiguration[@"forceReading"]) {
+                            [readConfig forceReading:[[readingConfiguration valueForKey:@"forceReading"] boolValue]];
+                        }
+                        if (readingConfiguration[@"forceReadingIfSupported"]) {
+                            [readConfig forceReadingIfSupported:[[readingConfiguration valueForKey:@"forceReadingIfSupported"] boolValue]];
+                        }
+                        if (document[@"faceReadMinimumMatchLevel"]) {
+                            readConfig.faceMinimumMatchLevel = [[document valueForKey:@"faceReadMinimumMatchLevel"] intValue];
+                        }
+                        if (readingConfiguration[@"timeoutInSeconds"]) {
+                            int timeoutInSeconds = [[readingConfiguration valueForKey:@"timeoutInSeconds"] intValue];
+                            if (timeoutInSeconds > 0) {
+                                readConfig.forceReadingTimeout = timeoutInSeconds;
+                            }
+                        }
+
+                        documentObject.reading = readConfig;
+                    }
+                }
+
+                [enrollmentBuilder add:documentObject];
+            }
+            // Add enrollment to builder
+            UQBuilderController *builderController = [UQBuilderController defaultBuilder];
+            builderController.delegate = self;
+            [builderController setEnrollment:enrollmentBuilder];
+            // set appearanceMode to builder
+            NSInteger appearanceMode = SYSTEM;
+            if (json[@"appearanceMode"]) {
+            if ([json[@"appearanceMode"] isEqualToString:@"LIGHT"]) {
+                   appearanceMode = LIGHT;
+            } else if ([json[@"appearanceMode"] isEqualToString:@"DARK"]) {
+                    appearanceMode = DARK;
+                }
+            }
+            [builderController setAppearanceMode:appearanceMode];
+
+
+//            // Start enrollment flow
+//            // accessToken reuire, if no token the UQExceptionInvalidToken will throw
+            dispatch_async(dispatch_get_main_queue(), ^(void) {
+                    UIWindow *window = [UIApplication sharedApplication].keyWindow;
+                    UIViewController *rootViewController = window.rootViewController;
+                    builderController.appViewController = rootViewController;
+                    [builderController performEnrollmentWithToken:authorizationToken optionNonce:nonce];
+                });
+        } else {
+            UQSessionStatus *status =[[UQSessionStatus alloc] init];
+            status.statusCode = UNEXPECTED_ERROR;
+            status.message = @"Expected enrollment object as argument.";
+            status.statusTask = -1;
+            [self sendPluginError:status];
+        }
+    }
+    @catch (NSException *exception) {
+        NSLog(@"%@", exception.callStackSymbols);
+        UQSessionStatus *status =[[UQSessionStatus alloc] init];
+        status.statusCode = UNEXPECTED_ERROR;
+        status.message = exception.reason;
+        status.statusTask = -1;
+        [self sendPluginError:status];
+    }
+}
+
+- (void) didEnrollmentFailWithError:(NSError *)error {
+    NSLog(@"Error %ld %@", (long)error.code, error.localizedDescription);
+    UQSessionStatus *status =[[UQSessionStatus alloc] init];
+    status.statusCode = UNEXPECTED_ERROR;
+    status.message = error.localizedDescription;
+    status.statusTask = -1;
+    [self sendPluginError:status];
+}
+
+- (void) didEnrollmentCompleteWithInfo:(NSString *)jwsString {
+    CAPPluginCallResult *result = [[CAPPluginCallResult alloc]init:@{@"value":jwsString}];
+    pluginCall.successHandler(result, pluginCall);
+}
+
+- (void) didEnrollmentIncompleteWithStatus:(UQSessionStatus *)status {
+    [self sendPluginError:status];
+}
+
+- (void)recover:(CAPPluginCall*)call
+{
+    self.pluginCall = call;
+    NSString* recoverObj = call.options[@"value"];
+
+    @try {
+        if (recoverObj != nil && [recoverObj length] > 0) {
+            NSData *data = [recoverObj dataUsingEncoding:NSUTF8StringEncoding];
+            id json = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
+
+            // Config account recovery builder
+            UQAccountRecoveryBuilder *accountRecoveryBuilder = [[UQAccountRecoveryBuilder alloc] init];
+            accountRecoveryBuilder.authorizationToken = json[@"token"];
+            accountRecoveryBuilder.enrollmentIdentifier = json[@"enrollmentIdentifier"];
+            accountRecoveryBuilder.nonce = json[@"nonce"];
+            if (json[@"isRootedDeviceAllowed"]) {
+                accountRecoveryBuilder.isRootedDeviceAllowed = [[json valueForKey:@"isRootedDeviceAllowed"] boolValue];
+            }
+            if (json[@"minimumMatchLevel"]) {
+                accountRecoveryBuilder.minimumMatchLevel = [[json valueForKey:@"minimumMatchLevel"] intValue];
+            }
+
+            if (json[@"maxAttempts"]) {
+                int maxAttempts = [[json valueForKey:@"maxAttempts"] intValue];
+                if (maxAttempts > 0) {
+                    accountRecoveryBuilder.maxAttempts = maxAttempts;
+                }
+            }
+
+            if (json[@"isReturnDataForIncompleteSession"]) {
+                accountRecoveryBuilder.returnDataForIncompleteSession = [[json valueForKey:@"isReturnDataForIncompleteSession"] boolValue];
+            }
+
+            UQBuilderController *builderController = [UQBuilderController defaultBuilder];
+            builderController.delegate = self;
+            [builderController setAccountRecovery:accountRecoveryBuilder];
+            NSInteger appearanceMode = SYSTEM;
+            if (json[@"appearanceMode"]) {
+            if ([json[@"appearanceMode"] isEqualToString:@"LIGHT"]) {
+                   appearanceMode = LIGHT;
+            } else if ([json[@"appearanceMode"] isEqualToString:@"DARK"]) {
+                    appearanceMode = DARK;
+                }
+            }
+            [builderController setAppearanceMode:appearanceMode];
+
+
+            dispatch_async(dispatch_get_main_queue(), ^(void) {
+                    UIWindow *window = [UIApplication sharedApplication].keyWindow;
+                    UIViewController *rootViewController = window.rootViewController;
+                    builderController.appViewController = rootViewController;
+                    [builderController performAccountRecovery];
+                });
+        } else {
+            UQSessionStatus *status =[[UQSessionStatus alloc] init];
+            status.statusCode = UNEXPECTED_ERROR;
+            status.message = @"Expected account recovery object as argument.";
+            status.statusTask = -1;
+            [self sendPluginError:status];
+        }
+    }
+    @catch (NSException *exception) {
+        NSLog(@"%@", exception.callStackSymbols);
+        UQSessionStatus *status =[[UQSessionStatus alloc] init];
+        status.statusCode = UNEXPECTED_ERROR;
+        status.message = exception.reason;
+        status.statusTask = -1;
+        [self sendPluginError:status];
+    }
+}
+
+- (void)didAccountRecoveryCompleteWithInfo:(nonnull NSString *)jwsString {
+    CAPPluginCallResult *result = [[CAPPluginCallResult alloc]init:@{@"value":jwsString}];
+    pluginCall.successHandler(result, pluginCall);
+}
+
+- (void)didAccountRecoveryFailWithError:(nonnull NSError *)error {
+    NSLog(@"Error %ld %@", (long)error.code, error.localizedDescription);
+    UQSessionStatus *status =[[UQSessionStatus alloc] init];
+    status.statusCode = UNEXPECTED_ERROR;
+    status.message = error.localizedDescription;
+    status.statusTask = -1;
+    [self sendPluginError:status];
+}
+
+- (void)didAccountRecoveryIncompleteWithStatus:(UQSessionStatus *)status {
+    [self sendPluginError:status];
+}
+
+- (void)sendPluginError:(UQSessionStatus *)status {
+    NSString *code = nil;
+    switch (status.statusCode) {
+        case USER_CANCEL:
+            code = @"USER_CANCEL";
+            break;
+        case SESSION_EXPIRED:
+            code = @"SESSION_EXPIRED";
+            break;
+        case UNEXPECTED_ERROR:
+            code = @"UNEXPECTED_ERROR";
+            break;
+        case SESSION_INVALIDATED_CHIP_VALIDATION_FAILED:
+            code = @"SESSION_INVALIDATED_CHIP_VALIDATION_FAILED";
+            break;
+        case SESSION_INVALIDATED_READING_NOT_SUPPORTED:
+            code = @"SESSION_INVALIDATED_READING_NOT_SUPPORTED";
+            break;
+        case SESSION_INVALIDATED_READING_INVALID_DOCUMENT:
+            code = @"SESSION_INVALIDATED_READING_INVALID_DOCUMENT";
+            break;
+        case SESSION_INVALIDATED_FACE_RECOGNITION_TOO_MANY_ATTEMPTS:
+            code = @"SESSION_INVALIDATED_FACE_RECOGNITION_TOO_MANY_ATTEMPTS";
+            break;
+    }
+    NSString *task = nil;
+    switch (status.statusTask) {
+        case SCAN:
+            task = @"SCAN";
+            break;
+        case READING:
+            task = @"READING";
+            break;
+        case FACE:
+            task = @"FACE";
+            break;
+        case BACKGROUND_CHECK:
+            task = @"BACKGROUND_CHECK";
+            break;
+    }
+    NSMutableDictionary *error = [[NSMutableDictionary alloc]init];
+    [error setValue:code forKey:@"code"];
+    [error setValue:status.message forKey:@"message"];
+    [error setValue:task forKey:@"task"];
+    [error setValue:status.data forKey:@"data"];
+
+    NSError *err = nil;
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:error options:NSJSONWritingPrettyPrinted error:&err];
+
+    NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
+    CAPPluginCallError *capError = [[CAPPluginCallError alloc]init:@"" code:jsonString error:nil data:@{}];
+    pluginCall.errorHandler(capError);
+//    pluginCall.reject(jsonString, nil, nil);
+}
+
+- (void)faceSession:(CAPPluginCall*)call
+{
+    self.pluginCall = call;
+    NSString* recoverObj = call.options[@"value"];
+
+    @try {
+        if (recoverObj != nil && [recoverObj length] > 0) {
+            NSData *data = [recoverObj dataUsingEncoding:NSUTF8StringEncoding];
+            id json = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
+
+            UQFaceSessionBuilder *faceSessionBuilder = [[UQFaceSessionBuilder alloc] init];
+            faceSessionBuilder.authorizationToken = json[@"token"];
+            faceSessionBuilder.sessionId = json[@"sessionId"];
+            faceSessionBuilder.nonce = json[@"nonce"];
+            if (json[@"isRootedDeviceAllowed"]) {
+                faceSessionBuilder.isRootedDeviceAllowed = [[json valueForKey:@"isRootedDeviceAllowed"] boolValue];
+            }
+            if (json[@"minimumMatchLevel"]) {
+                faceSessionBuilder.minimumMatchLevel = [[json valueForKey:@"minimumMatchLevel"] intValue];
+            }
+
+            if (json[@"maxAttempts"]) {
+                int maxAttempts = [[json valueForKey:@"maxAttempts"] intValue];
+                if (maxAttempts > 0) {
+                    faceSessionBuilder.maxAttempts = maxAttempts;
+                }
+            }
+
+            if (json[@"isReturnDataForIncompleteSession"]) {
+                faceSessionBuilder.returnDataForIncompleteSession = [[json valueForKey:@"isReturnDataForIncompleteSession"] boolValue];
+            }
+
+            UQBuilderController *builderController = [UQBuilderController defaultBuilder];
+            builderController.delegate = self;
+            UIViewController *rootViewController = [UIApplication sharedApplication].delegate.window.rootViewController;
+            builderController.appViewController = rootViewController;
+            [builderController setFaceSession:faceSessionBuilder];
+
+            NSInteger appearanceMode = SYSTEM;
+            if (json[@"appearanceMode"]) {
+                if ([json[@"appearanceMode"] isEqualToString:@"LIGHT"]) {
+                    appearanceMode = LIGHT;
+                } else if ([json[@"appearanceMode"] isEqualToString:@"DARK"]) {
+                    appearanceMode = DARK;
+                }
+            }
+            [builderController setAppearanceMode:appearanceMode];
+
+            [builderController performFaceSession];
+        } else {
+            UQSessionStatus *status =[[UQSessionStatus alloc] init];
+            status.statusCode = UNEXPECTED_ERROR;
+            status.message = @"Expected face session configuration as argument.";
+            status.statusTask = -1;
+            [self sendPluginError:status];
+        }
+    }
+    @catch (NSException *exception) {
+        NSLog(@"%@", exception.callStackSymbols);
+        UQSessionStatus *status =[[UQSessionStatus alloc] init];
+        status.statusCode = UNEXPECTED_ERROR;
+        status.message = exception.reason;
+        status.statusTask = -1;
+        [self sendPluginError:status];
+
+    }
+}
+
+- (void)didFaceSessionCompleteWithInfo:(nonnull NSString *)jwsString {
+    CAPPluginCallResult *result = [[CAPPluginCallResult alloc]init:@{@"value":jwsString}];
+    pluginCall.successHandler(result, pluginCall);
+}
+
+- (void)didFaceSessionFailWithError:(nonnull NSError *)error {
+    NSLog(@"Error %ld %@", (long)error.code, error.localizedDescription);
+    UQSessionStatus *status =[[UQSessionStatus alloc] init];
+    status.statusCode = UNEXPECTED_ERROR;
+    status.message = error.localizedDescription;
+    status.statusTask = -1;
+    [self sendPluginError:status];
+}
+
+- (void)didFaceSessionIncompleteWithStatus:(UQSessionStatus *)status {
+    [self sendPluginError:status];
+}
+@end
+
+@implementation MyTracer
+
+- (void)trace:(UQTrace *)trace {
+    NSMutableDictionary* parameters = [[NSMutableDictionary alloc] init];
+
+    if(nil != trace.sessionId){
+        [parameters setValue:trace.sessionId forKey:@"sessionId"];
+    }
+    [parameters setValue:trace.event->name forKey:@"event"];
+    [parameters setValue:trace.status->name forKey:@"status"];
+
+    NSString *timeStamp = [self timeStamp:trace.timestamp];
+    [parameters setValue:timeStamp forKey:@"timestamp"];
+
+    if (TP_NULL != trace.page) {
+        [parameters setValue:trace.page->name forKey:@"page"];
+    }
+    if (TSC_NULL != trace.statusCode) {
+        [parameters setValue:trace.statusCode->name forKey:@"statusCode"];
+    }
+    if (trace.documentType != UNSPECIFY) {
+        UQDocumentConfig *document = [[UQDocumentConfig alloc] initWithDocumentType:trace.documentType];
+        [parameters setValue:document.documentName forKey:@"documentType"];
+    }
+    if (trace.statusMessage) {
+        [parameters setValue:trace.statusMessage forKey:@"statusMessage"];
+    }
+
+    NSError *err = nil;
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:parameters options:NSJSONWritingPrettyPrinted error:&err];
+
+    NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
+    [self.bridge triggerWindowJSEventWithEventName:@"TraceEvent" data:jsonString];
+}
+
+- (NSString *)timeStamp:(NSDate *)currentDate {
+    return [NSDateFormatter localizedStringFromDate:currentDate
+                                            dateStyle:NSDateFormatterFullStyle
+                                            timeStyle:NSDateFormatterFullStyle];
+}
+
+@end

package/ios/Plugin/UqudoIdPlugin.h

@@ -0,0 +1,10 @@
+#import <UIKit/UIKit.h>
+
+//! Project version number for Plugin.
+FOUNDATION_EXPORT double PluginVersionNumber;
+
+//! Project version string for Plugin.
+FOUNDATION_EXPORT const unsigned char PluginVersionString[];
+
+// In this header, you should import all the public headers of your framework using statements like #import <Plugin/PublicHeader.h>
+

package/ios/Plugin/UqudoIdPlugin.m

@@ -0,0 +1,12 @@
+#import <Foundation/Foundation.h>
+#import <Capacitor/Capacitor.h>
+
+// Define the plugin using the CAP_PLUGIN Macro, and
+// each method the plugin supports using the CAP_PLUGIN_METHOD macro.
+CAP_PLUGIN(UqudoId, "UqudoId",
+           CAP_PLUGIN_METHOD(init, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(setLocale, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(enroll, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(recover, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(faceSession, CAPPluginReturnPromise);
+)

package/ios/Plugin/UqudoIdPlugin.swift

@@ -0,0 +1,11 @@
+import Foundation
+import Capacitor
+
+/**
+ * Please read the Capacitor iOS Plugin Development Guide
+ * here: https://capacitorjs.com/docs/plugins/ios
+ */
+@objc(UqudoIdPlugin)
+public class UqudoIdPlugin: CAPPlugin {
+    
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "uqudosdk-capacitor",
+  "version": "2.2.1",
+  "description": "Capacitor plugin for UqudoSDK",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "homepage": "https://uqudo.com",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Plugin/",
+    "UqudosdkCapacitor.podspec"
+  ],
+  "author": "uqudo",
+  "license": "MIT",
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}