@microblink/blinkid-react-native 7.7.0 → 8001.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))
         }
@@ -82,6 +83,9 @@ object BlinkIdSerializationUtilities {
         scanningResult?.race?.let {
             scanningResultJson.put("race", serializeStringResult(it))
         }
+        scanningResult?.ethnicity?.let {
+            scanningResultJson.put("ethnicity", serializeStringResult(it))
+        }
         scanningResult?.religion?.let {
             scanningResultJson.put("religion", serializeStringResult(it))
         }
@@ -109,6 +113,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 +254,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 +273,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 +283,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,16 +299,23 @@ object BlinkIdSerializationUtilities {
 
     private fun serializeDocumentClassInfo(documentClassInfo: DocumentClassInfo): JSONObject {
         val documentClassInfoJson = JSONObject()
-        documentClassInfo.country?.name?.let {
-            documentClassInfoJson.put("country", it.replaceFirstChar { char -> char.lowercase() })
-        }
-        documentClassInfo.region?.name?.let {
-            documentClassInfoJson.put("region", it.replaceFirstChar { char -> char.lowercase() })
-        }
-        documentClassInfo.type?.name?.let {
-            documentClassInfoJson.put(
-                "documentType",
-                it.replaceFirstChar { char -> char.lowercase() })
+        documentClassInfo.country?.let { country ->
+            documentClassInfoJson.put("country", serializeClassInfoComponent(
+                id = country.id?.let { BlinkIdClassInfoIdMappings.serializeCountryId(it) },
+                rawValue = country.rawValue
+            ))
+        }
+        documentClassInfo.region?.let { region ->
+            documentClassInfoJson.put("region", serializeClassInfoComponent(
+                id = region.id?.let { BlinkIdClassInfoIdMappings.serializeRegionId(it) },
+                rawValue = region.rawValue
+            ))
+        }
+        documentClassInfo.documentType?.let { documentType ->
+            documentClassInfoJson.put("documentType", serializeClassInfoComponent(
+                id = documentType.id?.let { BlinkIdClassInfoIdMappings.serializeDocumentTypeId(it) },
+                rawValue = documentType.rawValue
+            ))
         }
         documentClassInfo.countryName?.let {
             documentClassInfoJson.put("countryName", it)
@@ -312,9 +326,29 @@ object BlinkIdSerializationUtilities {
         documentClassInfo.isoAlpha3CountryCode?.let {
             documentClassInfoJson.put("isoAlpha3CountryCode", it)
         }
+        documentClassInfo.isoNumericCountryCode?.let {
+            documentClassInfoJson.put("isoNumericCountryCode", it)
+        }
+        documentClassInfoJson.put("empty", isDocumentClassInfoEmpty(documentClassInfo))
         return documentClassInfoJson
     }
 
+    private fun isDocumentClassInfoEmpty(documentClassInfo: DocumentClassInfo): Boolean {
+        val classIds = listOf(
+            documentClassInfo.country?.id?.name,
+            documentClassInfo.region?.id?.name,
+            documentClassInfo.documentType?.id?.name
+        )
+        return classIds.any { it == null } || classIds.all { it == "None" }
+    }
+
+    private fun serializeClassInfoComponent(id: String?, rawValue: String): JSONObject {
+        val json = JSONObject()
+        id?.let { json.put("id", it) }
+        json.put("rawValue", rawValue)
+        return json
+    }
+
     private fun serializeDataMatchResult(dataMatchResult: DataMatchResult): JSONObject {
         val dataMatchResultJson = JSONObject()
 
@@ -324,18 +358,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 +414,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 +439,8 @@ object BlinkIdSerializationUtilities {
         return locationJson
     }
 
-    private fun <T> serializeDriverLicenseDetailedInfo(
-        driverLicenseDetailedInfo: DriverLicenseDetailedInfo<T>?
+    private fun serializeDriverLicenseDetailedInfo(
+        driverLicenseDetailedInfo: DriverLicenseDetailedInfo<*>?
     ): JSONObject {
         val json = JSONObject()
 
@@ -407,7 +460,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 +496,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 +565,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 +685,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))
         }
@@ -680,6 +754,9 @@ object BlinkIdSerializationUtilities {
         vizResult?.race?.let {
             vizResultJson.put("race", serializeStringResult(it))
         }
+        vizResult?.ethnicity?.let {
+            vizResultJson.put("ethnicity", serializeStringResult(it))
+        }
         vizResult?.religion?.let {
             vizResultJson.put("religion", serializeStringResult(it))
         }
@@ -754,13 +831,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()
 
@@ -786,6 +884,10 @@ object BlinkIdSerializationUtilities {
             parentInfoJson.put("lastName", serializeStringResult(it))
         }
 
+        parentInfo.fullName?.let {
+            parentInfoJson.put("fullName", serializeStringResult(it))
+        }
+
         return parentInfoJson
     }
 
@@ -797,6 +899,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()
@@ -233,6 +234,21 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  override fun refreshLicenseLease(promise: Promise?) {
+    CoroutineScope(Dispatchers.Main).launch {
+      try {
+        val sdk = BlinkIdSdk.sdkInstance
+          ?: throw IllegalStateException(
+            "The BlinkID SDK is not initialized. Call loadBlinkIdSdk() first, or perform a scan."
+          )
+        sdk.refreshLicenseLease()
+        promise?.resolve(null)
+      } catch (error: Exception) {
+        promise?.reject(BLINKID_ERROR_RESULT_CODE, error.message)
+      }
+    }
+  }
+
   private suspend fun ensureLoadedSdk(blinkidSdkSettings: JSONObject?): BlinkIdSdk? {
 
     blinkIdSdk?.let { return it }
@@ -260,10 +276,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"
   }