@microblink/blinkid-react-native 7.4.0 → 7.6.0

package/ios/BlinkIdSerializationUtilities.swift

@@ -117,6 +117,9 @@ class BlinkIdSerializationUtilities {
       if let vehicleType = scanningResult?.vehicleType {
           scanningResultDict["vehicleType"] = serializeStringResult(vehicleType)
       }
+      if let vehicleOwner = scanningResult?.vehicleOwner {
+          scanningResultDict["vehicleOwner"] = serializeStringResult(vehicleOwner)
+      }
       if let countryCode = scanningResult?.countryCode {
           scanningResultDict["countryCode"] = serializeStringResult(countryCode)
       }
@@ -147,6 +150,36 @@ class BlinkIdSerializationUtilities {
       if let dateOfExpiry = scanningResult?.dateOfExpiry {
           scanningResultDict["dateOfExpiry"] = serializeDateResult(dateOfExpiry)
       }
+      if let dateOfEntry = scanningResult?.dateOfEntry {
+          scanningResultDict["dateOfEntry"] = serializeDateResult(dateOfEntry)
+      }
+      if let localityCode = scanningResult?.localityCode {
+          scanningResultDict["localityCode"] = serializeStringResult(localityCode)
+      }
+      if let maidenName = scanningResult?.maidenName {
+          scanningResultDict["maidenName"] = serializeStringResult(maidenName)
+      }
+      if let municipalityCode = scanningResult?.municipalityCode {
+          scanningResultDict["municipalityCode"] = serializeStringResult(municipalityCode)
+      }
+      if let municipalityOfRegistration = scanningResult?.municipalityOfRegistration {
+          scanningResultDict["municipalityOfRegistration"] = serializeStringResult(municipalityOfRegistration)
+      }
+      if let pollingStationCode = scanningResult?.pollingStationCode {
+          scanningResultDict["pollingStationCode"] = serializeStringResult(pollingStationCode)
+      }
+      if let registrationCenterCode = scanningResult?.registrationCenterCode {
+          scanningResultDict["registrationCenterCode"] = serializeStringResult(registrationCenterCode)
+      }
+      if let sectionCode = scanningResult?.sectionCode {
+          scanningResultDict["sectionCode"] = serializeStringResult(sectionCode)
+      }
+      if let stateCode = scanningResult?.stateCode {
+          scanningResultDict["stateCode"] = serializeStringResult(stateCode)
+      }
+      if let stateName = scanningResult?.stateName {
+          scanningResultDict["stateName"] = serializeStringResult(stateName)
+      }
       if let driverLicenseDetailedInfo = scanningResult?.driverLicenseDetailedInfo {
           scanningResultDict["driverLicenseDetailedInfo"] = serializeDriverLicenseDetailedInfo(driverLicenseDetailedInfo)
       }
@@ -287,7 +320,7 @@ class BlinkIdSerializationUtilities {
           "effectiveDate": serializeDateResult(vehicleClassInfo?.effectiveDate),
           "expiryDate":  serializeDateResult(vehicleClassInfo?.expiryDate),
           "licenceType": serializeStringType(vehicleClassInfo?.licenceType),
-          "vehicleClass": serializeStringType(vehicleClassInfo?.vehicleClass as? String)
+          "vehicleClass": serializeStringType(vehicleClassInfo?.vehicleClass)
       ]
       return vehicleClassInfoDict.compactMapValues { $0 }
   }
@@ -302,15 +335,17 @@ class BlinkIdSerializationUtilities {
   }
   
   static func serializeSingleSideScanningResult(_ singleSideScanningResult: SingleSideScanningResult?) -> Dictionary<String, Any> {
+      guard let singleSideScanningResult else { return [:] }
+      
       let singleSideScanningDict: [String: Any?] = [
-              "barcode": serializeBarcodeResult(singleSideScanningResult?.barcode),
-              "barcodeInputImage": encodeImage(singleSideScanningResult?.barcodeInputImage?.uiImage),
-              "documentImage": encodeImage(singleSideScanningResult?.documentImage?.uiImage),
-              "faceImage": serializeDetailedCroppedImageResult(singleSideScanningResult?.faceImage),
-              "inputImage": encodeImage(singleSideScanningResult?.inputImage?.uiImage),
-              "mrz": serializeMrzResult(singleSideScanningResult?.mrz),
-              "signatureImage": serializeDetailedCroppedImageResult(singleSideScanningResult?.signatureImage),
-              "viz": serializeVizResult(singleSideScanningResult?.viz)
+              "barcode": serializeBarcodeResult(singleSideScanningResult.barcode),
+              "barcodeInputImage": encodeImage(singleSideScanningResult.barcodeInputImage?.uiImage),
+              "documentImage": encodeImage(singleSideScanningResult.documentImage?.uiImage),
+              "faceImage": serializeDetailedCroppedImageResult(singleSideScanningResult.faceImage),
+              "inputImage": encodeImage(singleSideScanningResult.inputImage?.uiImage),
+              "mrz": serializeMrzResult(singleSideScanningResult.mrz),
+              "signatureImage": serializeDetailedCroppedImageResult(singleSideScanningResult.signatureImage),
+              "viz": serializeVizResult(singleSideScanningResult.viz)
           ]
       
       return singleSideScanningDict.compactMapValues { $0 }
@@ -343,7 +378,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 }
@@ -535,7 +571,7 @@ class BlinkIdSerializationUtilities {
             if let dateOfIssue = vizResult.dateOfIssue {
                 vizResultDict["dateOfIssue"] = serializeDateResult(dateOfIssue)
             }
-            vizResultDict["dependentsInfo"] = vizResult.dependentsInfo.compactMap(serializeDependentInfo(_:))
+            vizResultDict["dependentsInfo"] = vizResult.dependentsInfo?.compactMap(serializeDependentInfo(_:))
             if let documentAdditionalNumber = vizResult.documentAdditionalNumber {
                 vizResultDict["documentAdditionalNumber"] = serializeStringResult(documentAdditionalNumber)
             }
@@ -638,6 +674,36 @@ class BlinkIdSerializationUtilities {
             if let nationalInsuranceNumber = vizResult.nationalInsuranceNumber {
                 vizResultDict["nationalInsuranceNumber"] = serializeStringResult(nationalInsuranceNumber)
             }
+            if let dateOfEntry = vizResult.dateOfEntry {
+                vizResultDict["dateOfEntry"] = serializeDateResult(dateOfEntry)
+            }
+            if let localityCode = vizResult.localityCode {
+                vizResultDict["localityCode"] = serializeStringResult(localityCode)
+            }
+            if let maidenName = vizResult.maidenName {
+                vizResultDict["maidenName"] = serializeStringResult(maidenName)
+            }
+            if let municipalityCode = vizResult.municipalityCode {
+                vizResultDict["municipalityCode"] = serializeStringResult(municipalityCode)
+            }
+            if let municipalityOfRegistration = vizResult.municipalityOfRegistration {
+                vizResultDict["municipalityOfRegistration"] = serializeStringResult(municipalityOfRegistration)
+            }
+            if let pollingStationCode = vizResult.pollingStationCode {
+                vizResultDict["pollingStationCode"] = serializeStringResult(pollingStationCode)
+            }
+            if let registrationCenterCode = vizResult.registrationCenterCode {
+                vizResultDict["registrationCenterCode"] = serializeStringResult(registrationCenterCode)
+            }
+            if let sectionCode = vizResult.sectionCode {
+                vizResultDict["sectionCode"] = serializeStringResult(sectionCode)
+            }
+            if let stateCode = vizResult.stateCode {
+                vizResultDict["stateCode"] = serializeStringResult(stateCode)
+            }
+            if let stateName = vizResult.stateName {
+                vizResultDict["stateName"] = serializeStringResult(stateName)
+            }
         }
         return vizResultDict
     }

package/ios/BlinkidReactNative.mm

@@ -33,7 +33,7 @@ RCT_EXPORT_MODULE()
     return dict;
 }
 
