@microblink/blinkid-react-native 7.6.2 → 8000.0.0

package/ios/Serialization/BlinkIdDeserializationUtils.swift

@@ -0,0 +1,492 @@
+//
+//  BlinkIdDeserializationUtilities.swift
+//  BlinkidReactNative
+//
+//  Created by Milan Parađina on 22.05.2025..
+//
+
+import Foundation
+import BlinkID
+import UIKit
+import BlinkIDUX
+
+struct BlinkIdDeserializationUtils {
+    static func deserializeBlinkIdSdkSettings(_ sdkSettingsDict: Dictionary<String, Any>?) -> BlinkIDSdkSettings? {
+        var blinkidSdkSettings: BlinkIDSdkSettings?
+        
+        if let licenseKey = sdkSettingsDict?["licenseKey"] as? String {
+            blinkidSdkSettings = BlinkIDSdkSettings(licenseKey: licenseKey)
+        }
+        
+        if let licensee = sdkSettingsDict?["licensee"] as? String {
+            blinkidSdkSettings?.licensee = licensee
+        }
+        
+        if let helloLogEnabled = sdkSettingsDict?["helloLogEnabled"] as? Bool {
+            blinkidSdkSettings?.helloLogEnabled = helloLogEnabled
+        }
+        
+        if let downloadResources = sdkSettingsDict?["downloadResources"] as? Bool {
+            blinkidSdkSettings?.downloadResources = downloadResources
+        }
+        
+        if let resourceDownloadUrl = sdkSettingsDict?["resourceDownloadUrl"] as? String {
+            blinkidSdkSettings?.resourceDownloadUrl = resourceDownloadUrl
+        }
+        
+        if let resourceLocalFolder = sdkSettingsDict?["resourceLocalFolder"] as? String {
+            blinkidSdkSettings?.resourceLocalFolder = resourceLocalFolder
+        }
+        
+        if let bundleURL = sdkSettingsDict?["bundleIdentifier"] as? String,
+           let bundle: Bundle = Bundle.init(identifier: bundleURL) {
+            blinkidSdkSettings?.bundleURL = bundle.bundleURL
+        }
+
+        if sdkSettingsDict?["resourceRequestTimeout"] != nil {
+            blinkidSdkSettings?.resourceRequestTimeout = BlinkID.RequestTimeout.default
+        }
+        
+        if let microblinkProxyUrl = sdkSettingsDict?["microblinkProxyURL"] as? String
+            ?? sdkSettingsDict?["microblinkProxyUrl"] as? String {
+            blinkidSdkSettings?.microblinkProxyURL = microblinkProxyUrl
+        }
+        
+        return blinkidSdkSettings
+    }
+    
+    static func deserializeBlinkIdSessionSettings(_ sessionSettingsDict: Dictionary<String, Any>?, isFromDirectApi: Bool = false) -> BlinkIDSessionSettings {
+        var blinkidSessionSettings = BlinkIDSessionSettings()
+        
+        if let scanningSettings = sessionSettingsDict?["scanningSettings"] as? Dictionary<String, Any> {
+            blinkidSessionSettings.scanningSettings = deserializeBlinkIdScanningSettings(scanningSettings)
+        }
+        
+        if let scanningMode = sessionSettingsDict?["scanningMode"] as? String {
+            blinkidSessionSettings.scanningMode = deseralizeScanningMode(scanningMode)
+        }
+        
+        if let stepTimeoutDuration = sessionSettingsDict?["stepTimeoutDuration"] as? Int {
+            blinkidSessionSettings.stepTimeoutDuration = Double(stepTimeoutDuration) / 1000.0
+        }
+        
+        if let inactivityTimeoutDuration = sessionSettingsDict?["inactivityTimeoutDuration"] as? Int {
+            blinkidSessionSettings.inactivityTimeoutDuration = Double(inactivityTimeoutDuration) / 1000.0
+        }
+        
+        if isFromDirectApi {
+            blinkidSessionSettings.inputImageSource = .photo
+        }
+        
+        return blinkidSessionSettings
+    }
+    
+    static func deserializeBlinkIdScanningSettings(_ scanningSettingsDict: Dictionary<String, Any>?) -> ScanningSettings {
+        var scanningSettings = ScanningSettings()
+        guard let scanningSettingsDict else {
+            return scanningSettings
+        }
+
+        if scanningSettingsDict.keys.contains("barcodeModule") {
+            if let barcodeModuleDict = scanningSettingsDict["barcodeModule"] as? Dictionary<String, Any> {
+                scanningSettings.barcodeModule = deserializeBarcodeModule(barcodeModuleDict)
+            } else {
+                scanningSettings.barcodeModule = nil
+            }
+        }
+
+        if scanningSettingsDict.keys.contains("documentCaptureModule") {
+            if let documentCaptureDict = scanningSettingsDict["documentCaptureModule"] as? Dictionary<String, Any> {
+                scanningSettings.documentCaptureModule = deserializeDocumentCaptureModule(documentCaptureDict)
+            } else {
+                scanningSettings.documentCaptureModule = nil
+            }
+        }
+
+        if scanningSettingsDict.keys.contains("mrzModule") {
+            if let mrzModuleDict = scanningSettingsDict["mrzModule"] as? Dictionary<String, Any> {
+                scanningSettings.mrzModule = deserializeMrzModule(mrzModuleDict)
+            } else {
+                scanningSettings.mrzModule = nil
+            }
+        }
+
+        if scanningSettingsDict.keys.contains("vizModule") {
+            if let vizModuleDict = scanningSettingsDict["vizModule"] as? Dictionary<String, Any> {
+                scanningSettings.vizModule = deserializeVizModule(vizModuleDict)
+            } else {
+                scanningSettings.vizModule = nil
+            }
+        }
+
+        if let maxAllowedMismatchesPerField = scanningSettingsDict["maxAllowedMismatchesPerField"] as? Int {
+            scanningSettings.maxAllowedMismatchesPerField = maxAllowedMismatchesPerField
+        }
+
+        return scanningSettings
+    }
+    
+    static func deserializeBarcodeModule(_ barcodeModuleDict: Dictionary<String, Any>) -> BarcodeModuleSettings {
+        var barodeModuleSettings = BarcodeModuleSettings()
+        
+        if let barcodeImageReturnEnabled = barcodeModuleDict["barcodeImageReturnEnabled"] as? Bool {
+            barodeModuleSettings.barcodeImageReturnEnabled = barcodeImageReturnEnabled
+        }
+        
+        if let code128ScanningEnabled = barcodeModuleDict["code128ScanningEnabled"] as? Bool {
+            barodeModuleSettings.code128ScanningEnabled = code128ScanningEnabled
+        }
+        
+        if let code39ScanningEnabled = barcodeModuleDict["code39ScanningEnabled"] as? Bool {
+            barodeModuleSettings.code39ScanningEnabled = code39ScanningEnabled
+        }
+        
+        if let dataMatrixScanningEnabled = barcodeModuleDict["dataMatrixScanningEnabled"] as? Bool {
+            barodeModuleSettings.dataMatrixScanningEnabled = dataMatrixScanningEnabled
+        }
+        
+        if let ean13ScanningEnabled = barcodeModuleDict["ean13ScanningEnabled"] as? Bool {
+            barodeModuleSettings.ean13ScanningEnabled = ean13ScanningEnabled
+        }
+        
+        if let ean8ScanningEnabled = barcodeModuleDict["ean8ScanningEnabled"] as? Bool {
+            barodeModuleSettings.ean8ScanningEnabled = ean8ScanningEnabled
+        }
+        
+        if let itfScanningEnabled = barcodeModuleDict["itfScanningEnabled"] as? Bool {
+            barodeModuleSettings.itfScanningEnabled = itfScanningEnabled
+        }
+        
+        if let pdf417ScanningEnabled = barcodeModuleDict["pdf417ScanningEnabled"] as? Bool {
+            barodeModuleSettings.pdf417ScanningEnabled = pdf417ScanningEnabled
+        }
+        
+        if let presenceMandatory = barcodeModuleDict["presenceMandatory"] as? Bool {
+            barodeModuleSettings.presenceMandatory = presenceMandatory
+        }
+        
+        if let qrScanningEnabled = barcodeModuleDict["qrScanningEnabled"] as? Bool {
+            barodeModuleSettings.qrScanningEnabled = qrScanningEnabled
+        }
+        
+        if let upcaScanningEnabled = barcodeModuleDict["upcaScanningEnabled"] as? Bool {
+            barodeModuleSettings.upcaScanningEnabled = upcaScanningEnabled
+        }
+        
+        if let upceScanningEnabled = barcodeModuleDict["upceScanningEnabled"] as? Bool {
+            barodeModuleSettings.upceScanningEnabled = upceScanningEnabled
+        }
+        
+        return barodeModuleSettings
+    }
+    
+    static func deserializeDocumentCaptureModule(_ documentCaptureModuleDict: Dictionary<String, Any>) -> DocumentCaptureModuleSettings {
+        var documentCaptureSettings = DocumentCaptureModuleSettings()
+        
+        if let blurSensitivityLevel = documentCaptureModuleDict["blurSensitivityLevel"] as? String {
+            documentCaptureSettings.blurSensitivityLevel = deserializeSensitivityLevel(blurSensitivityLevel)
+        }
+        
+        if let glareSensitivityLevel = documentCaptureModuleDict["glareSensitivityLevel"] as? String {
+            documentCaptureSettings.glareSensitivityLevel = deserializeSensitivityLevel(glareSensitivityLevel)
+        }
+        
+        if let tiltSensitivityLevel = documentCaptureModuleDict["tiltSensitivityLevel"] as? String {
+            documentCaptureSettings.tiltSensitivityLevel = deserializeSensitivityLevel(tiltSensitivityLevel)
+        }
+        
+        if let documentImageReturnEnabled = documentCaptureModuleDict["documentImageReturnEnabled"] as? Bool {
+            documentCaptureSettings.documentImageReturnEnabled = documentImageReturnEnabled
+        }
+        
+        if let dotsPerInch = documentCaptureModuleDict["dotsPerInch"] as? Int {
+            documentCaptureSettings.dotsPerInch = DPI(dotsPerInch)
+        }
+        
+        if let extensionFactor = documentCaptureModuleDict["extensionFactor"] as? Double {
+            documentCaptureSettings.extensionFactor = Float(extensionFactor)
+        }
+        
+        if let faceImageExtractionEnabled = documentCaptureModuleDict["faceImageExtractionEnabled"] as? Bool {
+            documentCaptureSettings.faceImageExtractionEnabled = faceImageExtractionEnabled
+        }
+        
+        if let faceImagePresenceMandatory = documentCaptureModuleDict["faceImagePresenceMandatory"] as? Bool {
+            documentCaptureSettings.faceImagePresenceMandatory = faceImagePresenceMandatory
+        }
+        
+        if let imageWithBlurRejected = documentCaptureModuleDict["imageWithBlurRejected"] as? Bool {
+            documentCaptureSettings.imageWithBlurRejected = imageWithBlurRejected
+        }
+        
+        if let imageWithGlareRejected = documentCaptureModuleDict["imageWithGlareRejected"] as? Bool {
+            documentCaptureSettings.imageWithGlareRejected = imageWithGlareRejected
+        }
+        
+        if let imageWithHandOcclusionRejected = documentCaptureModuleDict["imageWithHandOcclusionRejected"] as? Bool {
+            documentCaptureSettings.imageWithHandOcclusionRejected = imageWithHandOcclusionRejected
+        }
+        
+        if let imageWithPoorLightingRejected = documentCaptureModuleDict["imageWithPoorLightingRejected"] as? Bool {
+            documentCaptureSettings.imageWithPoorLightingRejected = imageWithPoorLightingRejected
+        }
+        
+        if let inputImageCropped = documentCaptureModuleDict["inputImageCropped"] as? Bool {
+            documentCaptureSettings.inputImageCropped = inputImageCropped
+        }
+        
+        if let inputImageReturnEnabled = documentCaptureModuleDict["inputImageReturnEnabled"] as? Bool {
+            documentCaptureSettings.inputImageReturnEnabled = inputImageReturnEnabled
+        }
+        
+        if let passportDataPageScanOnly = documentCaptureModuleDict["passportDataPageScanOnly"] as? Bool {
+            documentCaptureSettings.passportDataPageScanOnly = passportDataPageScanOnly
+        }
+        
+        if let secondSideWithNoExtractableDataSkipped = documentCaptureModuleDict["secondSideWithNoExtractableDataSkipped"] as? Bool {
+            documentCaptureSettings.secondSideWithNoExtractableDataSkipped = secondSideWithNoExtractableDataSkipped
+        }
+        
+        if let unsupportedDocumentsAllowed = documentCaptureModuleDict["unsupportedDocumentsAllowed"] as? Bool {
+            documentCaptureSettings.unsupportedDocumentsAllowed = unsupportedDocumentsAllowed
+        }
+        
+        if let inputImageMargin = documentCaptureModuleDict["inputImageMargin"] as? Double {
+            documentCaptureSettings.inputImageMargin = Float(inputImageMargin)
+        }
+        
+        if let tiltSensitivityLevel = documentCaptureModuleDict["tiltSensitivityLevel"] as? String {
+            documentCaptureSettings.tiltSensitivityLevel = deserializeSensitivityLevel(tiltSensitivityLevel)
+        }
+        return documentCaptureSettings
+    }
+    
+    static func deserializeSensitivityLevel(_ sensitivityLevelRawValue: String) -> SensitivityLevel {
+        switch sensitivityLevelRawValue {
+        case "off": return .off
+        case "low": return .low
+        case "mid": return .mid
+        case "high": return .high
+        default: return .mid
+        }
+    }
+    
+    static func deserializeMrzModule(_ mrzModuleDict: Dictionary<String, Any>) -> MrzModuleSettings {
+        
+        var mrzModuleSettings = MrzModuleSettings()
+        
+        if let presenceMandatory = mrzModuleDict["presenceMandatory"] as? Bool {
+            mrzModuleSettings.presenceMandatory = presenceMandatory
+        }
+        
+        return mrzModuleSettings
+    }
+    
+    static func deserializeVizModule(_ vizModuleDict: Dictionary<String, Any>) -> VizModuleSettings {
+        var vizModuleSettings = VizModuleSettings()
+        
+        if let characterValidationEnabled = vizModuleDict["characterValidationEnabled"] as? Bool {
+            vizModuleSettings.characterValidationEnabled = characterValidationEnabled
+        }
+        
+        if let presenceMandatory = vizModuleDict["presenceMandatory"] as? Bool {
+            vizModuleSettings.presenceMandatory = presenceMandatory
+        }
+        
+        if let signatureImageExtractionEnabled = vizModuleDict["signatureImageExtractionEnabled"] as? Bool {
+            vizModuleSettings.signatureImageExtractionEnabled = signatureImageExtractionEnabled
+        }
+        
+        if let resultAggregationEnabled = vizModuleDict["resultAggregationEnabled"] as? Bool {
+            vizModuleSettings.resultAggregationEnabled = resultAggregationEnabled
+        }
+        
+        return vizModuleSettings
+    }
+    
+    static func deserializeRedactionSettings(_ redactionDict: Dictionary<String, Any>) -> RedactionSettings? {
+        var redactionSettings: RedactionSettings?
+        if let fieldsRaw = redactionDict["fields"] as? [String] {
+            let fieldTypes: [FieldType] = fieldsRaw.compactMap { FieldType(rawValue: $0) }
+            redactionSettings = RedactionSettings(fields: fieldTypes)
+        } else {
+            return nil
+        }
+
+        if let modeRaw = redactionDict["mode"] as? String,
+           let mode = RedactionMode(rawValue: modeRaw) {
+            redactionSettings?.mode = mode
+        }
+
+        if let redactBarcode = redactionDict["redactBarcode"] as? Bool
+            ?? redactionDict["redactBarcodeResult"] as? Bool {
+            redactionSettings?.redactBarcode = redactBarcode
+        }
+
+        if let redactMrz = redactionDict["redactMrz"] as? Bool
+            ?? redactionDict["redactMrzResult"] as? Bool {
+            redactionSettings?.redactMrz = redactMrz
+        }
+
+        if let documentNumberRedactionDict = redactionDict["documentNumberRedactionSettings"] as? Dictionary<String, Any> {
+            redactionSettings?.documentNumberRedactionSettings =
+                deserializeDocumentNumberRedactionSettings(documentNumberRedactionDict)
+        }
+
+        return redactionSettings
+    }
+    
+    static func deserializeDocumentNumberRedactionSettings(_ documentNumberRedactionSettingsDict: Dictionary<String, Any>) -> DocumentNumberRedactionSettings {
+        var documentNumberRedactionSettings = DocumentNumberRedactionSettings()
+        
+        if let prefixDigitsVisible = documentNumberRedactionSettingsDict["prefixDigitsVisible"] as? Int {
+            documentNumberRedactionSettings.prefixDigitsVisible = UInt8(prefixDigitsVisible)
+        }
+        
+        if let suffixDigitsVisible = documentNumberRedactionSettingsDict["suffixDigitsVisible"] as? Int {
+            documentNumberRedactionSettings.suffixDigitsVisible = UInt8(suffixDigitsVisible)
+        }
+        
+        return documentNumberRedactionSettings
+    }
+    
+    
+    static func deserializeBlinkIdUxScanningSettings(_ scanningUxSettingsDict: Dictionary<String, Any>?) -> ScanningUXSettings {
+        guard let scanningUxSettingsDict = scanningUxSettingsDict,
+              !scanningUxSettingsDict.isEmpty else {
+            return ScanningUXSettings()
+        }
+
+        let preferredCameraRaw = scanningUxSettingsDict["preferredCamera"] as? String
+        return ScanningUXSettings(
+            showIntroductionAlert: scanningUxSettingsDict["showOnboardingDialog"] as? Bool ?? true,
+            showHelpButton: scanningUxSettingsDict["showHelpButton"] as? Bool ?? true,
+            preferredCameraPosition: deserializePreferredCameraPosition(preferredCameraRaw ?? "back"),
+            allowHapticFeedback: scanningUxSettingsDict["allowHapticFeedback"] as? Bool ?? true)
+    }
+    
+    static func deserializePreferredCameraPosition(_ value: String) -> Camera.CameraPosition {
+        switch value {
+        case "front":
+            return Camera.CameraPosition.front
+        case "back":
+            return Camera.CameraPosition.back
+        default:
+            return Camera.CameraPosition.back
+        }
+    }
+    
+    static func deseralizeScanningMode(_ value: String) -> ScanningMode {
+        switch value {
+        case "single":
+            return ScanningMode.single
+        case "automatic":
+            return ScanningMode.automatic
+        default:
+            return ScanningMode.automatic
+        }
+    }
+    
+    
+    static func deserializeDetailedFieldType(_ detailedFieldTypeDict: Dictionary<String, Any>?) -> DetailedFieldType? {
+        if let fieldType = detailedFieldTypeDict?["fieldType"] as? String,
+           let alphabetType = detailedFieldTypeDict?["alphabetType"] as? String,
+           let fieldTypeValue = FieldType.init(rawValue: fieldType),
+           let alphabetTypeValue = AlphabetType(rawValue: alphabetType) {
+            return DetailedFieldType(
+                fieldType: fieldTypeValue,
+                alphabetType: alphabetTypeValue)
+        }
+        return nil
+    }
+    
+    static func deserializeRedactionSettingsResolver(
+        _ redactionResolverDict: Dictionary<String, Any>?,
+        _ classInfo: BlinkID.BlinkIDSDK.DocumentClassInfo
+    ) -> RedactionSettings? {
+
+        guard let redactionResolverDict,
+              let documentRedactionList = redactionResolverDict["documentRedactionList"] as? [[String: Any]] else { return nil }
+        
+        for redactionDict in documentRedactionList {
+            if shouldUseRedactionSettings(redactionDict, classInfo: classInfo) {
+                return deserializeRedactionSettings(redactionDict)
+            }
+        }
+
+        return nil
+    }
+    
+    private static func shouldUseRedactionSettings(
+        _ redactionDict: [String: Any],
+        classInfo: BlinkID.BlinkIDSDK.DocumentClassInfo
+    ) -> Bool {
+        if let documentFilters = redactionDict["documentFilter"] as? [[String: Any]] {
+            if documentFilters.isEmpty {
+                return true
+            }
+            return documentFilters.contains { filterDict in
+                matchClassFilter(filterDict, classInfo: classInfo)
+            }
+        }
+
+        if let documentFilter = redactionDict["documentFilter"] as? Dictionary<String, Any> {
+            return matchClassFilter(documentFilter, classInfo: classInfo)
+        }
+
+        return true
+    }
+    
+    static func deserializeClassFilter(_ classFilterDictArr: Dictionary<String, Any>?, _ classInfo: BlinkID.BlinkIDSDK.DocumentClassInfo) -> Bool {
+        guard let sanitizedDict = sanitizeDictionary(classFilterDictArr) else { return true}
+        var includeClass = false
+        var excludeClass = true
+        
+        if let includedClasses = sanitizedDict["includeDocuments"] as? Array<Dictionary<String, Any>> {
+            for includedClass in includedClasses {
+                includeClass = includeClass || matchClassFilter(includedClass, classInfo: classInfo)
+            }
+        } else {
+            includeClass = true
+        }
+        
+        if let excludedClasses = sanitizedDict["excludeDocuments"] as? Array<Dictionary<String, Any>> {
+            for excludedClass in excludedClasses {
+                excludeClass = excludeClass && !matchClassFilter(excludedClass, classInfo: classInfo)
+            }
+        }
+        
+        return includeClass && excludeClass
+    }
+    
+    static func matchClassFilter(_ filteredClass: Dictionary<String, Any>, classInfo: BlinkID.BlinkIDSDK.DocumentClassInfo) -> Bool {
+        let country = filteredClass["country"] as? String
+        let type = filteredClass["documentType"] as? String
+        let region = filteredClass["region"] as? String
+        
+        return (country == nil || classInfo.country == Country.init(rawValue: country!)) &&
+        (type == nil || classInfo.documentType == DocumentType.init(rawValue: type!)) &&
+        (region == nil || classInfo.region == Region.init(rawValue: region!))
+    }
+    
+    static func sanitizeDictionary(_ dictionary: Dictionary<String, Any>?) -> Dictionary<String, Any>? {
+        if let dictionary = dictionary {
+            var sanitized = dictionary
+            for (key, value) in dictionary {
+                if value is NSNull {
+                    sanitized[key] = nil
+                }
+            }
+            return sanitized
+        }
+        return dictionary
+    }
+    
+    static func deserializeBase64Image(_ base64Image: String?) -> UIImage? {
+        if let base64Image = base64Image,
+        let data = Data(base64Encoded: base64Image, options: .ignoreUnknownCharacters) {
+            return UIImage(data: data)
+        }
+        return nil
+    }
+}