@microblink/blinkid-react-native 7.7.0 → 8000.0.0

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

@@ -4,7 +4,9 @@ import android.graphics.Bitmap
 import com.microblink.blinkid.core.result.AddressDetailedInfo
 import com.microblink.blinkid.core.result.AlphabetType
 import com.microblink.blinkid.core.result.DataMatchFieldState
+import com.microblink.blinkid.core.result.DataMatchFieldType
 import com.microblink.blinkid.core.result.DataMatchResult
+import com.microblink.blinkid.core.result.DataMatchState
 import com.microblink.blinkid.core.result.DependentInfo
 import com.microblink.blinkid.core.result.DriverLicenseDetailedInfo
 import com.microblink.blinkid.core.result.SingleSideScanningResult
@@ -12,7 +14,9 @@ import com.microblink.blinkid.core.result.StringResult
 import com.microblink.blinkid.core.result.VehicleClassInfo
 import com.microblink.blinkid.core.result.barcode.BarcodeData
 import com.microblink.blinkid.core.result.barcode.BarcodeResult
+import com.microblink.blinkid.core.result.barcode.BarcodeType
 import com.microblink.blinkid.core.result.classinfo.DocumentClassInfo
+import com.microblink.blinkid.core.result.mrz.DocumentType
 import com.microblink.blinkid.core.result.mrz.MrzResult
 import com.microblink.blinkid.core.result.viz.VizResult
 import com.microblink.blinkid.core.session.BlinkIdScanningResult
@@ -21,19 +25,16 @@ import java.io.ByteArrayOutputStream
 import android.util.Base64
 import com.microblink.blinkid.core.result.ParentInfo
 import com.microblink.blinkid.core.result.barcode.BarcodeElement
