@microblink/blinkid-react-native 7.7.0 → 8001.0.0

package/ios/BlinkidReactNative.mm

@@ -1,5 +1,6 @@
 #import "BlinkidReactNative.h"
 #import "BlinkidReactNative-Swift.h"
+#import <React/RCTUtils.h>
 
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <BlinkidReactNativeSpec/BlinkidReactNativeSpec.h>
@@ -43,64 +44,52 @@ RCT_EXPORT_METHOD(unloadBlinkIdSdk:(BOOL)deleteCachedResources
     }];
 }
 
-RCT_EXPORT_METHOD(performScan:(NSString *)blinkIdSdkSettings
-                  blinkIdSessionSettings:(NSString *)blinkIdSessionSettings
-                  blinkIdScanningUxSettings:(NSString *)blinkIdScanningUxSettings
-                  classFilter:(NSString *)classFilter
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-{
+RCT_EXPORT_METHOD(performDirectApiScan:(nonnull NSString *)blinkIdSdkSettings blinkIdSessionSettings:(nonnull NSString *)blinkIdSessionSettings firstImage:(nonnull NSString *)firstImage secondImage:(nonnull NSString *)secondImage redactionSettings:(nonnull NSString *)redactionSettings resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject) {
+    [self->moduleImplementation
+     performDirectApiScanWithBlinkIdSdkSettings: [self createDictionaryFromBlinkIdObject: blinkIdSdkSettings]
+     blinkIdSessionSettings: [self createDictionaryFromBlinkIdObject: blinkIdSessionSettings]
+     redactionSettings: [self createDictionaryFromBlinkIdObject:redactionSettings]
+     firstImage:firstImage
+     secondImage:secondImage
+     onResolve:^(NSString * _Nonnull result) {
+        resolve(result);
+    } onReject:^(NSString * _Nonnull error) {
+        reject(@"BlinkIdIosError", error, nil);
+    }];
+}
+
+RCT_EXPORT_METHOD(refreshLicenseLease:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self->moduleImplementation refreshLicenseLeaseOnResolve:^(NSString * _Nonnull) {
+        resolve(@"");
+    } onReject:^(NSString * _Nonnull error) {
+        reject(@"BlinkIdIosError", error, nil);
+    }];
+}
+
+RCT_EXPORT_METHOD(performScan:(NSString *)blinkIdSdkSettings blinkIdSessionSettings:(NSString *)blinkIdSessionSettings blinkIdScanningUxSettings:(NSString *)blinkIdScanningUxSettings classFilter:(NSString *)classFilter redactionSettingsResolver:(NSString *)redactionSettingsResolver resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
     dispatch_async(dispatch_get_main_queue(), ^{
-        UIWindow *keyWindow = nil;
-        
-        for (UIWindowScene *scene in [UIApplication sharedApplication].connectedScenes) {
-            if (scene.activationState == UISceneActivationStateForegroundActive &&
-                [scene isKindOfClass:[UIWindowScene class]]) {
-                for (UIWindow *window in scene.windows) {
-                    if (window.isKeyWindow) {
-                        keyWindow = window;
-                        break;
-                    }
-                }
-            }
-            if (keyWindow) {
-                break;
-            }
+        UIViewController *rootViewController = RCTPresentedViewController();
+        if (rootViewController == nil) {
+            reject(@"BlinkIdIosError", @"No view controller is available to present the BlinkID scanning UI.", nil);
+            return;
         }
-        
+
         [self->moduleImplementation
-         performScan:keyWindow.rootViewController
+         performScan:rootViewController
          blinkIdSdkSettings:[self createDictionaryFromBlinkIdObject:blinkIdSdkSettings]
          blinkIdSessionSettings:[self createDictionaryFromBlinkIdObject:blinkIdSessionSettings]
          blinkIdScanningUxSettings:[self createDictionaryFromBlinkIdObject:blinkIdScanningUxSettings]
          classFilterSettings:[self createDictionaryFromBlinkIdObject:classFilter]
+         redactionSettingsResolver: [self createDictionaryFromBlinkIdObject:redactionSettingsResolver]
          onResolve:^(NSString * _Nonnull result) {
-            resolve(@[result]);
+            resolve(result);
         } onReject:^(NSString * _Nonnull error) {
-            reject(@"BlinkIdIosError", error, nil);
+            NSString *message = error.length > 0 ? error : @"Unknown BlinkID iOS error.";
+            reject(@"BlinkIdIosError", message, nil);
         }];
     });
 }
 
-RCT_EXPORT_METHOD(performDirectApiScan:(NSString *)blinkIdSdkSettings
-                  blinkIdSessionSettings:(NSString *)blinkIdSessionSettings
-                  firstImage:(NSString *)firstImage
-                  secondImage:(NSString *)secondImage
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-{
-    [self->moduleImplementation
-     performDirectApiScanWithBlinkIdSdkSettings: [self createDictionaryFromBlinkIdObject: blinkIdSdkSettings]
-     blinkIdSessionSettings: [self createDictionaryFromBlinkIdObject: blinkIdSessionSettings]
-     firstImage:firstImage
-     secondImage:secondImage
-     onResolve:^(NSString * _Nonnull result) {
-        resolve(@[result]);
-    } onReject:^(NSString * _Nonnull error) {
-        reject(@"BlinkIdIosError", error, nil);
-    }];
-}
-
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params
@@ -111,16 +100,24 @@ RCT_EXPORT_METHOD(performDirectApiScan:(NSString *)blinkIdSdkSettings
 
 - (NSDictionary *)createDictionaryFromBlinkIdObject:(NSString *)jsonString
 {
-  NSError *jsonError;
+  if (jsonString == nil || jsonString.length == 0) {
+    return @{};
+  }
+
   NSData *data = [jsonString dataUsingEncoding:NSUTF8StringEncoding];
-  if (!data) {
-    return nil;
+  if (data == nil) {
+    return @{};
+  }
+
+  NSError *jsonError = nil;
+  id parsed = [NSJSONSerialization JSONObjectWithData:data
+                                              options:NSJSONReadingMutableContainers
+                                                error:&jsonError];
+  if (![parsed isKindOfClass:[NSDictionary class]]) {
+    return @{};
   }
 
-  NSDictionary *dict = [NSJSONSerialization JSONObjectWithData:data
-                                                       options:NSJSONReadingMutableContainers
-                                                         error:&jsonError];
-  return dict;
+  return (NSDictionary *)parsed;
 }
 
 @end

package/ios/BlinkidReactNativeModule.swift

@@ -12,10 +12,10 @@ import Combine
 import BlinkID
 import BlinkIDUX
 
-@objc public class BlinkidReactNativeModule: NSObject {
+@objc public final class BlinkidReactNativeModule: NSObject {
     
-    private var cancellables = Set<AnyCancellable>()
     private var classFilterDict: [String: Any]?
+    private var redactionSettingsResolverDict: [String: Any]?
     
     private var blinkIdSdk: BlinkIDSdk?
     
@@ -25,7 +25,7 @@ import BlinkIDUX
                 let _ = try await ensureLoadedSdk(blinkIdSdkSettings)
                 onResolve("")
             } catch {
-                onReject(error.localizedDescription)
+                onReject(BlinkIdReactNativeError.message(for: error))
             }
         }
     }
@@ -33,20 +33,21 @@ import BlinkIDUX
     private func ensureLoadedSdk(_ blinkIdSdkSettings: [String: Any]) async throws -> BlinkIDSdk? {
         if let blinkIdSdk = blinkIdSdk { return blinkIdSdk }
         do {
-            guard let settings = BlinkIdDeserializationUtilities.deserializeBlinkIdSdkSettings(blinkIdSdkSettings) else { throw BlinkIdReactNativeError.incorrectArgument(message: "Incorrect BlinkID SDK settings!") }
+            guard let settings = BlinkIdDeserializationUtils.deserializeBlinkIdSdkSettings(blinkIdSdkSettings) else {
+                throw BlinkIdReactNativeError.incorrectArgument("BlinkID SDK settings (licenseKey is required)")
+            }
             blinkIdSdk = try await BlinkIDSdk.createBlinkIDSdk(withSettings: settings)
             return blinkIdSdk
         } catch {
             blinkIdSdk = nil
             throw error
         }
-        return nil
     }
     
     @objc public func unloadSdk(_ deleteCachedResources: Bool, onResolve: @escaping (String) -> Void, onReject: @escaping (String) -> Void) {
         Task {
             if deleteCachedResources {
-               await BlinkIDSdk.terminateBlinkIDSdkAndDeleteCachedResources()
+                await BlinkIDSdk.terminateBlinkIDSdkAndDeleteCachedResources()
             } else {
                 await BlinkIDSdk.terminateBlinkIDSdk()
             }
@@ -55,110 +56,126 @@ import BlinkIDUX
         }
     }
     
-    @objc public func performScan(_ rootVc: UIViewController, blinkIdSdkSettings: [String: Any], blinkIdSessionSettings: [String: Any], blinkIdScanningUxSettings: [String: Any], classFilterSettings: [String: Any], onResolve: @escaping (String) -> Void, onReject: @escaping (String) -> Void) {
+    @objc public func performScan(_ rootVc: UIViewController, blinkIdSdkSettings: [String: Any], blinkIdSessionSettings: [String: Any], blinkIdScanningUxSettings: [String: Any], classFilterSettings: [String: Any], redactionSettingsResolver: [String: Any], onResolve: @escaping (String) -> Void, onReject: @escaping (String) -> Void) {
         Task {
             do {
-                
                 blinkIdSdk = try await ensureLoadedSdk(blinkIdSdkSettings)
                 guard let blinkIdSdk = blinkIdSdk else {
-                    onReject("The SDK is not loaded!")
-                    return
+                    throw BlinkIdReactNativeError.initError("The BlinkID SDK is not initialized. Call the loadBlinkIdSdk() method to pre-load the SDK first, or try running the performScan() method with a valid internet connection.")
                 }
-                let sessionSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdSessionSettings(blinkIdSessionSettings)
+                
+                let sessionSettings = BlinkIdDeserializationUtils.deserializeBlinkIdSessionSettings(blinkIdSessionSettings)
+                
                 classFilterDict = classFilterSettings
+                redactionSettingsResolverDict = redactionSettingsResolver
                 
                 let analyzer = try await BlinkIDAnalyzer(
                     sdk: blinkIdSdk,
                     blinkIdSessionSettings: sessionSettings,
                     eventStream: BlinkIDEventStream(),
-                    classFilter: self
+                    classFilter: self,
+                    redactionSettingsResolver: self
                 )
                 await addReactNativePinglet(with: analyzer.sessionNumber)
                 
                 let scanningUxModel = await BlinkIDUXModel(
                     analyzer: analyzer,
-                    uxSettings: BlinkIdDeserializationUtilities.deserializeBlinkIdUxScanningSettings(blinkIdScanningUxSettings)
-                )
-                
-                await scanningUxModel.$result
-                    .sink { [weak self] scanningResultState in
-                        if let scanningResultState {
-                            if let scanningResult = scanningResultState.scanningResult {
-                                DispatchQueue.main.async {
-                                    if let result = BlinkIdSerializationUtilities.serializeBlinkIdScanningResult(scanningResult) {
-                                        onResolve(result)
-                                        rootVc.dismiss(animated: true)
-                                    }
-                                }
-                            }
-                            else {
-                                Task {
-                                    await BlinkIDSdk.terminateBlinkIDSdk()
-                                }
-                                DispatchQueue.main.async {
-                                    onReject("Scanning has been canceled")
+                    uxSettings: BlinkIdDeserializationUtils.deserializeBlinkIdUxScanningSettings(blinkIdScanningUxSettings), onScanCompleted: { blinkIdState in
+                        if let scanningResult = blinkIdState.scanningResult {
+                            DispatchQueue.main.async {
+                                if let result = BlinkIdSerializationUtils.serializeBlinkIdScanningResult(scanningResult) {
+                                    onResolve(result)
                                     rootVc.dismiss(animated: true)
                                 }
-                                self?.cancellables.forEach{ $0.cancel() }
                             }
                         }
+                        else {
+                            Task { await BlinkIDSdk.terminateBlinkIDSdk() }
+                            DispatchQueue.main.async {
+                                onReject(BlinkIdReactNativeError.message(for: BlinkIdReactNativeError.scanningCancelled))
+                                rootVc.dismiss(animated: true)
+                            }
+                        }
+                        
                     }
-                    .store(in: &cancellables)
+                )
                 
                 self.presentScanningUI(scanningUxModel, rootVc)
+            } catch let blinkIdError as BlinkIdReactNativeError {
+                onReject(BlinkIdReactNativeError.message(for: blinkIdError))
             } catch {
                 if let sdkError = error as? InvalidLicenseKeyError {
                     onReject(sdkError.message)
                 } else {
-                    onReject(error.localizedDescription)
+                    onReject(BlinkIdReactNativeError.message(for: error))
                 }
             }
         }
     }
     
-    @objc public func performDirectApiScan(blinkIdSdkSettings: [String: Any], blinkIdSessionSettings: [String: Any], firstImage: String, secondImage: String?, onResolve: @escaping (String) -> Void, onReject: @escaping (String) -> Void) {
+    @objc public func performDirectApiScan(blinkIdSdkSettings: [String: Any], blinkIdSessionSettings: [String: Any], redactionSettings: [String: Any], firstImage: String, secondImage: String?, onResolve: @escaping (String) -> Void, onReject: @escaping (String) -> Void) {
         Task{
             do {
                 blinkIdSdk = try await ensureLoadedSdk(blinkIdSdkSettings)
                 guard let blinkIdSdk = blinkIdSdk else {
-                    onReject("The BlinkID SDK is not initialized!")
-                    return
+                    throw BlinkIdReactNativeError.initError("The BlinkID SDK is not initialized. Call the loadBlinkIdSdk() method to pre-load the SDK first, or try running the performDirectApiScan() method with a valid internet connection.")
                 }
-                var sessionSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdSessionSettings(blinkIdSessionSettings)
-                sessionSettings.inputImageSource = .photo
                 
+                let sessionSettings = BlinkIdDeserializationUtils.deserializeBlinkIdSessionSettings(blinkIdSessionSettings, isFromDirectApi: true)
                 let session = try await blinkIdSdk.createScanningSession(sessionSettings: sessionSettings)
                 
                 await addReactNativePinglet(with: session.getSessionNumber())
                 
-                guard let frontUIImage = BlinkIdDeserializationUtilities.deserializeBase64Image(firstImage) else {
-                    onReject("Could not extract the information from the first image! An image of a valid document needs to be sent.")
-                    return
+                guard let frontUIImage = BlinkIdDeserializationUtils.deserializeBase64Image(firstImage) else {
+                    throw BlinkIdReactNativeError.frontImageError
                 }
                 
-                await session.process(inputImage: InputImage(uiImage: frontUIImage))
+                let _ = try await session.process(inputImage: InputImage(uiImage: frontUIImage))
                 
-                if let backUIImage = BlinkIdDeserializationUtilities.deserializeBase64Image(secondImage) {
-                    await session.process(inputImage: InputImage(uiImage: backUIImage))
+                if let backUIImage = BlinkIdDeserializationUtils.deserializeBase64Image(secondImage) {
+                    let _ = try await session.process(inputImage: InputImage(uiImage: backUIImage))
                 }
                 
-                let scannedResults = await session.getResult()
+                let scannedResults = await session.getResult(redactionSettings: BlinkIdDeserializationUtils.deserializeRedactionSettings(redactionSettings))
                 DispatchQueue.main.async {
-                    if let results = BlinkIdSerializationUtilities.serializeBlinkIdScanningResult(scannedResults) {
+                    if let results = BlinkIdSerializationUtils.serializeBlinkIdScanningResult(scannedResults) {
                         onResolve(results)
                     } else {
                         onReject("Could not retrive the results from DirectAPI scanning!")
                     }
                 }
+            } catch let blinkIdError as BlinkIdReactNativeError {
+                onReject(BlinkIdReactNativeError.message(for: blinkIdError))
             } catch {
                 if let sdkError = error as? InvalidLicenseKeyError {
                     onReject(sdkError.message)
                 } else {
-                    onReject(error.localizedDescription)
+                    onReject(BlinkIdReactNativeError.message(for: error))
+                }
+            }
+        }
+    }
+
+    @objc public func refreshLicenseLease(onResolve: @escaping (String) -> Void, onReject: @escaping (String) -> Void) {
+        Task {
+            do {
+                guard blinkIdSdk != nil else {
+                    throw BlinkIdReactNativeError.initError(
+                        "The BlinkID SDK is not initialized. Call the loadBlinkIdSdk() method to pre-load the SDK first, or perform a scan."
+                    )
+                }
+                try await BlinkIDSdk.refreshLicenseLease()
+                onResolve("")
+            } catch let blinkIdError as BlinkIdReactNativeError {
+                onReject(BlinkIdReactNativeError.message(for: blinkIdError))
+            } catch {
+                if let sdkError = error as? InvalidLicenseKeyError {
+                    onReject(sdkError.message)
+                } else {
+                    onReject(BlinkIdReactNativeError.message(for: error))
                 }
             }
         }
-        
     }
     
     private func presentScanningUI(_ model: BlinkIDUXModel, _ rootVc: UIViewController) {
@@ -174,15 +191,55 @@ import BlinkIDUX
     }
 }
 
-enum BlinkIdReactNativeError: Error {
-    case incorrectArgument(message: String)
-}
-
 extension BlinkidReactNativeModule: BlinkIDClassFilter {
     public func classAllowed(classInfo: BlinkID.BlinkIDSDK.DocumentClassInfo) -> Bool {
-        if let classInfoFilterDict = classFilterDict {
-            return BlinkIdDeserializationUtilities.deserializeClassFilter(classInfoFilterDict, classInfo)
+        guard let classInfoFilterDict = classFilterDict, !classInfoFilterDict.isEmpty else {
+            return true
+        }
+        return BlinkIdDeserializationUtils.deserializeClassFilter(classInfoFilterDict, classInfo)
+    }
+}
+
+extension BlinkidReactNativeModule: RedactionSettingsResolver {
+    public func resolveRedactionSettings(classInfo: BlinkID.BlinkIDSDK.DocumentClassInfo) -> BlinkID.RedactionSettings? {
+        guard let redactionSettingsResolverDict, !redactionSettingsResolverDict.isEmpty else {
+            return nil
         }
-        return true
+        return BlinkIdDeserializationUtils.deserializeRedactionSettingsResolver(redactionSettingsResolverDict, classInfo)
+    }
+}
+
+enum BlinkIdReactNativeError: LocalizedError {
+    case incorrectArgument(String)
+    case settingsError
+    case initError(String)
+    case frontImageError
+    case scanningCancelled
+    
+    var errorDescription: String? {
+        switch self {
+        case .incorrectArgument(let argument):
+            return "Incorrect argument passed for \(argument)"
+        case .settingsError:
+            return "Invalid SDK settings provided"
+        case .initError(let initErrorReason):
+            return "Could not initialize the SDK. Reason: \(initErrorReason)"
+        case .frontImageError:
+            return "Could not extract the information from the first image! An image of a valid document needs to be sent."
+        case .scanningCancelled:
+            return "Scanning has been cancelled"
+        }
+    }
+    
+    static func message(for error: Error) -> String {
+        if let localizedError = error as? LocalizedError,
+           let description = localizedError.errorDescription {
+            return description
+        }
+        return error.localizedDescription
+    }
+    
+    static var iosErrorName : String {
+        return "blinkid_ios_error"
     }
 }

package/ios/Frameworks/BlinkID.xcframework/Info.plist

@@ -5,35 +5,31 @@
 	<key>AvailableLibraries</key>
 	<array>
 		<dict>
-			<key>BinaryPath</key>
-			<string>BlinkID.framework/BlinkID</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>BlinkID.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
-			<key>BinaryPath</key>
-			<string>BlinkID.framework/BlinkID</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>BlinkID.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>