@microblink/blinkid-react-native 7.2.0 → 7.5.0

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -1,2 +1,2 @@
-#Tue May 20 15:25:31 CEST 2025
+#Mon Jul 21 15:42:56 CEST 2025
 gradle.version=8.9

package/android/build.gradle

@@ -75,7 +75,7 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation("com.microblink:blinkid-ux:7.2.1")
+  implementation("com.microblink:blinkid-ux:7.5.0")
 }
 
 react {

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

@@ -57,7 +57,8 @@ object BlinkIdDeserializationUtilities {
         blinkIdSdkSettingsMap.optJSONObject(
           "resourceRequestTimeout"
         )
-      )
+      ),
+      microblinkProxyUrl = if (blinkIdSdkSettingsMap.has("microblinkProxyURL")) blinkIdSdkSettingsMap.getString("microblinkProxyURL") else null,
     )
   }
 

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

@@ -144,7 +144,15 @@ object BlinkIdSerializationUtilities {
     scanningResult?.visaType?.let {
       scanningResultJson.put("visaType", serializeStringResult(it))
     }
-
+    scanningResult?.countryCode?.let {
+      scanningResultJson.put("countryCode", serializeStringResult(it))
+    }
+    scanningResult?.certificateNumber?.let {
+      scanningResultJson.put("certificateNumber", serializeStringResult(it))
+    }
+    scanningResult?.nationalInsuranceNumber?.let {
+      scanningResultJson.put("nationalInsuranceNumber", serializeStringResult(it))
+    }
     scanningResult?.dateOfBirth?.let {
       scanningResultJson.put("dateOfBirth", serializeDateResult(it))
     }
@@ -339,8 +347,8 @@ object BlinkIdSerializationUtilities {
 
   private fun <T> serializeVehicleClassInfo(vehicleClassInfo: VehicleClassInfo<T>): JSONObject {
     val vehicleClassInfoJson = JSONObject()
-    vehicleClassInfoJson.put("effectiveDate", serializeStringType(vehicleClassInfo.effectiveDate))
-    vehicleClassInfoJson.put("expiryDate", serializeStringType(vehicleClassInfo.expiryDate))
+    vehicleClassInfoJson.put("effectiveDate", serializeDateResult(vehicleClassInfo.effectiveDate))
+    vehicleClassInfoJson.put("expiryDate", serializeDateResult(vehicleClassInfo.expiryDate))
     vehicleClassInfoJson.put("licenceType", serializeStringType(vehicleClassInfo.licenceType))
     vehicleClassInfoJson.put("vehicleClass", serializeStringType(vehicleClassInfo.vehicleClass))
     return vehicleClassInfoJson
@@ -415,6 +423,7 @@ object BlinkIdSerializationUtilities {
     barcodeResultJson.put("religion", barcodeResult?.religion)
     barcodeResultJson.put("residentialStatus", barcodeResult?.residentialStatus)
     barcodeResultJson.put("sex", barcodeResult?.sex)
+    barcodeResultJson.put("parsed", barcodeResult?.parsed)
     barcodeResultJson.put(
       "extendedElements",
       serializeBarcodeExtendedElements(barcodeResult?.extendedElements?.barcodeElements)
@@ -603,6 +612,15 @@ object BlinkIdSerializationUtilities {
     vizResult?.visaType?.let {
       vizResultJson.put("visaType", serializeStringResult(it))
     }
+    vizResult?.countryCode?.let {
+      vizResultJson.put("countryCode", serializeStringResult(it))
+    }
+    vizResult?.certificateNumber?.let {
+      vizResultJson.put("certificateNumber", serializeStringResult(it))
+    }
+    vizResult?.nationalInsuranceNumber?.let {
+      vizResultJson.put("nationalInsuranceNumber", serializeStringResult(it))
+    }
     return vizResultJson
   }
 

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

@@ -1,6 +1,7 @@
 package com.microblink.blinkid.reactnative
 
 import android.app.Activity
+import android.content.Context
 import android.content.Intent
 import com.facebook.react.bridge.BaseActivityEventListener
 import com.facebook.react.bridge.Promise
@@ -13,7 +14,8 @@ import com.microblink.blinkid.ux.contract.BlinkIdScanActivitySettings
 import com.microblink.blinkid.ux.contract.MbBlinkIdScan
 import com.microblink.core.LicenseLockedException
 import com.microblink.core.image.InputImage
-import com.microblink.ux.UiSettings
+import com.microblink.core.ping.PingManager
+import com.microblink.core.ping.pinglets.WrapperProductInfo
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -56,6 +58,7 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
 
             BlinkIdScanActivityResultStatus.Canceled -> {
               pendingPromise?.reject(BLINKID_ERROR_RESULT_CODE, "Scanning is canceled.")
+              suspend { BlinkIdSdk.sdkInstance?.close() }
             }
 
             BlinkIdScanActivityResultStatus.ErrorSdkInit -> {
@@ -108,6 +111,7 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
             showOnboardingDialog = blinkIdUiSettingsJson?.optBoolean("showOnboardingDialog", true) ?: true
           )
         )
+        addReactNativePinglet(it)
         currentActivity?.startActivityForResult(intent, BLINKID_REQUEST_CODE, null)
       } ?: pendingPromise?.reject(BLINKID_ERROR_RESULT_CODE, "Activity not found.")
     } catch (error: Exception) {
@@ -147,6 +151,9 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
           }
 
         val sdkInit = BlinkIdSdk.initializeSdk(context, sdkSettings)
+
+        addReactNativePinglet(context)
+
         when {
           sdkInit.isSuccess -> {
             val instance = sdkInit.getOrNull() ?: return@launch withContext(Dispatchers.Main) {
@@ -202,7 +209,12 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
       }
     }
   }
-
+  private fun addReactNativePinglet(context: Context) {
+    PingManager.getInstance(context).add(
+      WrapperProductInfo(
+        wrapperProduct = WrapperProductInfo.WrapperProduct.CROSSPLATFORMREACTNATIVE),
+      0)
+  }
   companion object {
     const val NAME = "BlinkidReactNative"
   }

package/ios/BlinkIdDeserializationUtilities.swift

@@ -37,6 +37,9 @@ class BlinkIdDeserializationUtilities {
       if let resourceRequestTimeout = sdkSettingsDict?["resourceRequestTimeout"] as? Int {
           blinkidSdkSettings?.resourceRequestTimeout = BlinkID.RequestTimeout.default
       }
+      if let microblinkProxyUrl = sdkSettingsDict?["microblinkProxyURL"] as? String {
+          blinkidSdkSettings?.microblinkProxyURL = microblinkProxyUrl
+      }
       return blinkidSdkSettings
   }
   

package/ios/BlinkIdSerializationUtilities.swift

@@ -117,6 +117,15 @@ class BlinkIdSerializationUtilities {
       if let vehicleType = scanningResult?.vehicleType {
           scanningResultDict["vehicleType"] = serializeStringResult(vehicleType)
       }
+      if let countryCode = scanningResult?.countryCode {
+          scanningResultDict["countryCode"] = serializeStringResult(countryCode)
+      }
+      if let certificateNumber = scanningResult?.certificateNumber {
+          scanningResultDict["certificateNumber"] = serializeStringResult(certificateNumber)
+      }
+      if let nationalInsuranceNumber = scanningResult?.nationalInsuranceNumber {
+          scanningResultDict["nationalInsuranceNumber"] = serializeStringResult(nationalInsuranceNumber)
+      }
       if let eligibilityCategory = scanningResult?.eligibilityCategory {
           scanningResultDict["eligibilityCategory"] = serializeStringResult(eligibilityCategory)
       }
@@ -275,8 +284,8 @@ class BlinkIdSerializationUtilities {
   
   static func serializeVehicleClassInfo<T>(_ vehicleClassInfo: VehicleClassInfo<T>?) -> Dictionary<String, Any> {
       let vehicleClassInfoDict: [String: Any?] = [
-          "effectiveDate": serializeStringType(vehicleClassInfo?.effectiveDate),
-          "expiryDate":  serializeStringType(vehicleClassInfo?.expiryDate),
+          "effectiveDate": serializeDateResult(vehicleClassInfo?.effectiveDate),
+          "expiryDate":  serializeDateResult(vehicleClassInfo?.expiryDate),
           "licenceType": serializeStringType(vehicleClassInfo?.licenceType),
           "vehicleClass": serializeStringType(vehicleClassInfo?.vehicleClass as? String)
       ]
@@ -334,7 +343,8 @@ class BlinkIdSerializationUtilities {
           "race": barcodeResult?.race,
           "religion": barcodeResult?.religion,
           "residentialStatus": barcodeResult?.residentialStatus,
-          "sex": barcodeResult?.sex
+          "sex": barcodeResult?.sex,
+          "parsed": barcodeResult?.parsed
       ]
       
       return barcodeResultDict.compactMapValues { $0 }
@@ -494,56 +504,144 @@ class BlinkIdSerializationUtilities {
       return mrzResultDict.compactMapValues { $0 }
   }
   
-  static func serializeVizResult(_ vizResult: VIZResult?) -> Dictionary<String, Any> {
-      
-      let vizResultDict: [String: Any?] =
-       [
-          "additionalAddressInformation": serializeStringResult(vizResult?.additionalAddressInformation),
-          "additionalNameInformation": serializeStringResult(vizResult?.additionalNameInformation),
-          "additionalOptionalAddressInformation": serializeStringResult(vizResult?.additionalOptionalAddressInformation),
-          "additionalPersonalIdNumber": serializeStringResult(vizResult?.additionalPersonalIdNumber),
-          "address": serializeStringResult(vizResult?.address),
-          "bloodType": serializeStringResult(vizResult?.bloodType),
-          "dateOfBirth": serializeDateResult(vizResult?.dateOfBirth),
-          "dateOfExpiry": serializeDateResult(vizResult?.dateOfExpiry),
-          "dateOfExpiryPermanent": vizResult?.dateOfExpiryPermanent,
-          "dateOfIssue": serializeDateResult(vizResult?.dateOfIssue),
-          "dependentsInfo": vizResult?.dependentsInfo.compactMap(serializeDependentInfo(_:)),
-          "documentAdditionalNumber": serializeStringResult(vizResult?.documentAdditionalNumber),
-          "documentNumber": serializeStringResult(vizResult?.documentNumber),
-          "documentOptionalAdditionalNumber": serializeStringResult(vizResult?.documentOptionalAdditionalNumber),
-          "documentSubtype": serializeStringResult(vizResult?.documentSubtype),
-          "driverLicenseDetailedInfo": serializeDriverLicenseDetailedInfo(vizResult?.driverLicenseDetailedInfo),
-          "eligibilityCategory": serializeStringResult(vizResult?.eligibilityCategory),
-          "employer": serializeStringResult(vizResult?.employer),
-          "fathersName": serializeStringResult(vizResult?.fathersName),
-          "firstName": serializeStringResult(vizResult?.firstName),
-          "fullName": serializeStringResult(vizResult?.fullName),
-          "issuingAuthority": serializeStringResult(vizResult?.issuingAuthority),
-          "lastName": serializeStringResult(vizResult?.lastName),
-          "localizedName": serializeStringResult(vizResult?.localizedName),
-          "manufacturingYear": serializeStringResult(vizResult?.manufacturingYear),
-          "maritalStatus": serializeStringResult(vizResult?.maritalStatus),
-          "mothersName": serializeStringResult(vizResult?.mothersName),
-          "nationality": serializeStringResult(vizResult?.nationality),
-          "personalIdNumber": serializeStringResult(vizResult?.personalIdNumber),
-          "placeOfBirth": serializeStringResult(vizResult?.placeOfBirth),
-          "profession": serializeStringResult(vizResult?.profession),
-          "race": serializeStringResult(vizResult?.race),
-          "religion": serializeStringResult(vizResult?.religion),
-          "remarks": serializeStringResult(vizResult?.remarks),
-          "residencePermitType": serializeStringResult(vizResult?.residencePermitType),
-          "residentialStatus": serializeStringResult(vizResult?.residentialStatus),
-          "sex": serializeStringResult(vizResult?.sex),
-          "specificDocumentValidity": serializeStringResult(vizResult?.specificDocumentValidity),
-          "sponsor": serializeStringResult(vizResult?.sponsor),
-          "vehicleOwner": serializeStringResult(vizResult?.vehicleOwner),
-          "vehicleType": serializeStringResult(vizResult?.vehicleType),
-          "visaType": serializeStringResult(vizResult?.visaType)
-      ]
-      
-      return vizResultDict.compactMapValues { $0 }
-  }
+    static func serializeVizResult(_ vizResult: VIZResult?) -> Dictionary<String, Any> {
+        var vizResultDict = Dictionary<String, Any>()
+        if let vizResult = vizResult {
+            if let additionalAddressInformation = vizResult.additionalAddressInformation {
+                vizResultDict["additionalAddressInformation"] = serializeStringResult(additionalAddressInformation)
+            }
+            
+            if let additionalNameInformation = vizResult.additionalNameInformation {
+                vizResultDict["additionalNameInformation"] = serializeStringResult(additionalNameInformation)
+            }
+            if let additionalOptionalAddressInformation = vizResult.additionalOptionalAddressInformation {
+                vizResultDict["additionalOptionalAddressInformation"] = serializeStringResult(additionalOptionalAddressInformation)
+            }
+            if let additionalPersonalIdNumber = vizResult.additionalPersonalIdNumber {
+                vizResultDict["additionalPersonalIdNumber"] = serializeStringResult(additionalPersonalIdNumber)
+            }
+            if let address = vizResult.address {
+                vizResultDict["address"] = serializeStringResult(address)
+            }
+            if let bloodType = vizResult.bloodType {
+                vizResultDict["bloodType"] = serializeStringResult(bloodType)
+            }
+            if let dateOfBirth = vizResult.dateOfBirth {
+                vizResultDict["dateOfBirth"] = serializeDateResult(dateOfBirth)
+            }
+            if let dateOfExpiry = vizResult.dateOfExpiry {
+                vizResultDict["dateOfExpiry"] = serializeDateResult(dateOfExpiry)
+            }
+            vizResultDict["dateOfExpiryPermanent"] = vizResult.dateOfExpiryPermanent
+            if let dateOfIssue = vizResult.dateOfIssue {
+                vizResultDict["dateOfIssue"] = serializeDateResult(dateOfIssue)
+            }
+            vizResultDict["dependentsInfo"] = vizResult.dependentsInfo?.compactMap(serializeDependentInfo(_:))
+            if let documentAdditionalNumber = vizResult.documentAdditionalNumber {
+                vizResultDict["documentAdditionalNumber"] = serializeStringResult(documentAdditionalNumber)
+            }
+            if let documentNumber = vizResult.documentNumber {
+                vizResultDict["documentNumber"] = serializeStringResult(documentNumber)
+            }
+            if let documentOptionalAdditionalNumber = vizResult.documentOptionalAdditionalNumber {
+                vizResultDict["documentOptionalAdditionalNumber"] = serializeStringResult(documentOptionalAdditionalNumber)
+            }
+            if let documentSubtype = vizResult.documentSubtype {
+                vizResultDict["documentSubtype"] = serializeStringResult(documentSubtype)
+            }
+            if let driverLicenseDetailedInfo = vizResult.driverLicenseDetailedInfo {
+                vizResultDict["driverLicenseDetailedInfo"] = serializeDriverLicenseDetailedInfo(driverLicenseDetailedInfo)
+            }
+            if let eligibilityCategory = vizResult.eligibilityCategory {
+                vizResultDict["eligibilityCategory"] = serializeStringResult(eligibilityCategory)
+            }
+            if let employer = vizResult.employer {
+                vizResultDict["employer"] = serializeStringResult(employer)
+            }
+            if let fathersName = vizResult.fathersName {
+                vizResultDict["fathersName"] = serializeStringResult(fathersName)
+            }
+            if let firstName = vizResult.firstName {
+                vizResultDict["firstName"] = serializeStringResult(firstName)
+            }
+            if let fullName = vizResult.fullName {
+                vizResultDict["fullName"] = serializeStringResult(fullName)
+            }
+            if let issuingAuthority = vizResult.issuingAuthority {
+                vizResultDict["issuingAuthority"] = serializeStringResult(issuingAuthority)
+            }
+            if let lastName = vizResult.lastName {
+                vizResultDict["lastName"] = serializeStringResult(lastName)
+            }
+            if let localizedName = vizResult.localizedName {
+                vizResultDict["localizedName"] = serializeStringResult(localizedName)
+            }
+            if let manufacturingYear = vizResult.manufacturingYear {
+                vizResultDict["manufacturingYear"] = serializeStringResult(manufacturingYear)
+            }
+            if let maritalStatus = vizResult.maritalStatus {
+                vizResultDict["maritalStatus"] = serializeStringResult(maritalStatus)
+            }
+            if let mothersName = vizResult.mothersName {
+                vizResultDict["mothersName"] = serializeStringResult(mothersName)
+            }
+            if let nationality = vizResult.nationality {
+                vizResultDict["nationality"] = serializeStringResult(nationality)
+            }
+            if let personalIdNumber = vizResult.personalIdNumber {
+                vizResultDict["personalIdNumber"] = serializeStringResult(personalIdNumber)
+            }
+            if let placeOfBirth = vizResult.placeOfBirth {
+                vizResultDict["placeOfBirth"] = serializeStringResult(placeOfBirth)
+            }
+            if let profession = vizResult.profession {
+                vizResultDict["profession"] = serializeStringResult(profession)
+            }
+            if let race = vizResult.race {
+                vizResultDict["race"] = serializeStringResult(race)
+            }
+            if let religion = vizResult.religion {
+                vizResultDict["religion"] = serializeStringResult(religion)
+            }
+            if let remarks = vizResult.remarks {
+                vizResultDict["remarks"] = serializeStringResult(remarks)
+            }
+            if let residencePermitType = vizResult.residencePermitType {
+                vizResultDict["residencePermitType"] = serializeStringResult(residencePermitType)
+            }
+            if let residentialStatus = vizResult.residentialStatus {
+                vizResultDict["residentialStatus"] = serializeStringResult(residentialStatus)
+            }
+            if let sex = vizResult.sex {
+                vizResultDict["sex"] = serializeStringResult(sex)
+            }
+            if let specificDocumentValidity = vizResult.specificDocumentValidity {
+                vizResultDict["specificDocumentValidity"] = serializeStringResult(specificDocumentValidity)
+            }
+            if let sponsor = vizResult.sponsor {
+                vizResultDict["sponsor"] = serializeStringResult(sponsor)
+            }
+            if let vehicleOwner = vizResult.vehicleOwner {
+                vizResultDict["vehicleOwner"] = serializeStringResult(vehicleOwner)
+            }
+            if let vehicleType = vizResult.vehicleType {
+                vizResultDict["vehicleType"] = serializeStringResult(vehicleType)
+            }
+            if let visaType = vizResult.visaType {
+                vizResultDict["visaType"] = serializeStringResult(visaType)
+            }
+            if let countryCode = vizResult.countryCode {
+                vizResultDict["countryCode"] = serializeStringResult(countryCode)
+            }
+            if let certificateNumber = vizResult.certificateNumber {
+                vizResultDict["certificateNumber"] = serializeStringResult(certificateNumber)
+            }
+            if let nationalInsuranceNumber = vizResult.nationalInsuranceNumber {
+                vizResultDict["nationalInsuranceNumber"] = serializeStringResult(nationalInsuranceNumber)
+            }
+        }
+        return vizResultDict
+    }
   
   static func serializeDetailedCroppedImageResult(_ detailedcroppedImageResult: DetailedCroppedImageResult?) -> Dictionary<String, Any> {
       let detailedcroppedImageResultDict: [String: Any?] = [

package/ios/BlinkidReactNativeModule.swift

@@ -36,6 +36,7 @@ import BlinkIDUX
                     eventStream: BlinkIDEventStream(),
                     classFilter: self
                 )
+                await addReactNativePinglet(with: analyzer.sessionNumber)
                 
                 var shouldShowIntroductionAlert = true
                 if let showOnboardingDialog = blinkIdUiSettings["showOnboardingDialog"] as? Bool {
@@ -49,7 +50,8 @@ import BlinkIDUX
                 let scanningUxModel = await BlinkIDUXModel(
                     analyzer: analyzer,
                     shouldShowIntroductionAlert: shouldShowIntroductionAlert,
-                    showHelpButton: shouldShowHelpButton)
+                    showHelpButton: shouldShowHelpButton, sessionNumber: analyzer.sessionNumber)
+                
                 await scanningUxModel.$result
                     .sink { [weak self] scanningResultState in
                         if let scanningResultState {
@@ -62,6 +64,9 @@ import BlinkIDUX
                                 }
                             }
                             else {
+                                Task {
+                                    await BlinkIDSdk.terminateBlinkIDSdk()
+                                }
                                 DispatchQueue.main.async {
                                     onReject("Scanning has been canceled")
                                     rootVc.dismiss(animated: true)
@@ -74,7 +79,11 @@ import BlinkIDUX
                 
                 self.presentScanningUI(scanningUxModel, rootVc)
             } catch {
-                onReject(error.localizedDescription)
+                if let sdkError = error as? InvalidLicenseKeyError {
+                    onReject(sdkError.message)
+                } else {
+                    onReject(error.localizedDescription)
+                }
             }
         }
     }
@@ -93,6 +102,8 @@ import BlinkIDUX
                 let blinkidSdk = try await BlinkIDSdk.createBlinkIDSdk(withSettings: sdkSettings)
                 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
@@ -113,7 +124,11 @@ import BlinkIDUX
                     }
                 }
             } catch {
-                onReject(error.localizedDescription)
+                if let sdkError = error as? InvalidLicenseKeyError {
+                    onReject(sdkError.message)
+                } else {
+                    onReject(error.localizedDescription)
+                }
             }
         }
         
@@ -126,6 +141,10 @@ import BlinkIDUX
             rootVc.present(viewController, animated: true)
         }
     }
+    
+    private func addReactNativePinglet(with sessionNumber: Int) async {
+        await PingManager.shared.addPinglet(pinglet: WrapperProductInfoPinglet(wrapperProduct: .crossplatformreactnative), sessionNumber: sessionNumber)
+    }
 }
 
 extension BlinkidReactNativeModule: BlinkIDClassFilter {