@microblink/blinkid-react-native 7.7.0 → 8000.0.0

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,104 @@ 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))
                 }
             }
         }
-        
     }
     
     private func presentScanningUI(_ model: BlinkIDUXModel, _ rootVc: UIViewController) {
@@ -174,15 +169,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 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 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"
     }
 }