@microblink/blinkid-react-native 7.6.2 → 8000.0.0

package/android/src/main/java/com/microblink/blinkid/reactnative/BlinkidReactNativeModule.kt

@@ -10,12 +10,12 @@ import com.facebook.react.module.annotations.ReactModule
 import com.microblink.blinkid.core.BlinkIdSdk
 import com.microblink.blinkid.core.BlinkIdSdkSettings
 import com.microblink.blinkid.core.session.BlinkIdProcessResult
-import com.microblink.blinkid.ux.contract.BlinkIdScanActivityResultStatus
 import com.microblink.blinkid.ux.contract.BlinkIdScanActivitySettings
 import com.microblink.blinkid.ux.contract.MbBlinkIdScan
-import com.microblink.core.image.InputImage
-import com.microblink.core.ping.PingManager
-import com.microblink.core.ping.pinglets.WrapperProductInfo
+import com.microblink.blinkid.core.image.InputImage
+import com.microblink.blinkid.core.ping.PingManager
+import com.microblink.blinkid.core.ping.pinglets.WrapperProductInfo
+import com.microblink.blinkid.ux.contract.ScanActivityResultStatus
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -83,7 +83,7 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
 
           val blinkIdResult = MbBlinkIdScan().parseResult(resultCode, data)
           when (blinkIdResult.status) {
-            BlinkIdScanActivityResultStatus.DocumentScanned -> {
+            ScanActivityResultStatus.Scanned -> {
               blinkIdResult.result?.let { scanningResult ->
                 val success = BlinkIdSerializationUtilities.serializeBlinkIdScanningResult(
                   scanningResult
@@ -93,7 +93,7 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
               } ?: pendingPromise?.reject(BLINKID_ERROR_RESULT_CODE, "BlinkID result is empty.")
             }
 
-            BlinkIdScanActivityResultStatus.Canceled -> {
+              ScanActivityResultStatus.Canceled -> {
               pendingPromise?.reject(BLINKID_ERROR_RESULT_CODE, "Scanning is canceled.")
               blinkIdSdk = null
               suspend {
@@ -101,7 +101,7 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
               }
             }
 
-            BlinkIdScanActivityResultStatus.ErrorSdkInit -> {
+              ScanActivityResultStatus.ErrorSdkInit -> {
               pendingPromise?.reject(
                 BLINKID_ERROR_RESULT_CODE,
                 "Could not initialize the SDK."
@@ -122,6 +122,7 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
     blinkIdSessionSettings: String?,
     blinkIdScanningUxSettings: String?,
     classFilter: String?,
+    redactionSettingsResolver: String?,
     promise: Promise?
   ) {
     CoroutineScope(Dispatchers.Main).launch {
@@ -129,32 +130,36 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
       try {
         val sdkSettingsJson = blinkIdSdkSettings?.let { JSONObject(it) }
         val sessionSettingsJson = blinkIdSessionSettings?.let { JSONObject(it) }
-        val classFilterJson = classFilter?.let { JSONObject(it) }
-        val blinkIdScanningUxJson = blinkIdScanningUxSettings?.let { JSONObject(it) }
+        val classFilterJson = parseOptionalJsonObject(classFilter)
+        val redactionResolverJson = parseOptionalJsonObject(redactionSettingsResolver)
+        val blinkIdScanningUxJson = parseOptionalJsonObject(blinkIdScanningUxSettings)
         val sdkSettings: BlinkIdSdkSettings = sdkSettingsJson?.let {
           BlinkIdDeserializationUtilities.deserializeBlinkIdSdkSettings(it)
-        }?:return@launch withContext(Dispatchers.Main) {
+        } ?: return@launch withContext(Dispatchers.Main) {
           promise?.reject(BLINKID_ERROR_RESULT_CODE, "Invalid SDK settings")
         }
 
-       blinkIdSdk = ensureLoadedSdk(sdkSettingsJson)
-
         reactApplicationContext.currentActivity?.applicationContext?.let {
           val intent = MbBlinkIdScan().createIntent(
             it,
             BlinkIdScanActivitySettings(
               sdkSettings = sdkSettings,
-              cameraSettings = BlinkIdDeserializationUtilities.deserializeCameraSettings(blinkIdScanningUxJson),
+              cameraSettings = BlinkIdDeserializationUtilities.deserializeCameraSettings(
+                blinkIdScanningUxJson
+              ),
               scanningSessionSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdSessionSettings(
                 sessionSettingsJson,
                 false
               ),
-              uxSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdScanningUxSettings(
+              uxSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdUxSettings(
                 blinkIdScanningUxJson,
+                sessionSettingsJson,
                 classFilterJson,
+                redactionResolverJson,
               ),
-              showHelpButton = blinkIdScanningUxJson?.optBoolean("showHelpButton", true)?: true,
-              showOnboardingDialog = blinkIdScanningUxJson?.optBoolean("showOnboardingDialog", true) ?: true
+              showHelpButton = blinkIdScanningUxJson?.optBoolean("showHelpButton", true) ?: true,
+              showOnboardingDialog = blinkIdScanningUxJson?.optBoolean("showOnboardingDialog", true)
+                ?: true
             )
           )
           addReactNativePinglet(it)
@@ -173,6 +178,7 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
     blinkIdSessionSettings: String?,
     firstImage: String?,
     secondImage: String?,
+    redactionSettings: String?,
     promise: Promise?
   ) {
     pendingPromise = promise
@@ -180,6 +186,7 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
       try {
         val sdkSettingsJson = blinkIdSdkSettings?.let { JSONObject(it) }
         val sessionSettingsJson = blinkIdSessionSettings?.let { JSONObject(it) }
+        val redactionSettingsJson = parseOptionalJsonObject(redactionSettings)
 
         val context = reactApplicationContext.applicationContext
           ?: return@launch withContext(Dispatchers.Main) {
@@ -193,31 +200,25 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
               sessionSettingsJson,
               true
             )
-          )
+          ).getOrThrow()
 
           val inputImages = listOfNotNull(
             firstImage?.let { BlinkIdDeserializationUtilities.base64ToBitmap(it) },
             secondImage?.let { BlinkIdDeserializationUtilities.base64ToBitmap(it) }
           )
 
-          var result: Result<BlinkIdProcessResult>? = null
-
           for (img in inputImages) {
-            result = session.process(InputImage.createFromBitmap(img))
+            session.process(InputImage.createFromBitmap(img)).getOrThrow()
           }
 
-          if (result?.isSuccess == true) {
-            val scanResult = session.getResult()
-            val resultJson =
-              BlinkIdSerializationUtilities.serializeBlinkIdScanningResult(scanResult)
+          val scanResult = session.getResult(
+            BlinkIdDeserializationUtilities.deserializeRedactionSettings(redactionSettingsJson)
+          ).getOrThrow()
+          val resultJson =
+            BlinkIdSerializationUtilities.serializeBlinkIdScanningResult(scanResult)
 
-            withContext(Dispatchers.Main) {
-              promise?.resolve(resultJson.toString())
-            }
-          } else {
-            withContext(Dispatchers.Main) {
-              promise?.reject(BLINKID_ERROR_RESULT_CODE, "Could not get the results.")
-            }
+          withContext(Dispatchers.Main) {
+            promise?.resolve(resultJson)
           }
 
           it.close()
@@ -260,10 +261,17 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
 
   private fun addReactNativePinglet(context: Context) {
     PingManager.getInstance(context).add(
-      WrapperProductInfo(
-        wrapperProduct = WrapperProductInfo.WrapperProduct.CROSSPLATFORMREACTNATIVE),
-      0)
+      WrapperProductInfo(WrapperProductInfo.WrapperProduct.CROSSPLATFORMREACTNATIVE),
+      0
+    )
   }
+  private fun parseOptionalJsonObject(value: String?): JSONObject? {
+    if (value.isNullOrBlank() || value == "null" || value == "undefined") {
+      return null
+    }
+    return JSONObject(value)
+  }
+
   companion object {
     const val NAME = "BlinkidReactNative"
   }

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,45 @@ 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(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 +93,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,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),
-                    sessionNumber: analyzer.sessionNumber)
-                
-                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"
     }
 }