@regulaforensics/face-sdk 8.4.1336-rc → 8.4.1343-nightly

package/RNFaceSDK.podspec

@@ -5,7 +5,7 @@ source = File.join(__dir__, 'ios')
 
 Pod::Spec.new do |s|
   s.name         = 'RNFaceSDK'
-  s.version      = '8.4.1336-rc'
+  s.version      = '8.4.1343-nightly'
   s.summary      = package['description']
   s.license      = package['license']
 
@@ -16,6 +16,6 @@ Pod::Spec.new do |s|
   s.ios.deployment_target = '13.0'
   s.source_files = [ 'ios/**/*.swift', 'ios/**/RN*.m' ]
   s.exclude_files = [ 'ios/CDVFaceSDK.swift' ]
-  s.dependency 'FaceSDKStage', '9.8.4815'
+  s.dependency 'FaceSDKNightly', '9.9.4841'
   s.dependency 'React'
 end

package/android/build.gradle

@@ -20,7 +20,7 @@ android {
 rootProject.allprojects {
     repositories {
         maven {
-            url "https://maven.regulaforensics.com/RegulaDocumentReader/Stage"
+            url "https://maven.regulaforensics.com/RegulaDocumentReader/Nightly"
         }
     }
 }
@@ -29,7 +29,7 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+'
     //noinspection GradleDependency
-    implementation('com.regula.face:api:8.4.5337'){
+    implementation('com.regula.face:api:8.4.5342'){
         transitive = true
     }
 }

package/android/cordova.gradle

@@ -6,13 +6,13 @@ android {
 
 repositories {
     maven {
-        url "https://maven.regulaforensics.com/RegulaDocumentReader/Stage"
+        url "https://maven.regulaforensics.com/RegulaDocumentReader/Nightly"
     }
 }
 
 dependencies {
     //noinspection GradleDependency
-    implementation('com.regula.face:api:8.4.5337'){
+    implementation('com.regula.face:api:8.4.5342'){
         transitive = true
     }
 }

package/android/src/main/{java → kotlin}/com/regula/plugin/facesdk/Config.kt

@@ -17,22 +17,23 @@ import com.regula.facesdk.enums.RecordingProcess
 import org.json.JSONArray
 import org.json.JSONObject
 
-fun setFaceCaptureConfig(builder: FaceCaptureConfiguration.Builder, config: JSONObject) = config.forEach { k, v ->
-    when (k) {
-        "copyright" -> builder.setCopyright(v as Boolean)
-        "cameraSwitchEnabled" -> builder.setCameraSwitchEnabled(v as Boolean)
-        "closeButtonEnabled" -> builder.setCloseButtonEnabled(v as Boolean)
-        "torchButtonEnabled" -> builder.setTorchButtonEnabled(v as Boolean)
-        "vibrateOnSteps" -> builder.setVibrateOnStep(v as Boolean)
-        "detectOcclusion" -> builder.setDetectOcclusion(v as Boolean)
-        "showFaceAnimation" -> builder.setShowFaceAnimation(v as Boolean)
-        "preventScreenRecording" -> builder.setPreventScreenRecording(v as Boolean)
-        "cameraPositionAndroid" -> builder.setCameraId(v.toInt())
-        "screenOrientation" -> builder.setScreenOrientation(*screenOrientationArrayFromJSON(v as JSONArray))
-        "timeout" -> builder.setTimeout(v.toFloat())
-        "holdStillDuration" -> builder.setHoldStillDuration(v.toFloat())
+fun setFaceCaptureConfig(builder: FaceCaptureConfiguration.Builder, config: JSONObject) =
+    config.forEach { k, v ->
+        when (k) {
+            "copyright" -> builder.setCopyright(v as Boolean)
+            "cameraSwitchEnabled" -> builder.setCameraSwitchEnabled(v as Boolean)
+            "closeButtonEnabled" -> builder.setCloseButtonEnabled(v as Boolean)
+            "torchButtonEnabled" -> builder.setTorchButtonEnabled(v as Boolean)
+            "vibrateOnSteps" -> builder.setVibrateOnStep(v as Boolean)
+            "detectOcclusion" -> builder.setDetectOcclusion(v as Boolean)
+            "showFaceAnimation" -> builder.setShowFaceAnimation(v as Boolean)
+            "preventScreenRecording" -> builder.setPreventScreenRecording(v as Boolean)
+            "cameraPositionAndroid" -> builder.setCameraId(v.toInt())
+            "screenOrientation" -> builder.setScreenOrientation(*screenOrientationArrayFromJSON(v as JSONArray))
+            "timeout" -> builder.setTimeout(v.toFloat())
+            "holdStillDuration" -> builder.setHoldStillDuration(v.toFloat())
+        }
     }
-}
 
 fun getFaceCaptureConfig(input: FaceCaptureConfiguration) = mapOf(
     "copyright" to input.hasCopyright(),
@@ -49,25 +50,26 @@ fun getFaceCaptureConfig(input: FaceCaptureConfiguration) = mapOf(
     "holdStillDuration" to input.holdStillDuration,
 ).toJson()
 
-fun setLivenessConfig(builder: LivenessConfiguration.Builder, config: JSONObject) = config.forEach { k, v ->
-    when (k) {
-        "copyright" -> builder.setCopyright(v as Boolean)
-        "cameraSwitchEnabled" -> builder.setCameraSwitchEnabled(v as Boolean)
-        "closeButtonEnabled" -> builder.setCloseButtonEnabled(v as Boolean)
-        "torchButtonEnabled" -> builder.setTorchButtonEnabled(v as Boolean)
-        "vibrateOnSteps" -> builder.setVibrateOnStep(v as Boolean)
-        "cameraPositionAndroid" -> builder.setCameraId(v.toInt())
-        "screenOrientation" -> builder.setScreenOrientation(*screenOrientationArrayFromJSON(v as JSONArray))
-        "locationTrackingEnabled" -> builder.setLocationTrackingEnabled(v as Boolean)
-        "preventScreenRecording" -> builder.setPreventScreenRecording(v as Boolean)
-        "attemptsCount" -> builder.setAttemptsCount(v.toInt())
-        "recordingProcess" -> builder.setRecordingProcess(RecordingProcess.values()[v.toInt()])
-        "livenessType" -> builder.setType(LivenessType.values()[v.toInt()])
-        "tag" -> builder.setTag(v as String)
-        "skipStep" -> builder.setSkipStep(*livenessSkipStepArrayFromJSON(v as JSONArray))
-        "metadata" -> builder.setMetadata(v as JSONObject)
+fun setLivenessConfig(builder: LivenessConfiguration.Builder, config: JSONObject) =
+    config.forEach { k, v ->
+        when (k) {
+            "copyright" -> builder.setCopyright(v as Boolean)
+            "cameraSwitchEnabled" -> builder.setCameraSwitchEnabled(v as Boolean)
+            "closeButtonEnabled" -> builder.setCloseButtonEnabled(v as Boolean)
+            "torchButtonEnabled" -> builder.setTorchButtonEnabled(v as Boolean)
+            "vibrateOnSteps" -> builder.setVibrateOnStep(v as Boolean)
+            "cameraPositionAndroid" -> builder.setCameraId(v.toInt())
+            "screenOrientation" -> builder.setScreenOrientation(*screenOrientationArrayFromJSON(v as JSONArray))
+            "locationTrackingEnabled" -> builder.setLocationTrackingEnabled(v as Boolean)
+            "preventScreenRecording" -> builder.setPreventScreenRecording(v as Boolean)
+            "attemptsCount" -> builder.setAttemptsCount(v.toInt())
+            "recordingProcess" -> builder.setRecordingProcess(RecordingProcess.values()[v.toInt()])
+            "livenessType" -> builder.setType(LivenessType.values()[v.toInt()])
+            "tag" -> builder.setTag(v as String)
+            "skipStep" -> builder.setSkipStep(*livenessSkipStepArrayFromJSON(v as JSONArray))
+            "metadata" -> builder.setMetadata(v as JSONObject)
+        }
     }
-}
 
 fun getLivenessConfig(input: LivenessConfiguration) = mapOf(
     "copyright" to input.hasCopyright(),
@@ -87,28 +89,28 @@ fun getLivenessConfig(input: LivenessConfiguration) = mapOf(
     "metadata" to input.metadata,
 ).toJson()
 
-fun setEnrollmentConfig(builder: EnrollmentConfiguration.Builder, config: JSONObject) = config.forEach { k, v ->
-    when (k) {
-        "copyright" -> builder.setCopyright(v as Boolean)
-        "cameraSwitchEnabled" -> builder.setCameraSwitchEnabled(v as Boolean)
-        "closeButtonEnabled" -> builder.setCloseButtonEnabled(v as Boolean)
-        "torchButtonEnabled" -> builder.setTorchButtonEnabled(v as Boolean)
-        "vibrateOnSteps" -> builder.setVibrateOnStep(v as Boolean)
-        "cameraPositionAndroid" -> builder.setCameraId(v.toInt())
-        "screenOrientation" -> builder.setScreenOrientation(*screenOrientationArrayFromJSON(v as JSONArray))
-        "locationTrackingEnabled" -> builder.setLocationTrackingEnabled(v as Boolean)
-        "preventScreenRecording" -> builder.setPreventScreenRecording(v as Boolean)
-        "attemptsCount" -> builder.setAttemptsCount(v.toInt())
-        "recordingProcess" -> builder.setRecordingProcess(RecordingProcess.values()[v.toInt()])
-        "livenessType" -> builder.setType(LivenessType.values()[v.toInt()])
-        "tag" -> builder.setTag(v as String)
-        "externalId" -> builder.setExternalId(v as String)
-        "groupId" -> builder.setGroupId(v as String)
-        "duplicatesThreshold" -> if (config.getBooleanOrNull("checkDuplicatesEnabled") == true) builder.enableCheckDuplicates(v.toFloat())
-        "skipStep" -> builder.setSkipStep(*livenessSkipStepArrayFromJSON(v as JSONArray))
-        "metadata" -> builder.setMetadata(v as JSONObject)
+fun setEnrollmentConfig(builder: EnrollmentConfiguration.Builder, config: JSONObject) =
+    config.forEach { k, v ->
+        when (k) {
+            "copyright" -> builder.setCopyright(v as Boolean)
+            "cameraSwitchEnabled" -> builder.setCameraSwitchEnabled(v as Boolean)
+            "closeButtonEnabled" -> builder.setCloseButtonEnabled(v as Boolean)
+            "torchButtonEnabled" -> builder.setTorchButtonEnabled(v as Boolean)
+            "vibrateOnSteps" -> builder.setVibrateOnStep(v as Boolean)
+            "cameraPositionAndroid" -> builder.setCameraId(v.toInt())
+            "screenOrientation" -> builder.setScreenOrientation(*screenOrientationArrayFromJSON(v as JSONArray))
+            "locationTrackingEnabled" -> builder.setLocationTrackingEnabled(v as Boolean)
+            "preventScreenRecording" -> builder.setPreventScreenRecording(v as Boolean)
+            "attemptsCount" -> builder.setAttemptsCount(v.toInt())
+            "recordingProcess" -> builder.setRecordingProcess(RecordingProcess.values()[v.toInt()])
+            "livenessType" -> builder.setType(LivenessType.values()[v.toInt()])
+            "tag" -> builder.setTag(v as String)
+            "skipStep" -> builder.setSkipStep(*livenessSkipStepArrayFromJSON(v as JSONArray))
+            "metadata" -> builder.setMetadata(v as JSONObject)
+            "person" -> builder.setPerson(personFromJSON(v as JSONObject))
+            "searchFilter" -> builder.setSearchFilter(searchPersonFilterFromJSON(v as JSONObject))
+        }
     }
-}
 
 fun getEnrollmentConfig(input: EnrollmentConfiguration) = mapOf(
     "copyright" to input.hasCopyright(),
@@ -124,36 +126,35 @@ fun getEnrollmentConfig(input: EnrollmentConfiguration) = mapOf(
     "recordingProcess" to input.recordingProcess.ordinal,
     "livenessType" to input.type.ordinal,
     "tag" to input.tag,
-    "externalId" to input.externalId,
-    "groupId" to input.groupId,
-    "checkDuplicatesEnabled" to input.isCheckDuplicatesEnabled,
-    "duplicatesThreshold" to input.duplicatesThreshold,
     "skipStep" to generateLivenessSkipStepArray(input.skipStep),
     "metadata" to input.metadata,
+    "person" to generatePerson(input.person),
+    "searchFilter" to generateSearchPersonFilter(input.searchFilter),
 ).toJson()
 
-fun setVerificationConfig(builder: VerificationConfiguration.Builder, config: JSONObject) = config.forEach { k, v ->
-    when (k) {
-        "copyright" -> builder.setCopyright(v as Boolean)
-        "cameraSwitchEnabled" -> builder.setCameraSwitchEnabled(v as Boolean)
-        "closeButtonEnabled" -> builder.setCloseButtonEnabled(v as Boolean)
-        "torchButtonEnabled" -> builder.setTorchButtonEnabled(v as Boolean)
-        "vibrateOnSteps" -> builder.setVibrateOnStep(v as Boolean)
-        "cameraPositionAndroid" -> builder.setCameraId(v.toInt())
-        "screenOrientation" -> builder.setScreenOrientation(*screenOrientationArrayFromJSON(v as JSONArray))
-        "locationTrackingEnabled" -> builder.setLocationTrackingEnabled(v as Boolean)
-        "preventScreenRecording" -> builder.setPreventScreenRecording(v as Boolean)
-        "attemptsCount" -> builder.setAttemptsCount(v.toInt())
-        "recordingProcess" -> builder.setRecordingProcess(RecordingProcess.values()[v.toInt()])
-        "livenessType" -> builder.setType(LivenessType.values()[v.toInt()])
-        "tag" -> builder.setTag(v as String)
-        "personId" -> builder.setPrivateProperty("u", v as String)
-        "groupId" -> builder.setGroupId(v as String)
-        "threshold" -> builder.setThreshold(v.toFloat())
-        "skipStep" -> builder.setSkipStep(*livenessSkipStepArrayFromJSON(v as JSONArray))
-        "metadata" -> builder.setMetadata(v as JSONObject)
+fun setVerificationConfig(builder: VerificationConfiguration.Builder, config: JSONObject) =
+    config.forEach { k, v ->
+        when (k) {
+            "copyright" -> builder.setCopyright(v as Boolean)
+            "cameraSwitchEnabled" -> builder.setCameraSwitchEnabled(v as Boolean)
+            "closeButtonEnabled" -> builder.setCloseButtonEnabled(v as Boolean)
+            "torchButtonEnabled" -> builder.setTorchButtonEnabled(v as Boolean)
+            "vibrateOnSteps" -> builder.setVibrateOnStep(v as Boolean)
+            "cameraPositionAndroid" -> builder.setCameraId(v.toInt())
+            "screenOrientation" -> builder.setScreenOrientation(*screenOrientationArrayFromJSON(v as JSONArray))
+            "locationTrackingEnabled" -> builder.setLocationTrackingEnabled(v as Boolean)
+            "preventScreenRecording" -> builder.setPreventScreenRecording(v as Boolean)
+            "attemptsCount" -> builder.setAttemptsCount(v.toInt())
+            "recordingProcess" -> builder.setRecordingProcess(RecordingProcess.values()[v.toInt()])
+            "livenessType" -> builder.setType(LivenessType.values()[v.toInt()])
+            "tag" -> builder.setTag(v as String)
+            "skipStep" -> builder.setSkipStep(*livenessSkipStepArrayFromJSON(v as JSONArray))
+            "metadata" -> builder.setMetadata(v as JSONObject)
+            "personId" -> builder.setPrivateProperty("u", v as String)
+            "externalId" -> builder.setPrivateProperty("v", v as String)
+            "threshold" -> builder.setThreshold(v.toFloat())
+        }
     }
-}
 
 fun getVerificationConfig(input: VerificationConfiguration) = mapOf(
     "copyright" to input.hasCopyright(),
@@ -169,19 +170,20 @@ fun getVerificationConfig(input: VerificationConfiguration) = mapOf(
     "recordingProcess" to input.recordingProcess.ordinal,
     "livenessType" to input.type.ordinal,
     "tag" to input.tag,
-    "personId" to input.personId,
-    "groupId" to input.groupId,
-    "threshold" to input.threshold,
     "skipStep" to generateLivenessSkipStepArray(input.skipStep),
     "metadata" to input.metadata,
+    "personId" to input.personId,
+    "externalId" to input.externalId,
+    "threshold" to input.threshold,
 ).toJson()
 
-fun setMatchFacesConfig(builder: MatchFacesConfiguration.Builder, config: JSONObject) = config.forEach { k, v ->
-    when (k) {
-        "processingMode" -> builder.setProcessingMode(ProcessingMode.values()[v.toInt()])
-        "locationTrackingEnabled" -> builder.setLocationTrackingEnabled(v as Boolean)
+fun setMatchFacesConfig(builder: MatchFacesConfiguration.Builder, config: JSONObject) =
+    config.forEach { k, v ->
+        when (k) {
+            "processingMode" -> builder.setProcessingMode(ProcessingMode.values()[v.toInt()])
+            "locationTrackingEnabled" -> builder.setLocationTrackingEnabled(v as Boolean)
+        }
     }
-}
 
 fun getMatchFacesConfig(input: MatchFacesConfiguration) = mapOf(
     "processingMode" to input.processingMode.ordinal,
@@ -209,7 +211,9 @@ fun getImageQualityCharacteristic(
         "ImageWidth" -> ImageQualityGroup.ImageCharacteristic.imageWidthWithRange(min, max)
         "ImageHeight" -> ImageQualityGroup.ImageCharacteristic.imageHeightWithRange(min, max)
         "ImageWidthToHeight" -> ImageQualityGroup.ImageCharacteristic.imageWidthToHeightWithRange(min, max)
+
         "ImageChannelsNumber" -> ImageQualityGroup.ImageCharacteristic.imageChannelsNumberWithValue(min)
+
         "PaddingRatio" -> ImageQualityGroup.ImageCharacteristic.paddingRatio(min, max)
         "ArtFace" -> ImageQualityGroup.ImageCharacteristic.artFace()
 
@@ -259,9 +263,9 @@ fun getImageQualityCharacteristic(
         "BackgroundUniformity" -> ImageQualityGroup.QualityBackground.backgroundUniformity()
         "ShadowsOnBackground" -> ImageQualityGroup.QualityBackground.shadowsOnBackground()
         "OtherFaces" -> ImageQualityGroup.QualityBackground.otherFaces()
-        "BackgroundColorMatch" -> color?.let { ImageQualityGroup.QualityBackground.backgroundColorMatchWithColor(it) }
-            ?: ImageQualityGroup.QualityBackground.backgroundColorMatch()
-
+        "BackgroundColorMatch" -> color?.let {
+            ImageQualityGroup.QualityBackground.backgroundColorMatchWithColor(it)
+        } ?: ImageQualityGroup.QualityBackground.backgroundColorMatch()
         else -> throw Exception("ImageQualityCharacteristicName not found")
     }
     return customRange?.let { result.withCustomRange(it.min, it.max) } ?: result

package/android/src/main/{java/com/regula/plugin/facesdk/Main.kt → kotlin/com/regula/plugin/facesdk/Implementation.kt}

@@ -50,7 +50,6 @@ fun methodCall(method: String, callback: (Any?) -> Unit): Any = when (method) {
     "startLiveness" -> startLiveness(callback, argsNullable(0))
     "startEnrollment" -> startEnrollment(callback, args(0))
     "startVerification" -> startVerification(callback, args(0))
-    "enrollWithTrustedPhoto" -> enrollWithTrustedPhoto(callback, args(0))
     "stopLiveness" -> stopLiveness()
     "matchFaces" -> matchFaces(callback, args(0), argsNullable(1))
     "splitComparedFaces" -> splitComparedFaces(callback, args(0), args(1))
@@ -106,12 +105,14 @@ fun getLocale(callback: Callback) = callback(Instance().locale)
 fun setLocale(locale: String?) = locale.let { Instance().locale = it }
 
 fun setLocalizationDictionary(dictionary: JSONObject?) {
-    localizationCallbacks = LocalizationCallbacks { if (dictionary?.has(it) == true) dictionary.getString(it) else null }
+    localizationCallbacks =
+        LocalizationCallbacks { if (dictionary?.has(it) == true) dictionary.getString(it) else null }
     Instance().setLocalizationCallback(localizationCallbacks!!)
 }
 
 fun setRequestHeaders(headers: JSONObject?) {
-    networkInterceptorListener = NetworkInterceptorListener { headers?.forEach { k, v -> it.header(k, v as String) } }
+    networkInterceptorListener =
+        NetworkInterceptorListener { headers?.forEach { k, v -> it.header(k, v as String) } }
     Instance().setNetworkInterceptorListener(networkInterceptorListener)
 }
 
@@ -127,7 +128,11 @@ fun initialize(callback: Callback, config: JSONObject?) =
         Instance().initialize(context, initConfigFromJSON(config), initCompletion(callback))
     else
         getBleWrapper()?.let {
-            Instance().initialize(context, InitializationBleDeviceConfiguration(it), initCompletion(callback))
+            Instance().initialize(
+                context,
+                InitializationBleDeviceConfiguration(it),
+                initCompletion(callback)
+            )
         } ?: callback(generateInitCompletion(false, InitException(InitErrorCode.LICENSE_IS_NULL)))
 
 fun deinitialize() = Instance().deinitialize()
@@ -174,10 +179,6 @@ fun startVerification(callback: Callback, config: JSONObject) = Instance().start
     livenessNotificationCompletion(),
 )
 
-fun enrollWithTrustedPhoto(callback: Callback, config: JSONObject) = Instance().enrollWithTrustedPhoto(
-    enrollmentRequestFromJSON(config),
-) { callback(generateEnrollmentResponse(it)) }
-
 fun stopLiveness() = Instance().stopLivenessProcessing(context)
 
 fun matchFaces(callback: Callback, request: JSONObject, config: JSONObject?) = config?.let {
@@ -255,7 +256,9 @@ fun getPersonImage(callback: Callback, personId: String, imageId: String) = db.g
     personId,
     imageId,
     object : PersonDBCallback<ByteArray> {
-        override fun onSuccess(data: ByteArray?) = callback(generatePersonDBResponse(data.toBase64()!!, null))
+        override fun onSuccess(data: ByteArray?) =
+            callback(generatePersonDBResponse(data.toBase64()!!, null))
+
         override fun onFailure(error: String) = callback(generatePersonDBResponse(null, error))
     }
 )
@@ -310,7 +313,8 @@ fun getGroup(callback: Callback, groupId: String) = db.getGroup(
     databaseItemCompletion(callback, ::generatePersonGroup)
 )
 
-fun getGroups(callback: Callback) = db.getGroups(databasePageCompletion(callback, ::generatePersonGroup))
+fun getGroups(callback: Callback) =
+    db.getGroups(databasePageCompletion(callback, ::generatePersonGroup))
 
 fun getGroupsForPage(callback: Callback, page: Int, size: Int) = db.getGroupsForPage(
     page,
@@ -355,7 +359,9 @@ fun getPersonsInGroupForPage(
 fun searchPerson(callback: Callback, searchPersonRequest: JSONObject) = db.searchPerson(
     searchPersonRequestFromJSON(searchPersonRequest),
     object : PersonDBCallback<List<SearchPerson>> {
-        override fun onSuccess(data: List<SearchPerson>?) = callback(generatePersonDBResponse(data.toJsonNullable(::generateSearchPerson)!!, null))
+        override fun onSuccess(data: List<SearchPerson>?) =
+            callback(generatePersonDBResponse(data.toJsonNullable(::generateSearchPerson)!!, null))
+
         override fun onFailure(error: String) = callback(generatePersonDBResponse(null, error))
     }
 )
@@ -364,7 +370,12 @@ fun initCompletion(callback: Callback) = FaceInitializationCompletion { success,
     if (success) {
         // initializes MutableLiveData
         Instance().customization.uiConfigurationLive
-        Instance().setVideoEncoderCompletion { id, s -> sendEvent(videoEncoderCompletionEvent, generateVideoEncoderCompletion(id, s)) }
+        Instance().setVideoEncoderCompletion { id, s ->
+            sendEvent(
+                videoEncoderCompletionEvent,
+                generateVideoEncoderCompletion(id, s)
+            )
+        }
         Instance().setOnClickListener { sendEvent(onCustomButtonTappedEvent, it.tag.toInt()) }
     }
     callback(generateInitCompletion(success, error))
@@ -384,7 +395,8 @@ fun livenessCompletion(callback: Callback) = LivenessCallback {
 
 fun livenessNotificationCompletion() = object : LivenessNotificationCallback() {
     override fun onCameraSwitched(cameraId: Int) = sendEvent(cameraSwitchEvent, cameraId)
-    override fun onLivenessNotification(ln: LivenessNotification) = sendEvent(livenessNotificationEvent, generateLivenessNotification(ln))
+    override fun onLivenessNotification(ln: LivenessNotification) =
+        sendEvent(livenessNotificationEvent, generateLivenessNotification(ln))
 }
 
 fun matchFacesCompletion(callback: Callback) = MatchFaceCallback {
@@ -395,39 +407,49 @@ fun detectFacesCompletion(callback: Callback) = DetectFacesCompletion {
     callback(generateDetectFacesResponse(it))
 }
 
-fun verificationCompletion(callback: Callback) = { livenessResponse: LivenessResponse, verificationResponse: VerificationResponse? ->
-    callback(mapOf(
-        "livenessResponse" to generateLivenessResponse(livenessResponse),
-        "verificationResponse" to generateVerificationResponse(verificationResponse),
-    ).toJson())
-}
+fun verificationCompletion(callback: Callback) =
+    { livenessResponse: LivenessResponse, verificationResponse: VerificationResponse? ->
+        callback(
+            mapOf(
+                "livenessResponse" to generateLivenessResponse(livenessResponse),
+                "verificationResponse" to generateVerificationResponse(verificationResponse),
+            ).toJson()
+        )
+    }
 
-fun enrollmentCompletion(callback: Callback) = { livenessResponse: LivenessResponse, enrollmentResponse: EnrollmentResponse? ->
-    callback(mapOf(
-        "livenessResponse" to generateLivenessResponse(livenessResponse),
-        "enrollmentResponse" to generateEnrollmentResponse(enrollmentResponse),
-    ).toJson())
-}
+fun enrollmentCompletion(callback: Callback) =
+    { livenessResponse: LivenessResponse, enrollmentResponse: EnrollmentResponse? ->
+        callback(
+            mapOf(
+                "livenessResponse" to generateLivenessResponse(livenessResponse),
+                "enrollmentResponse" to generateEnrollmentResponse(enrollmentResponse),
+            ).toJson()
+        )
+    }
 
-fun <T> databaseItemCompletion(callback: Callback, toJson: ((T?) -> JSONObject?)?) = object : PersonDBCallback<T> {
-    override fun onSuccess(data: T?) = callback(generatePersonDBResponse(toJson?.let { it(data) } ?: true, null))
-    override fun onFailure(error: String) = callback(generatePersonDBResponse(null, error))
-}
+fun <T> databaseItemCompletion(callback: Callback, toJson: ((T?) -> JSONObject?)?) =
+    object : PersonDBCallback<T> {
+        override fun onSuccess(data: T?) =
+            callback(generatePersonDBResponse(toJson?.let { it(data) } ?: true, null))
 
-fun <T : DbBaseItem?> databasePageCompletion(callback: Callback, toJson: (T?) -> JSONObject?) = object : PersonDBCallback<PageableItemList<List<T>?, T>> {
-    override fun onSuccess(data: PageableItemList<List<T>?, T>?) = callback(
-        generatePersonDBResponse(
-            mapOf(
-                "items" to data!!.itemsList.toJsonNullable(toJson),
-                "page" to data.page,
-                "totalPages" to data.totalPages,
-            ).toJson(),
-            null
+        override fun onFailure(error: String) = callback(generatePersonDBResponse(null, error))
+    }
+
+fun <T : DbBaseItem?> databasePageCompletion(callback: Callback, toJson: (T?) -> JSONObject?) =
+    object : PersonDBCallback<PageableItemList<List<T>?, T>> {
+        override fun onSuccess(data: PageableItemList<List<T>?, T>?) = callback(
+            generatePersonDBResponse(
+                mapOf(
+                    "items" to data!!.itemsList.toJsonNullable(toJson),
+                    "page" to data.page,
+                    "totalPages" to data.totalPages,
+                ).toJson(),
+                null
+            )
         )
-    )
 
-    override fun onFailure(error: String) = callback(generatePersonDBResponse(null, error))
-}
+        override fun onFailure(error: String) = callback(generatePersonDBResponse(null, error))
+    }
 
 // Weak references
 var localizationCallbacks: LocalizationCallbacks? = null