-import com.microblink.core.result.DateResult
-import com.microblink.core.result.DetailedCroppedImageResult
-import com.microblink.core.result.Rectangle
-import com.microblink.core.result.ScanningSide
+import com.microblink.blinkid.core.result.DateResult
+import com.microblink.blinkid.core.result.DetailedCroppedImageResult
+import com.microblink.blinkid.core.result.Rectangle
+import com.microblink.blinkid.core.result.ScanningSide
 import org.json.JSONArray
 
 object BlinkIdSerializationUtilities {
     fun serializeBlinkIdScanningResult(scanningResult: BlinkIdScanningResult?): String {
         val scanningResultJson: JSONObject = JSONObject()
 
-        scanningResult?.mode.let {
-            scanningResultJson.put("recognitionMode", it?.name)
-        }
         scanningResult?.documentClassInfo?.let {
             scanningResultJson.put("documentClassInfo", serializeDocumentClassInfo(it))
         }
@@ -109,6 +110,9 @@ object BlinkIdSerializationUtilities {
         scanningResult?.documentNumber?.let {
             scanningResultJson.put("documentNumber", serializeStringResult(it))
         }
+        scanningResult?.cardAccessNumber?.let {
+            scanningResultJson.put("cardAccessNumber", serializeStringResult(it))
+        }
         scanningResult?.personalIdNumber?.let {
             scanningResultJson.put("personalIdNumber", serializeStringResult(it))
         }
@@ -247,8 +251,8 @@ object BlinkIdSerializationUtilities {
         scanningResult?.inputImage(ScanningSide.Second)?.let {
             scanningResultJson.put("secondInputImage", encodeBase64Image(it.bitmap))
         }
-        scanningResult?.barcodeInputImage()?.let {
-            scanningResultJson.put("barcodeInputImage", encodeBase64Image(it.bitmap))
+        scanningResult?.barcodeImage()?.let {
+            scanningResultJson.put("barcodeImage", encodeBase64Image(it.bitmap))
         }
         scanningResult?.documentImage(ScanningSide.First)?.let {
             scanningResultJson.put("firstDocumentImage", encodeBase64Image(it.bitmap))
@@ -266,7 +270,7 @@ object BlinkIdSerializationUtilities {
         return scanningResultJson.toString()
     }
 
-    private fun <T> serializeDateResult(dateResult: DateResult<T>?): JSONObject {
+    private fun serializeDateResult(dateResult: DateResult<*>?): JSONObject {
         val dateResultJson = JSONObject()
 
         dateResultJson.put("date", serializeSimpleDateResult(dateResult));
@@ -276,7 +280,7 @@ object BlinkIdSerializationUtilities {
         return dateResultJson
     }
 
-    private fun <T> serializeSimpleDateResult(dateResult: DateResult<T>?): JSONObject {
+    private fun serializeSimpleDateResult(dateResult: DateResult<*>?): JSONObject {
         val simpleDateResultJson = JSONObject()
         dateResult?.day?.let {
             simpleDateResultJson.put("day", it)
@@ -292,6 +296,9 @@ object BlinkIdSerializationUtilities {
 
     private fun serializeDocumentClassInfo(documentClassInfo: DocumentClassInfo): JSONObject {
         val documentClassInfoJson = JSONObject()
+        // TODO: Align country/region/documentType strings with iOS (rawValue). Android uses
+        // enum.name with only the first character lowercased; values usually match but are not
+        // guaranteed identical for every enum. Prefer shared explicit string mappers on both platforms.
         documentClassInfo.country?.name?.let {
             documentClassInfoJson.put("country", it.replaceFirstChar { char -> char.lowercase() })
         }
@@ -312,6 +319,10 @@ object BlinkIdSerializationUtilities {
         documentClassInfo.isoAlpha3CountryCode?.let {
             documentClassInfoJson.put("isoAlpha3CountryCode", it)
         }
+        documentClassInfo.isoNumericCountryCode?.let {
+            documentClassInfoJson.put("isoNumericCountryCode", it)
+        }
+        documentClassInfoJson.put("empty", documentClassInfo.isEmpty())
         return documentClassInfoJson
     }
 
@@ -324,18 +335,37 @@ object BlinkIdSerializationUtilities {
         }
 
         dataMatchResultJson.put("states", statesArray)
-        dataMatchResultJson.put("overallState", dataMatchResult.overallState.ordinal)
+        dataMatchResultJson.put("overallState", serializeDataMatchState(dataMatchResult.overallState))
 
         return dataMatchResultJson
     }
 
     private fun serializeDataMatchField(dataMatchField: DataMatchFieldState): JSONObject {
         val dataMatchFieldJson = JSONObject()
-        dataMatchFieldJson.put("field", dataMatchField.fieldType.ordinal)
-        dataMatchFieldJson.put("state", dataMatchField.state.ordinal)
+        dataMatchFieldJson.put("field", serializeDataMatchFieldType(dataMatchField.fieldType))
+        dataMatchFieldJson.put("state", serializeDataMatchState(dataMatchField.state))
         return dataMatchFieldJson
     }
 
+    private fun serializeDataMatchFieldType(fieldType: DataMatchFieldType): String {
+        return when (fieldType) {
+            DataMatchFieldType.DateOfBirth -> "dateOfBirth"
+            DataMatchFieldType.DateOfExpiry -> "dateOfExpiry"
+            DataMatchFieldType.DocumentNumber -> "documentNumber"
+            DataMatchFieldType.DocumentAdditionalNumber -> "documentAdditionalNumber"
+            DataMatchFieldType.DocumentOptionalAdditionalNumber -> "documentOptionalAdditionalNumber"
+            DataMatchFieldType.PersonalIdNumber -> "personalIdNumber"
+        }
+    }
+
+    private fun serializeDataMatchState(state: DataMatchState): String {
+        return when (state) {
+            DataMatchState.NotPerformed -> "notPerformed"
+            DataMatchState.Failed -> "failed"
+            DataMatchState.Success -> "success"
+        }
+    }
+
     private fun serializeStringResult(stringResult: StringResult): JSONObject {
         val stringResultJson = JSONObject()
         stringResultJson.put("value", stringResult.value(AlphabetType.Latin))
@@ -361,16 +391,16 @@ object BlinkIdSerializationUtilities {
 
         val sideJson = JSONObject()
         stringResult.side(AlphabetType.Latin)?.let {
-            sideJson.put("latin", it.ordinal)
+            sideJson.put("latin", serializeScanningSide(it))
         }
         stringResult.side(AlphabetType.Arabic)?.let {
-            sideJson.put("arabic", it.ordinal)
+            sideJson.put("arabic", serializeScanningSide(it))
         }
         stringResult.side(AlphabetType.Cyrillic)?.let {
-            sideJson.put("cyrillic", it.ordinal)
+            sideJson.put("cyrillic", serializeScanningSide(it))
         }
         stringResult.side(AlphabetType.Greek)?.let {
-            sideJson.put("greek", it.ordinal)
+            sideJson.put("greek", serializeScanningSide(it))
         }
         stringResultJson.put("side", sideJson)
 
@@ -386,8 +416,8 @@ object BlinkIdSerializationUtilities {
         return locationJson
     }
 
-    private fun <T> serializeDriverLicenseDetailedInfo(
-        driverLicenseDetailedInfo: DriverLicenseDetailedInfo<T>?
+    private fun serializeDriverLicenseDetailedInfo(
+        driverLicenseDetailedInfo: DriverLicenseDetailedInfo<*>?
     ): JSONObject {
         val json = JSONObject()
 
@@ -407,7 +437,7 @@ object BlinkIdSerializationUtilities {
         return json
     }
 
-    private fun <T> serializeVehicleClassInfo(vehicleClassInfo: VehicleClassInfo<T>): JSONObject {
+    private fun serializeVehicleClassInfo(vehicleClassInfo: VehicleClassInfo<*>): JSONObject {
         val vehicleClassInfoJson = JSONObject()
         vehicleClassInfoJson.put(
             "effectiveDate",
@@ -443,8 +473,8 @@ object BlinkIdSerializationUtilities {
         val subResultJson = JSONObject()
         subResultJson.put("barcode", serializeBarcodeResult(subResult.barcode))
         subResultJson.put(
-            "barcodeInputImage",
-            encodeBase64Image(subResult.barcodeInputImage?.bitmap)
+            "barcodeImage",
+            encodeBase64Image(subResult.barcodeImage?.bitmap)
         )
         subResultJson.put("documentImage", encodeBase64Image(subResult.documentImage?.bitmap))
         subResultJson.put("faceImage", serializeDetailedCroppedImageResult(subResult.faceImage))
@@ -512,21 +542,39 @@ object BlinkIdSerializationUtilities {
 
     private fun serializeBarcodeData(barcodeData: BarcodeData?): JSONObject {
         val barcodeDataJson = JSONObject()
-        barcodeDataJson.put("barcodeType", barcodeData?.barcodeType?.ordinal)
-        barcodeDataJson.put("rawData", barcodeData?.rawData.toString())
+        barcodeDataJson.put("barcodeType", serializeBarcodeType(barcodeData?.barcodeType))
+        barcodeDataJson.put("rawData", encodeBase64Bytes(barcodeData?.rawData))
         barcodeDataJson.put("stringData", barcodeData?.stringData)
         barcodeDataJson.put("uncertain", barcodeData?.uncertain)
 
         return barcodeDataJson
     }
 
+    private fun serializeBarcodeType(barcodeType: BarcodeType?): String {
+        return when (barcodeType) {
+            BarcodeType.None -> "none"
+            BarcodeType.QRCode -> "qrCode"
+            BarcodeType.DataMatrix -> "dataMatrix"
+            BarcodeType.UPCE -> "upce"
+            BarcodeType.UPCA -> "upca"
+            BarcodeType.EAN8 -> "ean8"
+            BarcodeType.EAN13 -> "ean13"
+            BarcodeType.Code128 -> "code128"
+            BarcodeType.Code39 -> "code39"
+            BarcodeType.ITF -> "itf"
+            BarcodeType.Aztec -> "aztec"
+            BarcodeType.PDF417 -> "pdf417"
+            null -> "none"
+        }
+    }
+
     private fun serializeMrzResult(mrzResult: MrzResult?): JSONObject {
         val mrzResultJson = JSONObject()
         mrzResultJson.put("dateOfBirth", serializeDateResult(mrzResult?.dateOfBirth))
         mrzResultJson.put("dateOfExpiry", serializeDateResult(mrzResult?.dateOfExpiry))
         mrzResultJson.put("documentCode", mrzResult?.documentCode)
         mrzResultJson.put("documentNumber", mrzResult?.documentNumber)
-        mrzResultJson.put("documentType", mrzResult?.documentType?.ordinal)
+        mrzResultJson.put("documentType", serializeMrzDocumentType(mrzResult?.documentType))
         mrzResultJson.put("gender", mrzResult?.gender)
         mrzResultJson.put("issuer", mrzResult?.issuer)
         mrzResultJson.put("issuerName", mrzResult?.issuerName)
@@ -614,15 +662,18 @@ object BlinkIdSerializationUtilities {
         vizResult?.documentAdditionalNumber?.let {
             vizResultJson.put("documentAdditionalNumber", serializeStringResult(it))
         }
-        vizResult?.dependentsInfo.let {
+        vizResult?.dependentsInfo?.let {
             vizResultJson.put(
                 "dependentsInfo",
-                JSONArray(it?.map { dependentInfo -> serializeDependentInfo(dependentInfo) })
+                JSONArray(it.map { dependentInfo -> serializeDependentInfo(dependentInfo) })
             )
         }
         vizResult?.documentNumber?.let {
             vizResultJson.put("documentNumber", serializeStringResult(it))
         }
+        vizResult?.cardAccessNumber?.let {
+            vizResultJson.put("cardAccessNumber", serializeStringResult(it))
+        }
         vizResult?.documentOptionalAdditionalNumber?.let {
             vizResultJson.put("documentOptionalAdditionalNumber", serializeStringResult(it))
         }
@@ -754,13 +805,34 @@ object BlinkIdSerializationUtilities {
         detailedCroppedImageResult?.location?.let {
             detailedCroppedImageResultJson.put("location", serializeLocation(it))
         }
-        detailedCroppedImageResult?.side?.let {
-            detailedCroppedImageResultJson.put("side", it.ordinal)
-
+        detailedCroppedImageResult?.side?.let { side ->
+            detailedCroppedImageResultJson.put("side", serializeScanningSide(side))
         }
         return detailedCroppedImageResultJson
     }
 
+    private fun serializeMrzDocumentType(documentType: DocumentType?): String? {
+        return when (documentType) {
+            DocumentType.Unknown -> "unknown"
+            DocumentType.IdentityCard -> "identityCard"
+            DocumentType.Passport -> "passport"
+            DocumentType.Visa -> "visa"
+            DocumentType.GreenCard -> "greenCard"
+            DocumentType.MysPassIMM13P -> "mysPassIMM13P"
+            DocumentType.DriverLicense -> "driverLicense"
+            DocumentType.InternalTravelDocument -> "internalTravelDocument"
+            DocumentType.BorderCrossingCard -> "borderCrossingCard"
+            null -> null
+        }
+    }
+
+    private fun serializeScanningSide(side: ScanningSide): String {
+        return when (side) {
+            ScanningSide.First -> "first"
+            ScanningSide.Second -> "second"
+        }
+    }
+
     private fun serializeBarcodeExtendedElements(barcodeExtendedElements: Array<BarcodeElement>?): JSONObject {
         val barcodeExtendedElementsJson = JSONObject()
 
@@ -797,6 +869,12 @@ object BlinkIdSerializationUtilities {
         }
     }
 
+    private fun encodeBase64Bytes(data: ByteArray?): String? {
+        return data?.let {
+            Base64.encodeToString(it, Base64.NO_WRAP)
+        }
+    }
+
     private fun encodeBase64Image(image: Bitmap?): String? {
         return image?.let { bmp ->
             val outputStream = ByteArrayOutputStream()

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

@@ -12,10 +12,10 @@ import com.microblink.blinkid.core.BlinkIdSdkSettings
 import com.microblink.blinkid.core.session.BlinkIdProcessResult
 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.ux.contract.ScanActivityResultStatus
+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
@@ -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