-- (void)performScan:(NSString *)blinkIdSdkSettings blinkIdSessionSettings:(NSString *)blinkIdSessionSettings blinkIdUiSettings:(NSString *)blinkIdUiSettings classFilter:(NSString *)classFilter resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+- (void)performScan:(nonnull NSString *)blinkIdSdkSettings blinkIdSessionSettings:(nonnull NSString *)blinkIdSessionSettings blinkIdScanningUxSettings:(nonnull NSString *)blinkIdScanningUxSettings classFilter:(nonnull NSString *)classFilter resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
     
     dispatch_async(dispatch_get_main_queue(), ^{
         UIWindow *keyWindow = nil;
@@ -55,10 +55,10 @@ RCT_EXPORT_MODULE()
         
         [self->moduleImplementation
          performScan:keyWindow.rootViewController
-         blinkIdSdkSettings:[self createDictionaryFromBlinkIdObject: blinkIdSdkSettings]
-         blinkIdSessionSettings:[self createDictionaryFromBlinkIdObject: blinkIdSessionSettings]
-         blinkIdUiSettings:[self createDictionaryFromBlinkIdObject:blinkIdUiSettings]
-         classFilterSettings:[self createDictionaryFromBlinkIdObject: classFilter]
+         blinkIdSdkSettings:[self createDictionaryFromBlinkIdObject:blinkIdSdkSettings]
+         blinkIdSessionSettings:[self createDictionaryFromBlinkIdObject:blinkIdSessionSettings]
+         blinkIdScanningUxSettings:[self createDictionaryFromBlinkIdObject:blinkIdScanningUxSettings]
+         classFilterSettings:[self createDictionaryFromBlinkIdObject:classFilter]
          onResolve:^(NSString * _Nonnull result) {
             resolve(@[result]);
         } onReject:^(NSString * _Nonnull error) {
@@ -81,7 +81,22 @@ RCT_EXPORT_MODULE()
     }];
 }
 
+- (void)loadBlinkIdSdk:(nonnull NSString *)blinkIdSdkSettings resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [self->moduleImplementation loadSdk:[self createDictionaryFromBlinkIdObject:blinkIdSdkSettings] onResolve:^(NSString * _Nonnull) {
+        resolve(@"");
+    } onReject:^(NSString * _Nonnull error) {
+        reject(@"BlinkIdIosError", error, nil);
+    }];
+}
+
 
