@microblink/blinkid-react-native 7.5.0 → 7.6.0

package/README.md

@@ -20,6 +20,7 @@ However, since the wrapper is open source, you can add the features you need on
 - [Plugin usage](#plugin-usage)
 - [Plugin specifics](#plugin-specifics)
   - [Scanning methods](#scanning-methods)
+  - [SDK loading & unloading](#sdk-loading--unloading)
   - [BlinkID Settings](#blinkid-settings)
   - [BlinkID Results](#blinkid-results)
 - [Additional information and Support](#additional-information-and-support)
@@ -30,7 +31,7 @@ A valid license key is required to initialize the BlinkID plugin. A free trial l
 
 ## <a name="requirements"></a> Requirements
 
-- BlinkID React Native was built and tested with [React Native v0.79.0](https://github.com/facebook/react-native/releases/tag/v0.79.0)
+- BlinkID React Native was built and tested with [React Native v0.82.1](https://github.com/facebook/react-native/releases/tag/v0.82.1)
 - For additional help with React-Native setup, view the official documentation [here](https://reactnative.dev/docs/set-up-your-environment).
 
 **Device requirements**
@@ -348,6 +349,28 @@ The optional second image Base64 string - `String`: needed if the information fr
 
 - The implementation of the `performDirectApiScanning` method can be viewed here in the [index.tsx](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/index.tsx) file.
 
+### <a name="sdk-loading--unloading"></a> SDK loading & unloading
+The BlinkID SDK also contains methods for loading and unloading. These methods can be called before the scanning methods (mentioned above), and are helpful to preload the neccessary resources and decrease the waiting time for the scanning session, but also to remove any resources after the scanning sessions ends.
+
+**The `loadBlinkIdSdk` method**
+
+The `loadBlinkIdSdk` method creates or retrieves the instance of the BlinkID SDK It initializes and loads the BlinkID SDK if it is not already loaded.
+
+It can be called in advance to **preload** the SDK before starting a scanning session. Doing so reduces loading time for the `performScan` and `performDirectApiScan` methods, since all resources will already be available and the license verified.
+
+If the method is not called beforehand, it will still be automatically invoked on the native platform channels when a scan starts. However, the initial scan may take longer due to resource loading and license checks.
+
+It takes the following parameter: [BlinkIdSdkSettings](#blinkid-settings), which is explained in more details below.
+
+**The `unloadBlinkIdSdk` method**
+
+The `unloadBlinkIdSdk` platform method terminates the BlinkID SDK and releases all associated resources. It safely shuts down the SDK instance and frees any allocated memory.
+After calling this method, you must reinitialize the SDK (by calling `loadBlinkIdSdk` or any of the scanning methods) before using it again.
+
+If set to `true` (`false` is default), the method performs a **complete cleanup**, including deletion of all downloaded and cached SDK resources from the device.
+
+This method is automatically called after each successful scan session.
+
 ### <a name="blinkid-settings"></a> BlinkID Settings
 The BlinkID SDK contains various settings, modifying different parts of scanning process:
 1. [BlinkID SDK settings](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/blinkIdSettings.ts#L14) - `BlinkIdSdkSettings` \

package/android/.project

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>microblink_blinkid-react-native</name>
+	<comment>Project microblink_blinkid-react-native created by Buildship.</comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1753105404889</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>

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.5.0")
+  implementation("com.microblink:blinkid-ux:7.6.0")
 }
 
 react {

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

@@ -28,11 +28,14 @@ import kotlin.time.Duration.Companion.milliseconds
 import kotlinx.parcelize.Parcelize
 import kotlinx.parcelize.RawValue
 import android.graphics.Bitmap
+import android.graphics.Camera
 import android.util.Base64
 import com.microblink.blinkid.core.session.InputImageSource
 import com.microblink.blinkid.core.settings.DocumentNumberAnonymizationSettings
 import com.microblink.core.network.RequestTimeout
 import com.microblink.ux.UiSettings
+import com.microblink.ux.camera.CameraLensFacing
+import com.microblink.ux.camera.CameraSettings
 import org.json.JSONArray
 import org.json.JSONObject
 
@@ -275,19 +278,32 @@ object BlinkIdDeserializationUtilities {
   }
 
 
-  fun deserializeBlinkIdUxSettings(
-    blinkidUxSettingsMap: JSONObject?,
+  fun deserializeBlinkIdScanningUxSettings(
+    blinkidScanningUxSettingsMap: JSONObject?,
     classFilterMap: JSONObject?
   ): BlinkIdUxSettings {
-    if (blinkidUxSettingsMap == null) return BlinkIdUxSettings()
+    if (blinkidScanningUxSettingsMap == null) return BlinkIdUxSettings()
     return BlinkIdUxSettings(
-      stepTimeoutDuration = (blinkidUxSettingsMap.optInt(
+      stepTimeoutDuration = (blinkidScanningUxSettingsMap.optInt(
         "stepTimeoutDuration",
         15000
       ).milliseconds),
+      allowHapticFeedback = blinkidScanningUxSettingsMap.optBoolean("allowHapticFeedback", true),
       classFilter = classFilterMap?.let { CustomClassFilter(it.toString()) },
     )
   }
+  fun deserializeCameraSettings(blinkidScanningUxSettingsMap: JSONObject?): CameraSettings {
+    if (blinkidScanningUxSettingsMap == null) return CameraSettings()
+    return CameraSettings(lensFacing = deserializeLensFacingCamera(blinkidScanningUxSettingsMap.optString("preferredCamera")))
+  }
+
+  fun deserializeLensFacingCamera(lens: String?): CameraLensFacing {
+    return when (lens?.lowercase()) {
+      "front" -> CameraLensFacing.LensFacingFront
+      "back" -> CameraLensFacing.LensFacingBack
+      else -> CameraLensFacing.LensFacingBack
+    }
+  }
 
   fun deserializeClassFilter(
     classFilterMap: JSONObject?,

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

@@ -135,6 +135,9 @@ object BlinkIdSerializationUtilities {
     scanningResult?.vehicleType?.let {
       scanningResultJson.put("vehicleType", serializeStringResult(it))
     }
+    scanningResult?.vehicleOwner?.let {
+      scanningResultJson.put("vehicleOwner", serializeStringResult(it))
+    }
     scanningResult?.eligibilityCategory?.let {
       scanningResultJson.put("eligibilityCategory", serializeStringResult(it))
     }
@@ -162,6 +165,36 @@ object BlinkIdSerializationUtilities {
     scanningResult?.dateOfExpiry?.let {
       scanningResultJson.put("dateOfExpiry", serializeDateResult(it))
     }
+    scanningResult?.dateOfEntry?.let {
+      scanningResultJson.put("dateOfEntry", serializeDateResult(it))
+    }
+    scanningResult?.localityCode?.let {
+      scanningResultJson.put("localityCode", serializeStringResult(it))
+    }
+    scanningResult?.maidenName?.let {
+      scanningResultJson.put("maidenName", serializeStringResult(it))
+    }
+    scanningResult?.municipalityCode?.let {
+      scanningResultJson.put("municipalityCode", serializeStringResult(it))
+    }
+    scanningResult?.municipalityOfRegistration?.let {
+      scanningResultJson.put("municipalityOfRegistration", serializeStringResult(it))
+    }
+    scanningResult?.pollingStationCode?.let {
+      scanningResultJson.put("pollingStationCode", serializeStringResult(it))
+    }
+    scanningResult?.registrationCenterCode?.let {
+      scanningResultJson.put("registrationCenterCode", serializeStringResult(it))
+    }
+    scanningResult?.sectionCode?.let {
+      scanningResultJson.put("sectionCode", serializeStringResult(it))
+    }
+    scanningResult?.stateCode?.let {
+      scanningResultJson.put("stateCode", serializeStringResult(it))
+    }
+    scanningResult?.stateName?.let {
+      scanningResultJson.put("stateName", serializeStringResult(it))
+    }
     scanningResult?.dateOfExpiryPermanent?.let {
       scanningResultJson.put("dateOfExpiryPermanent", it)
     }
@@ -180,7 +213,6 @@ object BlinkIdSerializationUtilities {
         JSONArray(it.map { subResult -> serializeSubResult(subResult) })
       )
     }
-
     scanningResult?.inputImage(ScanningSide.First)?.let {
       scanningResultJson.put("firstInputImage", encodeBase64Image(it.bitmap))
     }
@@ -510,6 +542,36 @@ object BlinkIdSerializationUtilities {
     vizResult?.dateOfIssue?.let {
       vizResultJson.put("dateOfIssue", serializeDateResult(it))
     }
+    vizResult?.dateOfEntry?.let {
+      vizResultJson.put("dateOfEntry", serializeDateResult(it))
+    }
+    vizResult?.localityCode?.let {
+      vizResultJson.put("localityCode", serializeStringResult(it))
+    }
+    vizResult?.maidenName?.let {
+      vizResultJson.put("maidenName", serializeStringResult(it))
+    }
+    vizResult?.municipalityCode?.let {
+      vizResultJson.put("municipalityCode", serializeStringResult(it))
+    }
+    vizResult?.municipalityOfRegistration?.let {
+      vizResultJson.put("municipalityOfRegistration", serializeStringResult(it))
+    }
+    vizResult?.pollingStationCode?.let {
+      vizResultJson.put("pollingStationCode", serializeStringResult(it))
+    }
+    vizResult?.registrationCenterCode?.let {
+      vizResultJson.put("registrationCenterCode", serializeStringResult(it))
+    }
+    vizResult?.sectionCode?.let {
+      vizResultJson.put("sectionCode", serializeStringResult(it))
+    }
+    vizResult?.stateCode?.let {
+      vizResultJson.put("stateCode", serializeStringResult(it))
+    }
+    vizResult?.stateName?.let {
+      vizResultJson.put("stateName", serializeStringResult(it))
+    }
     vizResult?.dateOfExpiryPermanent?.let {
       vizResultJson.put("dateOfExpiryPermanent", it)
     }

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

@@ -20,6 +20,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import okhttp3.Dispatcher
 import org.json.JSONObject
 
 @ReactModule(name = BlinkidReactNativeModule.NAME)
@@ -27,17 +28,61 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
   NativeBlinkidReactNativeSpec(reactContext) {
   private val BLINKID_REQUEST_CODE = 1453
   private val BLINKID_ERROR_RESULT_CODE = "BlinkIdAndroid"
-
   var pendingPromise: Promise? = null
+  private var blinkIdSdk: BlinkIdSdk? = null
 
   override fun getName(): String {
     return NAME
   }
 
+  override fun loadBlinkIdSdk(
+    blinkIdSdkSettings: String?,
+    promise: Promise?
+  ) {
+    pendingPromise = promise
+    CoroutineScope(Dispatchers.Main).launch {
+      try {
+        val blinkIdSettingsJson = blinkIdSdkSettings?.let { JSONObject(it) }
+        ensureLoadedSdk(blinkIdSettingsJson)
+        pendingPromise?.resolve("")
+      } catch (error: Exception) {
+        blinkIdSdk = null
+        when (error) {
+          is LicenseLockedException -> {
+            pendingPromise?.reject(BLINKID_ERROR_RESULT_CODE, error.message)
+          }
+          else -> {
+            pendingPromise?.reject(BLINKID_ERROR_RESULT_CODE, error.message)
+          }
+        }
+      }
+    }
+  }
+
+  override fun unloadBlinkIdSdk(
+    deleteCachedResources: Boolean,
+    promise: Promise?
+  ) {
+    try {
+      pendingPromise = promise
+      if (deleteCachedResources) {
+          BlinkIdSdk.sdkInstance?.closeAndDeleteCachedAssets()
+        } else {
+          BlinkIdSdk.sdkInstance?.close()
+        }
+        blinkIdSdk = null
+        pendingPromise?.resolve("")
+    } catch (exception: Exception) {
+      blinkIdSdk = null
+      pendingPromise?.reject(BLINKID_ERROR_RESULT_CODE, exception.message, null)
+    }
+  }
+
   init {
     reactApplicationContext.addActivityEventListener(object : BaseActivityEventListener() {
+
       override fun onActivityResult(
-        activity: Activity?,
+        activity: Activity,
         requestCode: Int,
         resultCode: Int,
         data: Intent?
@@ -76,7 +121,7 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
   override fun performScan(
     blinkIdSdkSettings: String?,
     blinkIdSessionSettings: String?,
-    blinkIdUiSettings: String?,
+    blinkIdScanningUxSettings: String?,
     classFilter: String?,
     promise: Promise?
   ) {
@@ -86,7 +131,7 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
       val sdkSettingsJson = blinkIdSdkSettings?.let { JSONObject(it) }
       val sessionSettingsJson = blinkIdSessionSettings?.let { JSONObject(it) }
       val classFilterJson = classFilter?.let { JSONObject(it) }
-      val blinkIdUiSettingsJson = blinkIdUiSettings?.let { JSONObject(it) }
+      val blinkIdScanningUxJson = blinkIdScanningUxSettings?.let { JSONObject(it) }
       val sdkSettings = sdkSettingsJson?.let {
         BlinkIdDeserializationUtilities.deserializeBlinkIdSdkSettings(it)
       } ?: run {
@@ -94,25 +139,26 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
         return
       }
 
-      currentActivity?.applicationContext?.let {
-        val intent = MbBlinkIdScan().createIntent(
+      reactApplicationContext.currentActivity?.applicationContext?.let {
+      val intent = MbBlinkIdScan().createIntent(
           it,
           BlinkIdScanActivitySettings(
             sdkSettings = sdkSettings,
+            cameraSettings = BlinkIdDeserializationUtilities.deserializeCameraSettings(blinkIdScanningUxJson),
             scanningSessionSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdSessionSettings(
               sessionSettingsJson,
               false
             ),
-            uxSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdUxSettings(
-              sessionSettingsJson,
+            uxSettings = BlinkIdDeserializationUtilities.deserializeBlinkIdScanningUxSettings(
+              blinkIdScanningUxJson,
               classFilterJson,
             ),
-            showHelpButton = blinkIdUiSettingsJson?.optBoolean("showHelpButton", true)?: true,
-            showOnboardingDialog = blinkIdUiSettingsJson?.optBoolean("showOnboardingDialog", true) ?: true
+            showHelpButton = blinkIdScanningUxJson?.optBoolean("showHelpButton", true)?: true,
+            showOnboardingDialog = blinkIdScanningUxJson?.optBoolean("showOnboardingDialog", true) ?: true
           )
         )
         addReactNativePinglet(it)
-        currentActivity?.startActivityForResult(intent, BLINKID_REQUEST_CODE, null)
+        reactApplicationContext.startActivityForResult(intent, BLINKID_REQUEST_CODE, null)
       } ?: pendingPromise?.reject(BLINKID_ERROR_RESULT_CODE, "Activity not found.")
     } catch (error: Exception) {
       when (error) {
@@ -134,74 +180,54 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
     secondImage: String?,
     promise: Promise?
   ) {
+    pendingPromise = promise
     CoroutineScope(Dispatchers.Default).launch {
       try {
         val sdkSettingsJson = blinkIdSdkSettings?.let { JSONObject(it) }
         val sessionSettingsJson = blinkIdSessionSettings?.let { JSONObject(it) }
 
-        val sdkSettings =
-          BlinkIdDeserializationUtilities.deserializeBlinkIdSdkSettings(sdkSettingsJson)
-            ?: return@launch withContext(Dispatchers.Main) {
-              promise?.reject(BLINKID_ERROR_RESULT_CODE, "Invalid SDK settings")
-            }
-
-        val context = currentActivity?.applicationContext
+        val context = reactApplicationContext.applicationContext
           ?: return@launch withContext(Dispatchers.Main) {
             promise?.reject(BLINKID_ERROR_RESULT_CODE, "No activity")
           }
-
-        val sdkInit = BlinkIdSdk.initializeSdk(context, sdkSettings)
-
-        addReactNativePinglet(context)
-
-        when {
-          sdkInit.isSuccess -> {
-            val instance = sdkInit.getOrNull() ?: return@launch withContext(Dispatchers.Main) {
-              promise?.reject(BLINKID_ERROR_RESULT_CODE, "SDK returned null instance")
-            }
-
-            val session = instance.createScanningSession(
-              BlinkIdDeserializationUtilities.deserializeBlinkIdSessionSettings(
-                sessionSettingsJson,
-                true
-              )
-            )
-
-            val inputImages = listOfNotNull(
-              firstImage?.let { BlinkIdDeserializationUtilities.base64ToBitmap(it) },
-              secondImage?.let { BlinkIdDeserializationUtilities.base64ToBitmap(it) }
+        blinkIdSdk = ensureLoadedSdk(sdkSettingsJson)
+        blinkIdSdk?.let {
+          addReactNativePinglet(context)
+          val session = it.createScanningSession(
+            BlinkIdDeserializationUtilities.deserializeBlinkIdSessionSettings(
+              sessionSettingsJson,
+              true
             )
+          )
 
-            var result: Result<BlinkIdProcessResult>? = null
-
-            for (img in inputImages) {
-              result = session.process(InputImage.createFromBitmap(img))
-            }
+          val inputImages = listOfNotNull(
+            firstImage?.let { BlinkIdDeserializationUtilities.base64ToBitmap(it) },
+            secondImage?.let { BlinkIdDeserializationUtilities.base64ToBitmap(it) }
+          )
 
-            if (result?.isSuccess == true) {
-              val scanResult = session.getResult()
-              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.")
-              }
-            }
+          var result: Result<BlinkIdProcessResult>? = null
 
-            instance.close()
+          for (img in inputImages) {
+            result = session.process(InputImage.createFromBitmap(img))
           }
 
-          sdkInit.isFailure -> {
-            return@launch withContext(Dispatchers.Main) {
-              promise?.reject(BLINKID_ERROR_RESULT_CODE, sdkInit.exceptionOrNull()?.message)
+          if (result?.isSuccess == true) {
+            val scanResult = session.getResult()
+            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.")
             }
           }
-        }
 
+          it.close()
+          blinkIdSdk = null
+        }?:pendingPromise?.reject(BLINKID_ERROR_RESULT_CODE, "Reason: The BlinkID SDK is not initialized. Call the loadBlinkIdSdk() method to pre-load the SDK first, or try running the performDirectApiScan() method with a valid internet connection.", null)
       } catch (e: Exception) {
         withContext(Dispatchers.Main) {
           promise?.reject(BLINKID_ERROR_RESULT_CODE, e.message)
@@ -209,6 +235,32 @@ class BlinkidReactNativeModule(reactContext: ReactApplicationContext) :
       }
     }
   }
+
+  private suspend fun ensureLoadedSdk(blinkidSdkSettings: JSONObject?): BlinkIdSdk? {
+
+    blinkIdSdk?.let { return it }
+
+    val sdkSettings = BlinkIdDeserializationUtilities
+      .deserializeBlinkIdSdkSettings(blinkidSdkSettings)?: throw IllegalStateException("Incorrect SDK Settings.")
+
+    reactApplicationContext.currentActivity?.let {
+      val maybeInstance = BlinkIdSdk.initializeSdk(it, sdkSettings)
+      when {
+        maybeInstance.isSuccess -> {
+          blinkIdSdk = maybeInstance.getOrNull()
+          return blinkIdSdk
+        }
+
+        maybeInstance.isFailure -> {
+          blinkIdSdk = null
+          throw maybeInstance.exceptionOrNull() ?: IllegalStateException("SDK initialization failed.")
+        }
+      }
+    }?: throw IllegalStateException("Activity not available.")
+
+    return null
+  }
+
   private fun addReactNativePinglet(context: Context) {
     PingManager.getInstance(context).add(
       WrapperProductInfo(

package/ios/BlinkIdDeserializationUtilities.swift

@@ -7,6 +7,7 @@
 
 import Foundation
 import BlinkID
+import BlinkIDUX
 
 class BlinkIdDeserializationUtilities {
   static func deserializeBlinkIdSdkSettings(_ sdkSettingsDict: Dictionary<String, Any>?) -> BlinkIDSdkSettings? {
@@ -30,9 +31,9 @@ class BlinkIdDeserializationUtilities {
       if let resourceLocalFolder = sdkSettingsDict?["resourceLocalFolder"] as? String {
           blinkidSdkSettings?.resourceLocalFolder = resourceLocalFolder
       }
-      if let bundleURL = sdkSettingsDict?["bundleURL"] as? String,
-         let url = URL(string: bundleURL) {
-          blinkidSdkSettings?.bundleURL = url
+      if let bundleIdentifier = sdkSettingsDict?["bundleIdentifier"] as? String,
+         let bundle = Bundle.init(identifier: bundleIdentifier) {
+          blinkidSdkSettings?.bundleURL = bundle.bundleURL
       }
       if let resourceRequestTimeout = sdkSettingsDict?["resourceRequestTimeout"] as? Int {
           blinkidSdkSettings?.resourceRequestTimeout = BlinkID.RequestTimeout.default
@@ -157,6 +158,20 @@ class BlinkIdDeserializationUtilities {
       
       return croppedImageSettings
   }
+    static func deserializeBlinkIdUxScanningSettings(_ scanningUxSettingsDict: Dictionary<String, Any>?) -> ScanningUXSettings {
+        if let scanningUxSettingsDict = scanningUxSettingsDict,
+           let allowHapticFeedback = scanningUxSettingsDict["allowHapticFeedback"] as? Bool,
+           let preferredCameraPosition = scanningUxSettingsDict["preferredCamera"] as? String,
+           let showHelpButton = scanningUxSettingsDict["showHelpButton"] as? Bool,
+           let showIntroductionAlert = scanningUxSettingsDict["showOnboardingDialog"] as? Bool {
+            return ScanningUXSettings(
+                showIntroductionAlert: showIntroductionAlert,
+                showHelpButton: showHelpButton,
+                preferredCameraPosition: deserializePrefferedCameraPosition(preferredCameraPosition),
+                allowHapticFeedback: allowHapticFeedback)
+        }
+        return ScanningUXSettings()
+    }
   
   static func deserializeRecognitionModeFilter(_ recognitionModeFilterDict: Dictionary<String, Any>) -> RecognitionModeFilter {
       var recognitionModeFilter = RecognitionModeFilter()
@@ -324,6 +339,17 @@ class BlinkIdDeserializationUtilities {
             return ScanningMode.automatic
         }
     }
+    
+    static func deserializePrefferedCameraPosition(_ 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 sanitizeDictionary(_ dictionary: Dictionary<String, Any>?) -> Dictionary<String, Any>? {
       if let dictionary = dictionary {

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 }
@@ -639,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
     }