+- (void)unloadBlinkIdSdk:(BOOL)deleteCachedResources resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [self->moduleImplementation unloadSdk:deleteCachedResources onResolve:^(NSString * _Nonnull) {
+        resolve(@"");
+    } onReject:^(NSString * _Nonnull error) {
+        reject(@"BlinkIdIosError", error, nil);
+    }];
+}
 
 - (NSDictionary *)createDictionaryFromBlinkIdObject:(NSString *)jsonString {
     NSError *jsonError;

package/ios/BlinkidReactNativeModule.swift

@@ -17,39 +17,69 @@ import BlinkIDUX
     private var cancellables = Set<AnyCancellable>()
     private var classFilterDict: [String: Any]?
     
-    @objc public func performScan(_ rootVc: UIViewController, blinkIdSdkSettings: [String: Any], blinkIdSessionSettings: [String: Any], blinkIdUiSettings: [String: Any], classFilterSettings: [String: Any], onResolve: @escaping (String) -> Void, onReject: @escaping (String) -> Void) {
+    private var blinkIdSdk: BlinkIDSdk?
+    
+    @objc public func loadSdk(_ blinkIdSdkSettings: [String: Any], onResolve: @escaping (String) -> Void, onReject: @escaping (String) -> Void) {
+        Task {
+            do {
+                let _ = try await ensureLoadedSdk(blinkIdSdkSettings)
+                onResolve("")
+            } catch {
+                onReject(error.localizedDescription)
+            }
+        }
+    }
+    
+    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!") }
+            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()
+            } else {
+                await BlinkIDSdk.terminateBlinkIDSdk()
+            }
+            blinkIdSdk = nil
+            onResolve("")
+        }
+    }
+    
+    @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) {
         Task {
             do {
                 
-                guard let sdkSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdSdkSettings(blinkIdSdkSettings) else {
-                    onReject("Could not initialize the SDK!")
+                blinkIdSdk = try await ensureLoadedSdk(blinkIdSdkSettings)
+                guard let blinkIdSdk = blinkIdSdk else {
+                    onReject("The SDK is not loaded!")
                     return
                 }
-                
                 let sessionSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdSessionSettings(blinkIdSessionSettings)
                 classFilterDict = classFilterSettings
                 
-                let sdkInstance = try await BlinkIDSdk.createBlinkIDSdk(withSettings: sdkSettings)
                 let analyzer = try await BlinkIDAnalyzer(
-                    sdk: sdkInstance,
+                    sdk: blinkIdSdk,
                     blinkIdSessionSettings: sessionSettings,
                     eventStream: BlinkIDEventStream(),
                     classFilter: self
                 )
-                
-                var shouldShowIntroductionAlert = true
-                if let showOnboardingDialog = blinkIdUiSettings["showOnboardingDialog"] as? Bool {
-                    shouldShowIntroductionAlert = showOnboardingDialog
-                }
-                var shouldShowHelpButton = true
-                if let showHelpButton = blinkIdUiSettings["showHelpButton"] as? Bool {
-                    shouldShowHelpButton = showHelpButton
-                }
+                await addReactNativePinglet(with: analyzer.sessionNumber)
                 
                 let scanningUxModel = await BlinkIDUXModel(
                     analyzer: analyzer,
-                    shouldShowIntroductionAlert: shouldShowIntroductionAlert,
-                    showHelpButton: shouldShowHelpButton)
+                    uxSettings: BlinkIdDeserializationUtilities.deserializeBlinkIdUxScanningSettings(blinkIdScanningUxSettings),
+                    sessionNumber: analyzer.sessionNumber)
+                
                 await scanningUxModel.$result
                     .sink { [weak self] scanningResultState in
                         if let scanningResultState {
@@ -62,6 +92,9 @@ import BlinkIDUX
                                 }
                             }
                             else {
+                                Task {
+                                    await BlinkIDSdk.terminateBlinkIDSdk()
+                                }
                                 DispatchQueue.main.async {
                                     onReject("Scanning has been canceled")
                                     rootVc.dismiss(animated: true)
@@ -74,7 +107,11 @@ import BlinkIDUX
                 
                 self.presentScanningUI(scanningUxModel, rootVc)
             } catch {
-                onReject(error.localizedDescription)
+                if let sdkError = error as? InvalidLicenseKeyError {
+                    onReject(sdkError.message)
+                } else {
+                    onReject(error.localizedDescription)
+                }
             }
         }
     }
@@ -82,16 +119,17 @@ import BlinkIDUX
     @objc public func performDirectApiScan(blinkIdSdkSettings: [String: Any], blinkIdSessionSettings: [String: Any], firstImage: String, secondImage: String?, onResolve: @escaping (String) -> Void, onReject: @escaping (String) -> Void) {
         Task{
             do {
-                guard let sdkSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdSdkSettings(blinkIdSdkSettings) else {
-                    onReject("Could not initialize the SDK!")
+                blinkIdSdk = try await ensureLoadedSdk(blinkIdSdkSettings)
+                guard let blinkIdSdk = blinkIdSdk else {
+                    onReject("The BlinkID SDK is not initialized!")
                     return
                 }
-                
                 var sessionSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdSessionSettings(blinkIdSessionSettings)
                 sessionSettings.inputImageSource = .photo
                 
-                let blinkidSdk = try await BlinkIDSdk.createBlinkIDSdk(withSettings: sdkSettings)
-                let session = try await blinkidSdk.createScanningSession(sessionSettings: sessionSettings)
+                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.")
@@ -113,7 +151,11 @@ import BlinkIDUX
                     }
                 }
             } catch {
-                onReject(error.localizedDescription)
+                if let sdkError = error as? InvalidLicenseKeyError {
+                    onReject(sdkError.message)
+                } else {
+                    onReject(error.localizedDescription)
+                }
             }
         }
         
@@ -126,6 +168,14 @@ import BlinkIDUX
             rootVc.present(viewController, animated: true)
         }
     }
+    
+    private func addReactNativePinglet(with sessionNumber: Int) async {
+        await PingManager.shared.addPinglet(pinglet: WrapperProductInfoPinglet(wrapperProduct: .crossplatformreactnative), sessionNumber: sessionNumber)
+    }
+}
+
+enum BlinkIdReactNativeError: Error {
+    case incorrectArgument(message: String)
 }
 
 extension BlinkidReactNativeModule: BlinkIDClassFilter {