Face integration guide

The purpose of the Integration Guide is to give developers everything they need to set up and work with a minimally viable application using the Capture SDK.

Introduction 

The CaptureSDK is targeted to developers who want to use IDEMIA technologies within their mobile apps.

The main features are:

• Biometric captures

• Biometric coding

• Fingerprint capture and matching

• Biometric authentication and identification

• Identity documents reading

Adding the SDK to your project 

Gradle

Configure repository:

XMLbuildscript {    repositories {        maven {          url "$repositoryUrlMI"          credentials {              username "$artifactoryUserMI"              password "$artifactoryPasswordMI"          }        }        ...    }    ...}

repositoryUrlMI: Mobile Identity artifactory repository url

artifactoryUserMI: Mobile Identity artifactory username

artifactoryPasswordMI: Mobile Identity artifactory password

These properties can be obtained through Experience Portal(My Identity Proofing -> Access) and should be stored in local gradle.properties file. In such case credentials will not be included in source code. Configuration of properties:

XMLartifactoryUserMI=artifactory_userartifactoryPasswordMI=artifactory_credentialsrepositoryUrlMI=https://mi-artifactory.otlabs.fr/artifactory/smartsdk-android-local

More about gradle properties can be found here.

For biometric features the dependency is:

Groovyimplementation("morpho.mph_bio_sdk.android:SmartBio:version")

For document features the dependency is:

Groovyimplementation("morpho.mph_bio_sdk.android:SmartDoc:version")

For all features the dependency is:

Groovyimplementation("morpho.mph_bio_sdk.android:SmartSDK:version")

Version: artifact version

Components

The SDK comprises five distinct components:

1. BioCaptureHandler: Handles the capture of the biometrics through the camera of the device.

2. BioMatcherHandler: Handles the biometric coding and matching.

3. DocumentCaptureHandler (see: DocumentCaptureHandler): Handles the document reading features (like reading MRZ documents).

4. BioStoreDB: Repository to store biometric templates. (This component is optional, in case you don't want to implement your own database.)

5. ImageUtils: Handles the image format conversion, in case the integrator must change the image format or import an image.

6. LicenseManager: Handles the license management. Refer to License Manager for more details.

Access to BioCaptureHandler, BioMatcherHandler and DocumentCaptureHandler is through the Biometric Capture SDK entry points.

Design considerations 

• User permissions must be handled by the integrator. You must check that the app permissions are granted by the user if the Android version is higher than 23 (as detailed here).

• Remember: You must always have a valid license before using any method of this SDK. You can activate it through LicenseManager. Refer to License Manager for more details.

• Note: If your app is to run in low memory devices, you must add android:largeHeap="true" to your application.

• If you find that your project requires other native libraries, you must add in your gradle.properties file the following filter:

XMLandroid.useDeprecatedNdk=true

And in your build.gradle add filters for the desired ABI. For now, the SDK supports armeabi-v7a and arm64-v8a:

XMLdefaultConfig {        ....        ndk.abiFilters 'armeabi-v7a','arm64-v8a'    }

Prerequisites 

Skills required

The integration tasks should be done by developers with knowledge of:

• Android Studio

• Java for Android

• Android OS

Resources required

Integration may be performed on computers running Windows, Linux, or macOS.

The tools required are:

• Android Studio

• Android SDK tools: preferred latest version

• JDK: preferred latest version

• Android device (emulator is not supported)

• Minimum SDK version is 21

Biometric capture SDK structure 

The SDK's structure is displayed below.

Tips 

App size optimization

After adding the SDK to your project you will observe that the size of application has grown significantly. This is because the SDK now includes native libraries for two ABIs: armeabi-v7a and arm64-v8a. What is generated is an .apk file that deploys to Google Play. Your application will contain both application binary interfaces even if one is not used.

Android App Bundle is the solution for this issue. Instead of generating an .apk, it is possible to generate a bundle (.aab). When a user installs the application from the store that contains the bundle, only the required components for the user's specific device will be downloaded.

Additionally, the maximum size of the bundle increases to 150 MB (100 MB is still maximum size for .apk files).

No changes on Google Play are required - just upload .aab instead of .apk. Also, no development in the application project is required.

It is recommended that the bundle options be declared inside the Gradle file, for example:

XMLandroid {        ...    bundle {        density {            enableSplit true        }        abi {            enableSplit true        }        language {            enableSplit false        }    }}

More about app bundles can be found here.

License manager 

The purpose of this section is to show the API of the license management portion of the SDK, and expose the objects involved.

License manager 

The License manager is the main entry point to use the SDK. You can manage licenses through LicenseManager.

Note: A valid license is required before using any feature of the SDK.

provideLicenseManager

This method provides an instance of LicenseManager with a predefined LKMS profile. Operation with LicenseManager should be executed before starting capture.

Kotlinval manager: LicenseManager = LicenseManager.provideLicenseManager(LkmsProfileId, LkmsApiKey, lkmsUrl)

Activating license

This function takes care of making sure a valid license is stored on the device. This process is crucial and must occur each time before any SDK usage. In most cases it does not require any effort from integrator side. However, it might fail in some corner cases that are listed below.

Method handles license management on calling thread.

Callback solution:

Kotlinval activationResult = manager.activate(object : LicenseActivationListener {    override fun onLicenseActivated() {        //License fetched and activated with success.    }
    override fun onLicenseActivationFailed(licenseActivationError: LicenseActivationError) {         //Failed to fetch or activate the license.    } }, applicationContext)

Coroutines solution: It returns LicenseActivationResult

Kotlinval activationResult = manager.activate(applicationContext)when (activationResult) {    is LicenseActivationSuccess -> {        //License fetched and activated with success.    }    is LicenseActivationError -> {        //Failed to fetch or activate the license.    }}

LicenseActivationResult

This is information of result from activation license using coroutines solution. Instance might be type of:

• LicenseActivationSuccess

• LicenseActivationError

LicenseActivationError

This is the information about why license can not be activated.

ActivationErrorType

Getting started 

This guide illustrates the required steps to configure a minimally viable project for capturing biometrics using the Biometric Capture SDK.

Downloadable sample apps are here:

• Liveness

• Liveness-lite

Creating your app 

1. Add the SDK library to your app's build.gradle:

Groovyimplementation("morpho.mph_bio_sdk.android:SmartBio:version")

If you do not have configured repository for the SDK yet, see introduction that explains how to do that.

2. Add the correct plugin dependency if you use face capture.

Plugins are special extensions to the SDK that might add or change its features. In this way, users can save memory and increase performance by picking plugins they need.

For face capture there are three plugins to choose from. There should be only one plugin selected during the build. If more than one for a specific flavor is selected, it will cause a MultipleFaceInitPluginsException.

Available plugins

• plugin-face-normal should be used when WebBioServer is not used and there is need for strong security during local liveness challenges.

• plugin-face-lite should be used when WebBioServer is used because it can reduce the size of an application significantly.

• plugin-face-cr2dmatching should be used for local usage with additional security feature for FaceLiveness.ACTIVE mode.

Example plugin dependency for face capture:

Groovyimplementation 'com.idemia.smartsdk:plugin-face-normal:version'

Plugins for face matching 

If you use the finger only variant you can skip this section because the proper plugin is already attached to that version.

For face matching there are three options to choose from. Keep in mind that these algorithms are not compatible.

Stored templates will not be successfully matched against templates from another algorithm.

• plugin-algorithm-f5-4-low75: This has been improved to perform better with default compression. If a previous SDK has been used before and there is a user base with stored templates already, then full migration will be required. All templates must be generated again with the new plugin in use.

• plugin-algorithm-f5-0-vid81: This is the default algorithm that is compatible with previous SDK versions.

• plugin-algorithm-fingerv9: This provides only finger matching.

• plugin-algorithm-f6-5-low70: Recommended algorithm for face matching, introduced in SDK version 4.44.0. There is no compatibility in the template level with other plugins.

Remember to attach only one matching plugin per flavor, otherwise a MultipleInitBlockPluginsException will occur.

More about plugins

3. Add the CaptureView to the layout where you handle the biometric capture:

XML<com.idemia.smartsdk.preview.CaptureView                        android:id="@+id/captureView"                        android:layout_width="match_parent"                        android:layout_height="match_parent" />

4. On your activity or fragment get a reference to this view:

val cameraPreview: CaptureView = findViewById(android.R.id.captureView)

5. Activate your license. This can be done in the onCreate(Bundle savedInstanceState) or in a previous stage of your app. This must be done only once.

val manager = LicenseManager.provideLicenseManager(LkmsProfileId, LkmsApiKey, lkmsUrl)val activationResult = manager.activate(applicationContext)when (activationResult) {    is LicenseActivationSuccess -> {        //License fetched and activated with success.    }    is LicenseActivationError -> {        //Failed to fetch or activate the license.    }}

For security reasons it is good to consider storing LKMS credentials outside source code (for example gradle properties).

6. Prepare capture settings. For face capture, you should use FaceCaptureOptions.

val captureOptions = FaceCaptureOptions(FaceLiveness.PASSIVE)captureOptions.camera = Camera.FRONTcaptureOptions.captureTimeout = 120captureOptions.overlay = Overlay.OFF

7. In the onResume() method of your activity or fragment, obtain a valid reference to the IBioCaptureHandler using the previously created capture options.

override fun onResume() {    //Create handler    BioSdk.createFaceCaptureHandler(this, captureOptions, object : MscAsyncCallbacks<IFaceCaptureHandler> {        override fun onPreExecute() {            // Optional hook on the builtin Android AsyncTask callback `onPreExecute`        }
        override fun onSuccess(result: IFaceCaptureHandler) {            // Indicates that initialization succeeded, the returned handler can be used to start the capture.            faceCaptureHandler = result        }
        override fun onError(e: BioCaptureHandlerError) {            // An error has occurred during the initialization        }    })    super.onResume()}

8. Add the listeners for the events to the handler:

faceCaptureHandler.setFaceCaptureResultListener(object : FaceCaptureResultListener {    override fun onCaptureSuccess(image: FaceImage) {        //Successfully captured image    }
    override fun onCaptureFailure(captureError: CaptureError, biometricInfo: IBiometricInfo, extraInfo: Bundle) {        //Capture failure    }})
faceCaptureHandler.setFaceCaptureFeedbackListener(FaceCaptureFeedbackListener {feedback ->    //Face capture feedback info, like move your face to the right})
faceCaptureHandler.setFaceTrackingListener(FaceCaptureTrackingListener {    //Tracking info to know where the face is.})

9. Initialize the preview and capture to start receiving events. It should happen after creating the capture handler. The most common place for this would be onResume:

coroutineScope.launch {    faceCaptureHandler.startPreview()    faceCaptureHandler.startCapture()}

10. Destroy the handler when onPause() is invoked:

override fun onPause() {    captureHandler?.apply {        stopCapture()        stopPreview()        destroy()    }    super.onPause()}

11. In your manifest, you must add:

XML<!--Declare new permissions-->        <permission            android:name="your.new.permission.NEW_READ_MPH_BIO_SDK_PROVIDER"            android:protectionLevel="signature" /> <!--unless otherwise required, set the maximum security permission -->        <permission            android:name="your.new.permission.NEW_WRITE_MPH_BIO_SDK_PROVIDER"            android:protectionLevel="signature" /> <!--unless otherwise required, set the maximum security permission -->

XML<!--The provider must be defined by the implementing app so as to allow multiple apps-->        <!--Bio store provider provider-->        <provider           android:name="com.morpho.mph_bio_sdk.android.sdk.content_provider.BioStoreProvider"           android:authorities="your.new.authority"           android:readPermission="your.new.permission.NEW_READ_MPH_BIO_SDK_PROVIDER"           android:writePermission="your.new.permission.NEW_WRITE_MPH_BIO_SDK_PROVIDER"           tools:replace="android:authorities, android:readPermission, android:writePermission">        </provider>

Analytics 

Capture SDK offers a logging mechanism that collects analytics data about SDK usage, and sends this data to IDEMIA's server. This data helps IDEMIA to improve Capture SDK and the likelihood of integrator success within the app. It is strongly recommended to activate the analytics mechanism.

• You can enable or disable sending analytics data.

• You can choose to send analytics data only when you are connected to a Wi-Fi network, so as not to not use your cellular connection.

• Analytics data that IDEMIA collects contains only technical data.

• No sensitive personal data is collected.

• IDEMIA does not collect any images.

Analytics data that we collect include following information:

• Application name, bundle id, version

• Capture SDK and RemoteLogger libraries versions

• Device model and operating system version

• Technical information about performed face, finger, and document capture (such as: capture mode used; timestamp; reason of error; time needed to perform a capture; quality of captured image; and light condition)

• Technical information about performed authentication and identification events (such as: used threshold, duration, and obtained score)

• Other technical information (such as: image compression, occurred errors, and SDK performance) that does not contain personal data

You can disable analytics reporting using the appropriate SDK method.

Capture SDK plugins 

Plugins have been introduced to give even more flexibility than variants of the SDK. Every integrator might have different needs and size requirements. A new plugin mechanism allows for greater flexibility. Plugins are split to two groups: feature and algorithm.

Feature plugins 

Provides various SDK functionalities such as: face capture, document capture, and optical character recognition (OCR).

Algorithm plugins 

Provides for extracting biometric data from images, matching this data, and storing it as templates.

How it works 

Capture SDK still has previous variants with predefined plugins in the dependency list that are still required. However, some features might be different, like the matching algorithm or face capture challenge behavior. In such cases, these features might be configured via adding specific plugins.

All that must be done to add a plugin is to put the proper dependency to a project's module that will be using the plugin (How to use them).

Benefits 

The obvious benefit is reducing the number of SDK variants which makes it easier to pick the proper SDK dependency. It also brings flexibility to the product, namely, the ability to mix or replace features in the future or even extend SDK possibilities by implementing your own plugins.

How to use them 

Plugins are just ordinary dependencies. All that must be done is to add the proper dependency for the plugins that are needed. Read carefully about allowed combinations and predefined plugins in SDK variants.

Here is a snippet with all available plugins:

Gradle//Feature pluginsimplementation 'com.idemia.smartsdk:plugin-finger:$version'implementation 'com.idemia.smartsdk:plugin-face:$version'implementation 'com.idemia.smartsdk:plugin-face-normal:$version'implementation 'com.idemia.smartsdk:plugin-face-lite:$version'implementation 'com.idemia.smartsdk:plugin-face-cr2dmatching:$version'implementation 'com.idemia.smartsdk:plugin-face:$version'implementation 'com.idemia.smartsdk:plugin-improved-pdf417-detection:$version'
//Algorithm pluginsimplementation 'com.idemia.smartsdk:plugin-algorithm-f5-0-vid81:$version'implementation 'com.idemia.smartsdk:plugin-algorithm-f5-4-low75:$version'implementation 'com.idemia.smartsdk:plugin-algorithm-f6-0-idd80:$version'implementation 'com.idemia.smartsdk:plugin-algorithm-f6-5-low70:$version'implementation 'com.idemia.smartsdk:plugin-algorithm-fingerv9:$version'

Allowed combinations 

Here are all possible combinations of plugins for specific use cases.

As mentioned above, the SDK variants have predefined plugins dependency, so that only a few must be defined.

See what predefined plugins has which variant of the SDK you use.

Warning: Only one of: plugin-face-lite, plugin-face-normal, plugin-face-cr2dmatching can be used at a time. The integrator must pick one of them. A MultipleFaceInitPluginsException will occur if more than one has been picked.

SDK variants and their plugins 

Each SDK plugin variant delivers something different - check carefully what each plugin variant contains. Plugin variants should not be added in a module that uses this specific variant. As can be seen below, no document-related plugins must be added for variants that deliver this feature. In other words, variants contain all plugins that are required and have no alternatives.

Plugins that might be added for a Capture SDK variant:

• One of: plugin-face-normal, plugin-face-lite, plugin-face-cr2dmatching

• One of: plugin-algorithm-f5-4-low75, plugin-algorithm-f5-0-vid81, plugin-algorithm-f6-0-idd80, plugin-algorithm-f6-5-low70, plugin-algorithm-fingerv9* (this one is not recommended if face matching will be performed)

Plugins that can be added for the Biometric Capture SDK variant:

• One of: plugin-face-normal, plugin-face-lite, plugin-face-cr2dmatching

• One of: plugin-algorithm-f5-4-low75, plugin-algorithm-f5-0-vid81, plugin-algorithm-f6-0-idd80, plugin-algorithm-f6-5-low70 plugin-algorithm-fingerv9 (this one is not recommended if face matching is going to be performed)

There are no plugins for the SmartFinger variant.

Plugins that can be added for the SmartFace variant:

• One of: plugin-face-normal, plugin-face-lite, plugin-face-cr2dmatching

• One of: plugin-algorithm-f5-4-low75, plugin-algorithm-f5-0-vid81, plugin-algorithm-f6-0-idd80, plugin-algorithm-f6-5-low70

Plugins that can be added for the SmartFaceDoc variant:

• One of: plugin-algorithm-f5-4-low75, plugin-algorithm-f5-0-vid81, plugin-algorithm-f6-0-idd80, plugin-algorithm-f6-5-low70

However, this variant is meant to be used with WebBioServer which performs matching operations (no need to do that locally).

For SDK variants with document plugin-improved-pdf417-detection may be added in order to improve capture of barcodes.

Feature plugins descriptions 

plugin-face

Basic plugin needed for face capture. Usually it is predefined in every SDK variant that delivers face capture functionality.

plugin-face-normal

Should be used for face capture when WebBioServer is not used and there is a need for strong security during local liveness challenges.

plugin-face-lite

Should be used when WebBioServer is used for liveness check during face capture, because it can reduce the size of application significantly.

plugin-face-cr2dmatching

Should be used for local usage (without WebBioServer) when additional security feature for FaceLiveness.ACTIVE mode is needed.

plugin-finger

Plugin needed for finger capture. Usually it is predefined in every SDK variant that delivers finger capture functionality.

plugin-improved-pdf417-detection

Plugin that can be used to speed up barcode capture.

Algorithm plugins descriptions 

plugin-algorithm-f6-0-idd80

It is more accurate than f5-4-low75 and much smaller than f5-0-vid81.

plugin-algorithm-f5-4-low75

Improved to perform better with default compression. If a previous SDK has been used before and there is a user base with stored templates already, then full migration of the user's biometrics will be required. All templates must be generated again with the new plugin in use.

plugin-algorithm-f5-0-vid81

This is the default algorithm that is compatible with previous SDK versions.

plugin-algorithm-f6-5-low70

Recommended algorithm for face capture. It is more accurate than f6-0-idd80. If a previous SDK has been used before and there is a user base with stored templates already, then full migration of the user's biometrics will be required. All templates must be generated again with the new plugin in use.

plugin-algorithm-fingerv9

Provides only finger matching feature. It is best to pick this one when only finger matching will be performed.

WARNING

The algorithms are NOT compatible with each other. The templates generated by one of the algorithms cannot be processed with the other one; that is, it is not possible to match a template generated with F6_0_IDD80 against a template generated with F5_4_LOW75 or F5_0_VID81. If an integrator wants to change the algorithm in their solution, all the stored templates must be recreated with the new algorithm.

SDK size 

This is the estimated size of an SDK variant with all its dependencies, like predefined plugins (see Plugins section). The UI-extension is not included in size as it is not a predefined dependency.

Plugins size 

Integration guide 

The purpose of this document is to show the API of the SDK and expose all of its involved objects.

Use cases 

Capture biometrics

Below is the generic execution flow to perform a biometric capture (Get Picture), and get information about the biometry. For example, getting a picture and moving your head to the left.

Capture timeout

Below is the generic execution flow to be followed when a capture timeout occurs.

Capture enroll

Below is the generic execution flow to perform a biometric capture (Get Picture). After that, the biometrics template is extracted from the image returned by the capture component. The biometric template is linked to one user using the userUUID. The UUID of this template and the userUUID are stored in a database.

Capture authenticate

Below is the generic execution flow to perform a biometric capture (Get Picture). The biometrics template is then extracted from the image and returned by the capture component. These are the candidate templates that you must use to create an IBiometricCandidate.

After the IBiometricCandidate is created, a list of reference templates must be extracted. These will then be used to create an IBiometricReference object with which to match against the IBiometricCandidate and authenticate that the candidate templates belong to the user.

There are two ways to extract a list of template references: the first is to retrieve them from the database used during the enrollment process; the second is to extract the templates from another image with detectBiometrics(...).

Capture identify

Below is the generic execution flow to perform a biometric capture (Get Picture). The biometrics template is then extracted from the image and returned by the capture component. These are the candidate templates which you must use to create an IBiometricCandidate.

After the IBiometricCandidate is created, a list of reference templates must be extracted. These will then be used to create an IBiometricReference object with which to match against the IBiometricCandidate and authenticate that the candidate templates belong to the user.

Creating BioMatcherHandler

Below is the generic execution flow to retrieve and release a BioMatcherhandler.

Authenticating

Below is the generic execution flow to perform a generic verification process which involves extracting the biometrics template from an image. These are the candidate templates which you must use to create an IBiometricCandidate.

After the IBiometricCandidate is created, a list of reference templates must be extracted. These will then be used to create an IBiometricReference object with which to match against the IBiometricCandidate and authenticate that the candidate templates belong to the user.

There are two ways to extract a list of template references: the first is to retrieve them from the database used during the enrollment process; the second to is extract the templates from another image with detectBiometrics(...).

Identifying

Below is the generic execution flow to perform a generic identification process which involves extracting the biometrics template from an image. These are the candidate templates which you must use to create an IBiometricCandidate.

After the IBiometricCandidate is created, a list of reference templates must be extracted. These will then be used to create an IBiometricReference object with which to match against the IBiometricCandidate and authenticate that the candidate templates belong to the user.

Detect biometrics

This describes detecting the biometrics in an IImage. This function is intended to be used to extract all the biometric templates contained in an image; for example, all the faces that are in an image.

Face capture - new API (recommended) 

Introduction 

In order to make integration of the SDK easier and more intuitive - new API for Face Capture has been delivered. It is based on use cases that are self-explaining which provide specific information depending on a given use case. This allows integrator to focus on working with the data provided by the SDK rather than on SDK configuration.

Old API is still available for backward compability for already integrated users. It's description might be found here.

NOTE: The new API now supports both: remote and local liveness use cases.

Integration 

License activation

First step that is mandatory to use SDK is to activate license and grant camera permission for application. This part is common for old API and the new one. License handling can be found here.

Adding FaceCaptureView

FaceCaptureView is a key component of SDK. It not only provides preview for the capture but also it is an entry point to SDK's API. It means that on this component integrator sets up capture and orchestrate it's flow.

FaceCaptureView should be added to the layout of capture Activity. It is done as any other android's view. It must be visible to the end user.

XML<androidx.constraintlayout.widget.ConstraintLayout    xmlns:android="http://schemas.android.com/apk/res/android"    xmlns:app="http://schemas.android.com/apk/res-auto"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:orientation="horizontal">
    <com.idemia.capture.face.api.FaceCaptureView        android:id="@+id/captureView"        android:layout_width="0dp"        android:layout_height="0dp"        app:layout_constraintBottom_toBottomOf="parent"        app:layout_constraintEnd_toEndOf="parent"        app:layout_constraintStart_toStartOf="parent"        app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

As FaceCaptureView is also entry point to SDK, it should be also invoked with proper methods in application logic. This can be done by old way - findViewById:

Kotlinprivate var captureView: FingerCaptureView? = null
override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.your_activity_layout)
        captureView = findViewById(R.id.captureView)}

or with more popular way - through binding:

Kotlinlateinit var binding: YourActivityCaptureBinding
override fun onCreate(savedInstanceState: Bundle?) {    super.onCreate(savedInstanceState)    binding = YourActivityCaptureBinding.inflate(layoutInflater)    setContentView(binding.root)
    val captureView = binding.captureView}

Creating use case

In order to perform capture, the next step is to create use case we are interested in. As mentioned above - new API focuses on what we want to do and not on how we want to do. In order to achieve that, use cases have been introduced. They define what will be done and require (at least for result) set of listeners to provide information about capture.

Kotlinval remoteUseCase =    RemoteUseCase(        sessionId,        RemoteCaptureListeners(              faceTrackingInfo = faceTrackingInfoListener,              captureFeedback = feedbackListener,              captureLivenessListener = captureLivenessListener,              stepInfoListener = stepInfoListener,              passiveVideoListener = passiveVideoListener,              captureResultListener = captureResultListener        ),        environmentInfo    )

More about use cases and their properties can be found in dedicated section.

Setting up capture

When license is activated, camera permission is granted, and use case has been created, it is time to set up capture and perform it. In order to do that use method setUp on FaceCaptureView:

Kotlinfun setUp(useCase: UseCase, lifecycle: Lifecycle?, uiSettings: UISettings?)

Please find below explanation to each function argument:

In case that Lifecycle component is not configured, methods:

• start() - Start's capture and liveness verification flow. Recommended to invoke in onResume or onStart methods of Android's lifecycle.

• cancel() - Cancels flow. Recommended to invoke in onPause or onStop methods of Android's lifecycle - depending on desired effect.

• destroy() - Cleans up capture view and it's data. Recommended to invoke in onDestroy method of Android's lifecycle. have to be called explicitly by integrator in order to provide smooth and stable user experience.

Provided that above steps has been done, capture needs to be set up, as in the following example:

Kotlin[code in Activity]
fun setupView(useCase: UseCase) {    binding.captureView.setUp(        useCase,        lifecycle,        UISettings(passiveVideoSettings, passiveSettings, joinThePointsCaptureSettings)    )}

Here is example of UISettings setup. Keep in mind that this class keep configuration for each FaceLiveness mode except from NO_LIVENESS:

Kotlinval joinThePointsCaptureSettings = joinThePointsChallengeSettings {    useInterpolation = true    scene {        overlay {            showOverlay = true            imageRes = R.drawable.ic_face_overlay            marginVertical = R.dimen.default_face_overlay_vertical_padding            marginHorizontal = R.dimen.default_face_overlay_vertical_padding            text {                text = R.string.default_overlay_text                textSize = R.dimen.default_overlay_text_size                textColor = Color.parseColor(Colors.text_black)                }            }        capturedLineOpacity = 0.5f        pointer {            type = PointerType.PULSING            collisionWithTargetAction = PointerCollisionAction.NONE        }        target {            pulseAnimation {                waves = 3            }            showMarkOnCurrentTarget = true        }        verticalTilt {            enabled = false        }        tapping {            enabled = false        }        result {            failureImageResId = R.drawable.ic_challenge_failed            successImageResId = R.drawable.ic_challenge_success        }    }}
val passiveSettings = passiveCaptureSettings {    scene {        background {            colorEnd = Color.parseColor("#189482")            colorStart = Color.parseColor("#38ddb8")        }        previewScale {            scaleX = 1.0f            scaleY = 1.0f        }        feedback {            colorText = Color.parseColor(Colors.white)        }        overlay {            showOverlay = true        }        tapping {            colorBackground = Color.parseColor("#FAFAFA")            colorImage = Color.parseColor(Colors.black)            colorText = Color.parseColor(Colors.black)            textResId = "Use your head to interact"            textH1ResId = "No tapping needed"            enabled = true        }        verticalTilt {            colorBackground = Color.parseColor("#FAFAFA")            colorImage = Color.parseColor("#000000")            colorText = Color.parseColor("#000000")            textResId = "Please hold your phone vertically."            enabled = true        }        countdown {            countdownSeconds = 3        }        delay {            isEnabled = true            message = "Authentication locked.\nPlease wait for:\n%1$s"        }    }}
val passiveVideoSettings = passiveVideoCaptureSettings {    scene {        preparationScene {            backgroundColor = Color.WHITE        }        faceOverlay {            progressBar {                progressFill = Color.GREEN            }        }        background {            colorEnd = Color.parseColor("#189482")            colorStart = Color.parseColor("#38ddb8")        }        previewScale {            scaleX = 1.0f            scaleY = 1.0f        }        feedback {            videoBackground { }        }        tapping {            colorBackground = Color.parseColor("#FAFAFA")            colorImage = Color.parseColor("#000000")            colorText = Color.parseColor("#000000")            textResId = "Use your head to interact"            textH1ResId = "No tapping needed"            enabled = true        }        verticalTilt {            colorBackground = Color.parseColor("#FAFAFA")            colorImage = Color.parseColor("#000000")            colorText = Color.parseColor("#000000")            textResId = "Please hold your phone vertically."            enabled = true        }        delay {            isEnabled = true            message = "Authentication locked.\nPlease wait for:\n%1$s"        }    }}

Use cases 

As mentioned in sections above new API is meant to be easier to integrate and more intuitive in general. In order to achieve that use cases have been introduced. Every use case is dedicated to do particular job. Please find below list of available use cases.

RemoteUseCase (recommended) 

This use case is used to perform face capture with backend liveness verification. Thanks to this use case integrator does not have to integrate with backend services as it provides end to end integration. However, few things needs to be provided:

• Session id for given capture

• RemoteCaptureListeners

• EnvironmentInfo

KotlinRemoteUseCase(sessionId: String, listeners: RemoteCaptureListeners, environmentInfo: EnvironmentInfo)

RemoteCaptureListeners - detailed description of each listeners can be found in listeners section.

EnvironmentInfo

FaceCapture is compatible with two types of the authorization: API Key and OAuth.

• In token type authorization, an access token is generated by the authorization server using the provided secrets. This token can be utilized by creating an AccessToken class and using the appropriate initializer in the EnvironmentInfo class: init(accessToken: AccessToken, baseUrl: URL).

• The AccessToken class holds information about the secret and token type from the OAuth authorization server.

Secrets can be found on the webpage: https://experience.idemia.com/dashboard/my-identity-proofing/access/environments/ .

Access Token solution constructor:

ApiKey solution constructor:

AccessToken

Creating capture session

RemoteUseCase handles liveness verification on backend side. It requires to create session per capture. Common approach is to create session on integrator's backend side and provide it to application. Then capture flow might be triggered. Good to start with pages:

• General description of liveness remote capture - here

• GIPS API description - here

• WebBio API description - here

For example, creating session via GIPS requires:

1. Create identity by calling: POST: /v1/identities As a result an identity is being returned

2. Submit confirmation that the user has consented to perform specific evidence verifications: POST: /v1/identities/{id}/consents

3. Start liveness session by calling: POST: /v1/identities/{id}/attributes/portrait/live-capture-session?mode=nativeSDK Response to this call contains session id used by SDK.

Proceeding with WebBio requires:

1. Create session by calling: POST: /bioserver-app/v2/bio-sessions Call must contain session data in body.

2. Retrieve session path from the response:

Kotlinval bioSessionPath = response.headers()["Location"]

3. Get BioSession: GET: /bioserver-app{bioSessionPath} Response to this call contains session id used by SDK.

4. Initialize the session with id from previous step and liveness parameters passed in body: POST: /bioserver-app/v2/bio-sessions/{bioSessionId}/init-liveness-parameters

Snippet below shows use case creation:

Kotlinval environmentInfo = EnvironmentInfo(        "https://proofing.app.eu.identity-prod.idemia.io:443/",        "YourApiKey")val sessionInfo = sessionHandler.createSession(                    readFaceLivenessModeFromSettings(),                    readFaceSecurityLevelFromSettings())val remoteUseCase = RemoteUseCase(                        sessionInfo.sessionId,                        RemoteCaptureListeners(                            faceTrackingInfo = faceTrackingInfoLoggingListener,                            captureFeedback = feedbackListener,                            captureLivenessListener = captureLivenessLoggingListener,                            stepInfoListener = stepInfoListener,                            passiveVideoListener = passiveVideoLoggingListener,                            captureResultListener = captureResultListener                        ),                        environmentInfo)

If this guide is not enough, there is still FaceSampleAppLite source code on our Artifactory repository. Feel free to download latest package with GIPS implementation from here or WBS implementation from here and see integration with session creation included.

Keep in mind that result of flow on SDK side is sending required data to backend service. Captured image might be required for application needs. To aquire it, additional request to WebBioServer has to be done. API description related to this can be found here.

Simple interface responsible for starting illumination process. It's returned by onIlluminationDemand method of MlcListener.

Listeners

New API introduces multiple listeners to acquire capture related data by integrator. All listeners are being called on UI thread and it is safe to manipulate UI components directly from them.

CaptureLivenessListener

Returns information about current liveness capture mode. Usefull for RemoteUseCase where mode comes from backend side.

Kotlinfun captureLiveness(liveness: Liveness)

Liveness

StepInfoListener

This listener provides information about capture flow state within StepInfo object.

Kotlinfun stepInfo(stepInfo: StepInfo)

StepInfo

LivenessActiveListener

This listener provides information about active face capture. This mode requires user to connect dots in correct order by moving his face. Callbacks tells integrator what is current status of challenge and what to display. Keep in mind that by providing UISettings to FaceCaptureView, there is no need to handle that because SDK will draw this challenge with style provided.

Kotlinfun onPointerUpdate(pointInfo: PointerInfo)

PointerInfo contains information about user's "viewfinder" position. This is the point that user needs to put on a target in order to mark it as "captured".

Kotlinfun onTargetUpdate(targetInfo: TargetInfo)

TargetInfo contains information about targets to capture.

Kotlinfun onNumberTargets(numberOfTargets: Int)

This callback provides information about how many points needs to be captured to pass challenge.

PassiveVideoListener

This listeners helps to pass passive video liveness capture mode. Before capture starts there is a preparation phase and capture itself has it's progress. Information are provided within this listener should be presented to end user. Keep in mind that by providing UISettings to * FaceCaptureView*, there is no need to handle this listener because SDK will draw this challenge with style provided.

Kotlinfun onPreparationStarted()

Tells integrator that preparation of capture has been started.

Kotlinfun onPreparationFinished()

Tells integrator that preparation phase has finished. Now capture will be performed.

Kotlinfun overlayUpdated(overlay: OvalOverlay)

To make capture easier there is a special configuration for UI oval to be displayed to end user. OvalOverlay has coordinates and size of that oval.

Kotlinfun progressUpdated(progress: Float)

Progress of capture.

CaptureResultListener

Used for all use cases. Provides information about flow result.

Kotlinfun onFinish(result: CaptureResult)

CaptureResult instance might be type of Success that is information about successful flow or Failure that contains Error instance inside. For more details see errors section.

CaptureFeedbackListener

This is listener with crucial information for user about the capture. Helps to find optimal position in front of camera.

Kotlinfun onFeedback(captureFeedback: CaptureFeedback)

Where CaptureFeedback is enum with self-explanatory instruction. It is covered by UISettings* by mapping these to text instructions to the user.

FaceTrackingInfoListener

This listener provides rectangle coordinates and size with face position (relative to preview frame size) in real time during capture. Helpful when there is a need to draw overlay on preview showing detected face.

Kotlinfun faceTrackingInfo(trackingInfo: FaceTrackingInfo)

FaceTrackingInfo provides "face rectangle" informations.

LivenessProcessingListener

This listener provides information about current progress of uploading metadata to the server.

Kotlinfun onLivenessMetadataUploadProgressUpdated(@FloatRange(from = 0.0, to = 1.0) progress: Float)

MlcListener

This listener provides information related to MultidimensionalLivenessCheck capture.

It contains following methods:

Kotlinfun onSmileStabilityChange(@FloatRange(from = 0.0, to = 1.0) value: Float)

Returns the percentage of smile step completion.

Kotlinfun onSmileSizeChange(@FloatRange(from = 0.0, to = 1.0) value: Float)

Returns current smile size.

Kotlinfun onSmileFinished()

Called when smile acquisition process has ended.

Kotlinfun onIlluminationPrepared(@FloatRange(from = 0.0, to = 1.0) scale: Float)

Indicates that illumination process is ready to start. scale parameter is a value between 0.0 and 1.0, and should be used to rescale preview component before triggering illumination.

Kotlinfun onIlluminationProgressChange(@FloatRange(from = 0.0, to = 1.0) progress: Float)

Returns current illumination progress value in the range between 0.0 and 1.0.

Kotlinfun onColorToDisplay(red: Int, green: Int, blue: Int)

Returns colors which should be used as a part of illumination process. Background of preview should change according to those colors.

Kotlinfun onIlluminationFinished()

Called after end of illumination process.

Kotlinfun onIlluminationDemand(request: IlluminationRequest)

Returns IlluminationRequest which is used to start illumination.

Additional classes

IlluminationRequest

Kotlininterface IlluminationRequest {    fun start()}

ActiveLivenessUseCase 

This use case performs face capture with on-device liveness verification. It means that no external requests are made in order to verify user. "Active" in use case name indicate that in order to pass verification end user has to complete an action. Points on the screen need to be joined in given order using face as a pointer.

Use case should be created using its constructor:

KotlinActiveLivenessUseCase (    val listeners: ActiveCaptureListeners = ActiveCaptureListeners(),    val numberOfPoints: Int,    val timeoutInSeconds: Long = DEFAULT_TIMEOUT_SECONDS,    val securityLevel: SecurityLevel = SecurityLevel.HIGH,)

Listeners

LivenessActiveListener

This listener provides information about active face capture. This mode requires user to connect dots in correct order by moving his face. Callbacks tells integrator what is current status of challenge and what to display. Keep in mind that by providing UISettings to FaceCaptureView, there is no need to handle that because SDK will draw this challenge with style provided.

Kotlinfun onPointerUpdate(pointInfo: PointerInfo)

PointerInfo contains information about user's "viewfinder" position. This is the point that user needs to put on a target in order to mark it as "captured".

Kotlinfun onTargetUpdate(targetInfo: TargetInfo)

TargetInfo contains information about targets to capture.

Kotlinfun onNumberTargets(numberOfTargets: Int)

This callback provides information about how many points needs to be captured to pass challenge.

CaptureResultListener

Provides information about flow result.

Kotlinfun onFinish(result: CaptureResult)

CaptureResult instance might be type of Success that is information about successful flow or Failure that contains Error instance inside. For more details see errors section.

FaceTrackingInfoListener

This listener provides rectangle coordinates and size with face position (relative to preview frame size) in real time during capture. Helpful when there is a need to draw overlay on preview showing detected face.

Kotlinfun faceTrackingInfo(trackingInfo: FaceTrackingInfo)

CaptureFeedbackListener

This is listener with crucial information for user about the capture. Helps to find optimal position in front of camera.

Kotlinfun onFeedback(captureFeedback: CaptureFeedback)

Where CaptureFeedback is enum with self-explanatory instruction. It is covered by UISettings* by mapping these to text instructions to the user.

PassiveLivenessUseCase 

This use case performs face capture with on-device liveness verification. It means that no external requests are made in order to verify user. "Passive" in use case name indicate that in order to pass verification end user does not have to do any action - just place his face in front of the camera.

Use case should be created using its constructor:

KotlinPassiveLivenessUseCase (    val listeners: ActiveCaptureListeners = ActiveCaptureListeners(),    val timeoutInSeconds: Long = DEFAULT_TIMEOUT_SECONDS,    val securityLevel: SecurityLevel = SecurityLevel.HIGH,)

Listeners

CaptureResultListener

Provides information about flow result.

Kotlinfun onFinish(result: CaptureResult)

CaptureResult instance might be type of Success that is information about successful flow or Failure that contains Error instance inside. For more details see errors section.

FaceTrackingInfoListener

This listener provides rectangle coordinates and size with face position (relative to preview frame size) in real time during capture. Helpful when there is a need to draw overlay on preview showing detected face.

Kotlinfun faceTrackingInfo(trackingInfo: FaceTrackingInfo)

CaptureFeedbackListener

This is listener with crucial information for user about the capture. Helps to find optimal position in front of camera.

Kotlinfun onFeedback(captureFeedback: CaptureFeedback)

Where CaptureFeedback is enum with self-explanatory instruction. It is covered by UISettings* by mapping these to text instructions to the user.

Errors 

For every flow there is possibility to receive Error type of result. It means that something went wrong during the capture or backend communication. Fortunately, Error object contains a lot of useful information that help to handle failed flow.

Error

ErrorType

FailureReason

Integration of MLC capture 

MultidimensionalLivenessCheck is a recommended mode for liveness capture. This capture consist of three phases:

1. Framing - when the user have to correctly align face within the frame.

2. Smile - when the user needs to smile genuinely.

3. Illumination - when face will be verified with a sequence of color flashes.

There are two ways of integrating this capture - with providing UiSettings, or by handling each step of the capture on your own.

Integration with using UiSettings

Using UiSettings is the easiest way of integrating MLC capture. It requires following steps:

1. Create session with Liveness of type MLC. See creating capture session section for more details.

2. Create RemoteUseCase with sessionId, EnvironmentInfo and listeners.

Kotlinval remoteUseCase = RemoteUseCase(    sessionId,    RemoteCaptureListeners(        stepInfoListener = stepInfoListener,        captureResultListener = captureResultListener,    ),    environmentInfo)

3. Create mlcCaptureSettings with feedbacks specific for MLC and pass it to UiSettings object.

4. Call setUp on FaceCaptureView with previously created objects:

Kotlinbinding.captureView.setUp(remoteUseCase,    lifecycle, //If you don't want to start and stop capture on your own    UISettings(mlcCaptureSettings = mlcCaptureSettings))

After that capture will be started.

Integration based on MlcListener

The second way of handling MLC capture is to implement your own UI and logic for handling each phase of the capture. It's more complex, but allows better customization than approach with using UiSettings. This integration is based on correctly handling information coming from MlcListener. As mentioned before, MLC capture consist of three phases:

1. Framing - it requires correctly placing the face within the preview. To proceed, the user have to follow feedbacks coming from CaptureFeedbackListener.

2. Smile - starts after receiving feedback CaptureFeedback.FACE_INFO_MAKE_A_SMILE. There are three methods in MlcListener related with this phase: onSmileStabilityChange - which can be used to track progress of whole phase, onSmileSizeChange - to show smile progress for the user (It can be done for example with using SmileIndicatorBar) and onSmileFinished - which means that smile phase ended.

3. Illumination - during this phase preview background have to change colors according to values coming from the SDK. To properly handle this phase, you have to:

   • Rescale FaceCaptureView with value received from onIlluminationPrepared method.

   • Show some additional instructions for the user, for example informing about incoming color changes or necessity of moving face closer to the screen due to changed preview size.

   • Trigger illumination process by calling start() on IlluminationRequest received from onIlluminationDemand method.

   • Adjust color of preview background to values coming from onColorToDisplay. If you want to track progress of illumination phase, then progress will be returned in onIlluminationProgressChange (as value in range between 0.0 and 1.0). The process ends when onIlluminationFinished is called.

When MlcListener is implemented based on given instructions, then you must:

1. Create screen with FaceCaptureView which does not cover all available space - because during illumination phase user's face should be verified with sequence of a color flashes, and FaceCaptureView background have to be adjusted to colors from onColorToDisplay callback.

2. Create session with Liveness of type MLC. See creating capture session section for more details.

3. Create RemoteUseCase with sessionId, EnvironmentInfo and listeners.

Kotlinval remoteUseCase = RemoteUseCase(    sessionId,    RemoteCaptureListeners(        stepInfoListener = stepInfoListener,        captureFeedback  = captureFeedbackListener,        captureResultListener = captureResultListener,        mlcListener = mlcListener    ),    environmentInfo)

4. Call setUp on FaceCaptureView with previously created objects:

Kotlinbinding.captureView.setUp(remoteUseCase,    lifecycle, //If you don't want to start and stop capture on your own    null)

Face capture - local 

Creating a FaceCaptureHandler 

These instructions will help you create a BioCapture handler.

1. Retrieve a capture handler to perform all the biometric capture operations. You must first configure the capture options. For projects that use Kotlin there are handlers from com.idemia.smartsdk.capture that support initializing capture preview with suspend method.

BioCaptureMode is now deprecated and should not be used during capture configuration because it will be removed in a future release.

• Review the use cases named Capture biometrics.

• Review all the features provided by the BioCaputureHandler handler here.

val captureOptions = FaceCaptureOptions(FaceLiveness.PASSIVE).apply {    camera = Camera.FRONT    captureTimeout = 120    overlay = Overlay.OFF}val captureHandler = FaceCaptureHandler(context, captureOptions)

Errors

Handlers 

This section discusses the BioCapture handler, FaceCapture handler and BioMatcher handler.

BioCapture handler

You must retrieve the capture handler through the Biometric Capture SDK entry point.

Face listener

This sets the listener to receive feedback (such as when a user moves their face to the right) as shown in the snippet:

captureHandler.setFaceTrackingListener({ trackingInfo ->    //Tracking info to know where the face is.})

Start preview

This asynchronously starts the camera preview. It is recommended to start the capture once the preview has been initialized, as shown in the snippet:

coroutineScope.launch {    handler.startPreview()    handler.startCapture()}

Stop preview

This stops the camera preview as shown in the snippet:

handler.stopPreview()

Start capture

This starts the biometric capture as shown in the snippet.

handler.startCapture()

Stop capture

This stops the biometric capture as shown in the snippet:

handler.stopCapture()

Switch camera

This switches between different cameras as shown in the snippet:

handler.switchCamera(Camera.FRONT) // Use front camerahandler.switchCamera(Camera.REAR) // Use rear camera

Destroy

This releases all the handler resources as shown in the snippet:

handler.destroy()

Overlay

This sets the overlay option.

handler.overlay = Overlay.OFF // Disable preview's overlayhandler.overlay = Overlay.ON // Enable preview's overlay

CaptureOptions

This retrieves the capture options used in this handler as shown in the snippet:

val options: ICaptureOptions = handler.captureOptions

Force capture

This forces a capture as shown in the snippet:

handler.forceCapture()

Capture handler status

Note: Check CaptureHandlerStatus.

This retrieves the status of the capture handler as shown in the snippet:

val captureHandlerStatus: CaptureHandlerStatus = handler.captureStatus

FaceCapture handler

Note: It extends from BioCaptureHandler.

You must retrieve the capture handler through the Biometric Capture SDK entry point for BioCaptureHandler, as shown in the snippet:

// Get activity from applicationval activity: Activity = ...// Populate a CaptureOptions objectval captureOptions: IFaceCaptureOptions = FaceCaptureOptions(FaceLiveness.PASSIVE)captureOptions.faceLivenessSecurityLevel = FaceLivenessSecurityLevel.HIGHcaptureOptions.camera = Camera.FRONTcaptureOptions.captureTimeout = 120captureOptions.overlay = Overlay.OFFBioSdk.createFaceCaptureHandler(activity, captureOptions, object : MscAsyncCallbacks<IFaceCaptureHandler?> {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask call-back `onPreExecute`    }
    override fun onSuccess(faceCaptureHandler: IFaceCaptureHandler) {        // Indicates that initialization succeeded, the returned handler can be used to start the capture.        handler = faceCaptureHandler        //handler.setTotalNumberOfCapturesBeforeDelay(-1); to disable delays between face capture failures.    }
    override fun onError(e: BioCaptureHandlerError) {        // An error has occurred during the initialization    }})

Capture result listener

This sets the listener to receive the face captures. The face image callback will be fired whenever the capture is finished, as shown in the snippet:

handler.setFaceCaptureResultListener(object : FaceCaptureResultListener {    override fun onCaptureSuccess(image: FaceImage) {        //Capture finished with success    }
    override fun onCaptureFailure(captureError: CaptureError, biometricInfo: IBiometricInfo, extraInfo: Bundle) {        //Capture finished with failure    }})

FaceImage extends IImage, so it is possible to call getImageQuality() on it. However it is not recommended, as imageQuality is only available for finger capture and this method will always return -1 for FaceImage.

Use CR2D challenges

This is another type of challenges which contains target points and points controlled by the user. To use it, pass FaceLiveness.ACTIVE to the FaceCaptureOptions constructor.

This example sets CR2D in capture options as shown in the snippet:

val options: FaceCaptureOptions = FaceCaptureOptions(FaceLiveness.ACTIVE)

Use passive liveness challenge

Passive mode checks for liveness without user interaction (no head movement required). As in default mode, it requires only to show the face in front of the camera so that an image can be acquired. Special algorithms estimate if a user is a real person or not. To use this mode, pass FaceLiveness.PASSIVE to FaceCaptureOptions constructor.

This example sets Passive in the capture options as shown in the snippet"

val options: FaceCaptureOptions = FaceCaptureOptions(FaceLiveness.PASSIVE)

Get debug data

You can save some capture data on the user device's memory. In some cases, keeping those files might help to solve issues.

Below is an example of how to configure the debug data options. The data can be found on the SD card in the SmartSDK_debug_data directory. An example is shown in the snippet:

[...]    val debugSettingsBuilder: DebugSettingsBuilder = DebugSettingsBuilder()    debugSettingsBuilder.logLevel(logLevel)        .storingType(DataStoringType.LAST_SESSION_ONLY)        .saveCapturedImages(DebugOption.DISABLED)    captureOptions.setDebugDataSettings(debugSettingsBuilder.build())

Note: DataStoringType might have two values: LAST_SESSION_ONLY or MULTIPLE_SESSIONS. The first overwrites data in a single directory. The second makes a separate directory per capture.

An option exists to store special .rtv files that help you understand what is happening during a capture.

Note: Storing these files takes a lot of space. LogLevel describes what part of the logs will be saved to a file. If needed, the integrator can also save captured images by enabling saveCapturedImages option.

Set maximum captures before delay

This field sets the maximum number of captures before preventing a capture.

Values less than or equal to 0 disable the functionality. Values greater than 0 set the number of attempts before blocking.

The default value is 5 as shown in the snippet:

faceCaptureOptions.maxCapturesBeforeDelay = 5

There is also a getter for this value as shown in the snippet:

faceCaptureOptions.maxCapturesBeforeDelay

Set capture delay time array

This sets the array list with capture delay for failed attempts that will happen after maxCapturesBeforeDelay.

Delay for the next attempt is taken from the arrays as timeCaptureDelayArray[n maxCapturesBeforeDelay].

For all the attempts after the array length, the last item is taken as shown in the snippet:

val delayTimes: List<Long> = mutableListOf(1L, 5L, 10L, 30L, 60L)faceCaptureHandler.setTimeCaptureDelayArray(delayTimes)

Get time to unlock capture

This provides information about the delay time before the user can retry (specified in seconds). A return value of 0 means that the capture is not blocked.

An example request is shown in the snippet:

faceCaptureHandler.timeToUnlock

Get liveness captures attempts left before delay

This provides information about the number of captures that can be completed before delay is initialized.

It returns the number of attempts before the capture will be blocked, as shown in the snippet:

handler.captureAttemptsLeft

It returns 0 if the capture is blocked, and Int.MAX_VALUE if the capture delays are turned off.

Internal counter

Warning. For security reasons, there is also internal counter. After significant amount of failures, capture still can be delayed if this feature is not turned off.

Liveness security levels

In IFaceCaptureOptions you can set the liveness security strength. It is configured via the FaceLivenessSecurityLevel enum.

The liveness security levels are:

• LOW

• MEDIUM

• HIGH recommended

An option exists to store special .rtv files that help you understand what happens during a capture.

Compression recommendations 

Selfie images

• Recommended compression is JPEG90

• Size of image will be about 100 KB

BioStore 

The use of this component is optional. Its purpose is to allow the integrator to easily persist templates.

Query templates by userUUID 

This lists the templates stored in the repository filtering by user.

s

BioStoreDB.listTemplates(context, userId, object : DataBaseAsyncCallbacks<List<IMorphoTemplate?>?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: List<IMorphoTemplate?>?) {        //The list of templates that match the criteria.    }
    override fun onError(e: Exception?) {        // An error has occurred.    }})

Function

Javapublic static void listTemplates(final Context context, final UUID userId, DataBaseAsyncCallbacks<List<IMorphoTemplate>> callbacks);

Errors

You will receive an exception reporting the error.

Query templates by userUUID and modality 

This lists the templates stored in the repository filtering by User and BiometricModality.

BioStoreDB.listTemplates(context, userId, biometricModality, object : DataBaseAsyncCallbacks<List<IMorphoTemplate?>?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: List<IMorphoTemplate?>?) {        //The list of templates that match the criteria.    }
    override fun onError(e: Exception?) {        // An error has occurred.    }})

Function

Javavoid listTemplates(final Context context, final UUID userId, final BiometricModality biometricModality, DataBaseAsyncCallbacks<List<IMorphoTemplate>> callbacks);

Errors

You will receive an exception reporting the error.

Add template 

This stores a template in the repository. If there is a previous template with the same user UUID, Biometric location, and Biometric modality, it will be updated and the UUID returned.

Note: You cannot have two templates with the same configuration.

BioStoreDB.addTemplate(context, morphoTemplate, object : DataBaseAsyncCallbacks<UUID?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: UUID?) {        //The template has been added and the template's uuid is returned as a parameter.    }
    override fun onError(e: Exception?) {        // An error has occurred.    }})

Function

Javapublic static void addTemplate(final Context context, final IMorphoTemplate template, DataBaseAsyncCallbacks<UUID> callbacks);

Errors

You will receive an exception reporting the error.

Update template 

This updates a template in the repository.

BioStoreDB.updateTemplate(context, morphoTemplate, object : DataBaseAsyncCallbacks<Void?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: Void?) {        //updated.    }
    override fun onError(e: Exception?) {        // An error has occurred.    }})

Function

Javavoid updateTemplate(final Context context, final IMorphoTemplate template, DataBaseAsyncCallbacks<Void> callbacks);

Errors

You will receive an exception reporting the error.

Remove template 

This removes a template from the repository.

BioStoreDB.removeTemplate(context, templateId, object : DataBaseAsyncCallbacks<Void?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: Void?) {        //The template was removed.    }
    override fun onError(e: Exception?) {        // An error has occurred.    }})

Function

Javavoid removeTemplate(final Context context, final UUID templateId, DataBaseAsyncCallbacks<Void> callbacks);

Errors

You will receive an exception reporting the error.

Remove templates associated to one userUUID 

This removes the templates associated to the user identifier from the repository.

BioStoreDB.removeTemplateByUserId(context, userId, object : DataBaseAsyncCallbacks<Int?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: Int?) {        //The number of templates removed.    }
    override fun onError(e: Exception?) {        // An error has occurred.    }})

Function

Javavoid removeTemplateByUserId(final Context context, final UUID userId, DataBaseAsyncCallbacks<Integer> callbacks);

Errors

You will receive an exception reporting the error.

Retrieve template 

This retrieves a template from the database.

BioStoreDB.getTemplate(context, templateId, object : DataBaseAsyncCallbacks<IMorphoTemplate?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: IMorphoTemplate?) {        //The template if exists.    }
    override fun onError(e: Exception?) {        // An error has occurred.    }})

Function

Javavoid getTemplate(final Context context, final UUID templateId, DataBaseAsyncCallbacks<MorphoTemplate> callbacks);

Errors

You will receive an exception reporting the error.

Clear database 

This clears all the data stored in the database.

BioStoreDB.clear(context, object : DataBaseAsyncCallbacks<Void?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: Void?) {        //Data has been cleared    }
    override fun onError(e: Exception?) {        // An error has occurred    }})

Function

Javavoid clear(final Context context, DataBaseAsyncCallbacks<Void> callbacks);

Errors

You will receive an exception reporting the error.

Add user 

This adds a new user to the database.

val user: IUser = User()user.name = "Jose"BioStoreDB.addUser(context, user, object : DataBaseAsyncCallbacks<UUID?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: UUID?) {        //User saved    }
    override fun onError(e: Exception?) {        // An error has occurred    }})

Function

Javavoid addUser(final Context context, final IUser user, DataBaseAsyncCallbacks<UUID> callbacks);

Errors

You will receive an exception reporting the error.

Update user 

This updates a user in the database.

val user: IUser = ... //retrieve old userBioStoreDB.updateUser(context, user, object : DataBaseAsyncCallbacks<Void?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: Void?) {        //User updated.    }
    override fun onError(e: Exception?) {        // An error has occurred.    }})

Function

Javavoid updateUser(final Context context, final IUser user, DataBaseAsyncCallbacks<Void> callbacks);

Errors

You will receive an exception reporting the error.

Remove user 

This removes a user from the database.

BioStoreDB.removeUser(context, uuid, object : DataBaseAsyncCallbacks<Void?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: Void?) {        //User removed    }
    override fun onError(e: Exception?) {        // An error has occurred    }})

Function

Javavoid removeUser(final Context context, final UUID uuid, DataBaseAsyncCallbacks<Void> callbacks);

Errors

You will receive an exception reporting the error.

Get user 

This retrieves a user from the database.

BioStoreDB.getUser(context, uuid, object : DataBaseAsyncCallbacks<IUser?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: IUser?) {        //User    }
    override fun onError(e: Exception?) {        // An error has occurred    }})

Function

Javavoid getUser(final Context context, final UUID uuid, DataBaseAsyncCallbacks<IUser> callbacks);

Errors

You will receive an exception reporting the error.

List users 

List the users stored in the repository.

BioStoreDB.listUsers(context, object : DataBaseAsyncCallbacks<List<IUser?>?>() {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: List<IUser?>?) {    //Users    }
    override fun onError(e: Exception?) {    // An error has occurred    }})

Function

Javavoid listUsers(final Context context, DataBaseAsyncCallbacks<List<IUser>> callbacks);

Errors

You will receive an exception reporting the error.

Helper objects 

BioSdk class - enableAnalytics

This method turns on the reporting and sending analytics report. It also changes the analytics server and its API key.

NOTE: The server is set to Europe by default.

BioSdk class - disableAnalytics

This turns off the reporting and sending analytics report.

Note: By default, the analytics mechanism is turned on and the server is set to Europe.

This section describes the helper objects that are necessary to use the Biometric Capture SDK.

MscAsyncCallbacks

Generic callbacks which execute task asynchronous.

Function

Kotlinfun onPreExecute() {
}

Function

Kotlinfun onSuccess(result: T) {    //on success}

Arguments

Function

Kotlinfun onError(e: BioCaptureHandlerError) {    //on error}

Arguments

BioSdk class - IBioSdkInfo

This object exposes information about the SDK. An example snippet is shown:

val sdkInfo: IBioSdkInfo = BioSdk.getInfo()

IBioMatcherSettings

This object is used to configure the behavior of BioMatcher.

ICaptureOptions

This object is used to configure the behavior of Capture.

FaceCaptureOptions

This object used to configure the behavior of FaceCapture. It extends from CaptureOptions.

IBiometricSet

This is a common interface that all the candidates and references that perform authentication and identification operations extend.

IBiometricCandidate

This is a common interface that all the candidates extend. It extends IBiometricSet.

IBiometricReference

This is a common interface that all the references used to perform an authentication or identification extend. It extends IBiometricSet.

IBiometricInfo

This is a common interface that all the different Biometrics implement.

BiometricInfo

This is a common object that all the different Biometrics extend. It implements the interface IBiometricInfo.

IImage

This is the image interface that the SDK image objects extend.

MorphoImage

This is the image object returned by the SDK. It extends BiometricInfo and implements IImage.

Metadata

This is low level data information about capture for verification.

EncryptedData

This is low level encrypted data information about Capture for verification.

EncryptedMetadata

This is low level encrypted data information about Capture for verification.

FaceTracking

This is a face tracking object returned by the FaceCaptureTrackingListener.

OvalOverlay

Information about oval overlay that might help user to position face correctly in front of camera. Keep in mind these numbers are relative to preview image size. If you want to display some UI elements helping user to place his face, using UIExtensions library is recommended. Otherwise you have to rescale these coordinates by your own to fit your view.

IMorphoTemplate

This is the biometric template object returned by the SDK. It extends IBiometricInfo.

IMorphoFaceTemplate

This is the biometric face template object returned by the SDK. It extends IMorphoTemplate.

IEyePosition

This is the position of eyes on face.

CaptureListener

This is a generic capture listener.

onCaptureFinish

This is invoked by BioCapture when the capture finishes.

Function

An example snippet is shown:

fun onCaptureFinish()

BioCaptureCR2DListener

This listener receives information about CR2D challenge objects.

onCurrentUpdated

This is called every time the current point changes. Cr2dCurrentPoint is an object with information about user position during the challenge.

fun onCurrentUpdated(currentPoint: Cr2dCurrentPoint)

onTargetUpdated

This is called every time the target changes. Cr2dTargetPoint is the object with information about a specific target in a challenge. Each target has a unique number. This method is called once per specific target update.

fun onTargetUpdated(targetPoint: Cr2dTargetPoint)

onTargetsConditionUpdated

This is called every time the condition of targets changes, where targetCount is the amount of all targets in a challenge. targetStability is the stability for the current target in a challenge (possible value is from 0 to 100).

fun onTargetsConditionUpdated(targetCount: Int, targetStability: Int)

FaceCaptureFeedbackListener

This is the capture feedback listener. It enables the app to receive feedback about the biometric captures, like moving your head to the left.

onCaptureInfo

This is invoked multiple times by BioCapture to send feedback about the capture process to the app.

Function

An example snippet is shown.

fun onCaptureInfo(captureInfo: FaceCaptureInfo)

Arguments

IDetectBiometricOptions

This interface represents the verification options. This interface extends IBiometricInfo.

IMatchingOptions

This interface represents the basic matching options.

IAuthenticationOptions

This is the interface that represents the authentication options. This interface extends IMatchingOptions.

The matching result is a score that reflects the similarity of two biometrics acquisitions. The threshold is the score value that is used to differentiate a HIT from a NOHIT.

Threshold choice is a compromise between FAR (False Acceptance Rate) and FRR (False Reject Rate).

FAR is the proportion of requests that generate an unexpected HIT with two biometrics acquisitions of two different persons.

FRR is the proportion of requests that generate an unexpected NOHIT with two biometrics acquisitions of the same person.

IDEMIA algorithms

The recognition algorithm similarity matching score is linked with the FAR (as previously defined):

IAuthenticationResult

This is the interface that represents an authentication result.

IIdentificationOptions

This is the interface that represents the identification options. This interface extends IMatchingOptions.

IIdentificationResult

This is the interface that represents an identification result.

IIdentificationCandidate

This is the Interface that represents a candidate result.

VideoRecordingReadyForGenerationListener (Only for Face capture and RemoteFace capture)

This sets the listener for to get a VideoRecording. This listener is called when recording is enabled. It is called on successful and failed capture.

Setting callback

captureHandler.setVideoRecordingReadyForGenerationListener({ videoRecording ->    //Video recording object to generate video})

Callback returns VideoRecording object to generate video from capture.

VideoRecordingOptions

This object is used to configure the behavior of the VideoRecording. You cannot generate two or more videos at the same time.

VideoRecording

This object is used to generate video in MP4 format. On success, it return the path to the video. You can generate one video.

videoRecording.generateVideo(object: VideoProgressListener {    override fun onError(error: VideoError) {        //It's call when generating video failed or another video is current generating    }
    override fun onFinish(path: String) {        //When creating video comlete with success return path to video    }
    override fun progress(progress: Int) {        //Showing progress of generating video from 0 to 100    }})

BioMatcher handler 

This interface provides all the necessary helper methods to perform all the matching, identifying, and template coding operations.

Authenticate

This verifies a list of candidate templates against a list of reference templates. This method can be used to authenticate users.

Note: Review the use cases named Authenticate.

An example snippet is shown:

//Authentication optionsval authenticationOptions: IAuthenticationOptions  = AuthenticationOptions()authenticationOptions.threshold = 3500
//Biometric candidateval biometricCandidate: IBiometricCandidate = BiometricCandidate(BiometricModality.FACE)//We add all the templates for this candidatebiometricCandidate.addTemplates(candidates)
//Biometric referencesval biometricReference: IBiometricReference = BiometricReference(user.getUuid(), BiometricModality.FACE)//We add all the templates for this userbiometricReference.addTemplates(references)
matcherHandler.authenticate(authenticationOptions, biometricCandidate, biometricReference,    object : BioMatcherAsyncCallbacks<IAuthenticationResult?> {        override fun onPreExecute() {            // Optional hook on the builtin Android AsyncTask callback `onPreExecute`        }
        override fun onSuccess(result: IAuthenticationResult) {            //The result of the authentication            val resultScore = result.score            //authentication status (FAILURE, SUCCESS...)            val authenticationStatus: AuthenticationStatus = result.getStatus()        }
        override fun onError(e: Exception) {            // An error has occurred        }    })

Function

Javavoid authenticate(IAuthenticationOptions authenticationOptions, IBiometricCandidate biometricCandidate, IBiometricReference biometricReference, BioMatcherAsyncCallbacks<IAuthenticationResult> callbacks);

Errors

You will receive an exception reporting the error.

Authenticate synchronous

This verifies a list of candidate templates against a list of reference templates. This method can be used to authenticate users.

Note: This function must be executed in a different thread than the UI. Check the use cases named Authenticate.

An example snippet is shown:

//Authentication optionsval authenticationOptions: IAuthenticationOptions = AuthenticationOptions()authenticationOptions.threshold = 3500
//Biometric candidateval biometricCandidate: IBiometricCandidate = BiometricCandidate(BiometricModality.FACE)//We add all the templates for this candidatebiometricCandidate.addTemplates(candidates)
//Biometric referencesval biometricReference: IBiometricReference = BiometricReference(user.getUuid(), BiometricModality.FACE)//We add all the templates for this userbiometricReference.addTemplates(references)
val result: IAuthenticationResult = matcherHandler.authenticate(authenticationOptions, biometricCandidate, biometricReference)//The result of the authenticationval resultScore = result.score//authentication status (FAILURE, SUCCESS...)val authenticationStatus: AuthenticationStatus = authenticationResult.getStatus()

Function

An example snippet is shown.

JavaIAuthenticationResult authenticate(IAuthenticationOptions authenticationOptions, IBiometricCandidate biometricCandidate, IBiometricReference biometricReference);

Errors

You will receive an exception reporting the error.

Identify

This method can be used to identify users. It identifies the user from the list of candidate templates that are matched against the list of reference templates.

Note: Check the use case named Identify.

An example snippet is shown:

//Identification optionsval identificationOptions: IIdentificationOptions = IdentificationOptions()
//Biometric candidateval biometricCandidate: IBiometricCandidate = BiometricCandidate(BiometricModality.FACE)
//We add all the templates for this candidatebiometricCandidate.addTemplates(candidates)
//We create the list of referencesval biometricReferences = ArrayList<IBiometricReference>()//Biometric reference for one userval biometricReference: IBiometricReference = BiometricReference(user.getUuid(), BiometricModality.FACE)//We add all the templates for this userbiometricReference.addTemplates(references)
//We add the user to the listbiometricReferences.add(biometricReference)
matcherHandler.identify(identificationOptions, biometricCandidate, biometricReferences,     object : BioMatcherAsyncCallbacks<IIdentificationResult?> {         override fun onPreExecute() {            // Optional hook on the builtin Android AsyncTask callback `onPreExecute`        }
        override fun onSuccess(result: IIdentificationResult) {            //The identification result            val candidates = result.identificationCandidateList            if (candidates.size > 0) {                val candidate = candidates[0]                val userUUID = candidate.uuid                val candidateScore = candidate.score            }        }
        override fun onError(e: Exception) {            // An error has occurred        } })

Function

An example snippet is shown.

Javavoid identify(IIdentificationOptions identificationOptions, IBiometricCandidate biometricCandidate, List<IBiometricReference> biometricReferences, BioMatcherAsyncCallbacks<IIdentificationResult> callbacks);

Errors

You will receive an exception reporting the error.

Identify synchronous

This method can be used to identify users.

It identifies the user from the list of candidate templates that are matched against a list of reference templates.

Note: This function must be executed in a different thread than UI. Check the use case named Identify.

An example snippet is shown.

//Identification optionsval identificationOptions: IIdentificationOptions = IdentificationOptions()
//Biometric candidateval biometricCandidate: IBiometricCandidate = BiometricCandidate(BiometricModality.FACE)//We add all the templates for this candidatebiometricCandidate.addTemplates(candidates)
//We create the list of referencesval biometricReferences = ArrayList<IBiometricReference>()//Biometric reference for one userval biometricReference: IBiometricReference = BiometricReference(user.getUuid(), BiometricModality.FACE)//We add all the templates for this userbiometricReference.addTemplates(references)
//We add the user to the listbiometricReferences.add(biometricReference)
//The identification resultval result: IIdentificationResult = matcherHandler.identify(identificationOptions, biometricCandidate, biometricReferences)if (candidates.size() > 0) {    val candidate: IIdentificationCandidate = candidates.get(0)    val userUUID = candidate.uuid    val candidateScore = candidate.score}

Function

An example snippet is shown.

JavaIIdentificationResult identify(IIdentificationOptions identificationOptions, IBiometricCandidate biometricCandidate, List<IBiometricReference> biometricReferences);

Errors

You will receive an exception reporting the error.

Detect biometrics

This allows you to detect the biometrics in a MorphoImage.

This function extracts all the biometric templates contained in an image (such as, all the faces that are in an image).

Note: Check the use case named Detect Biometric.

//Create a populate optionsval detectBiometricsOptions: IDetectBiometricOptions = DetectBiometricsOptions()detectBiometricsOptions.biometricLocation = BiometricLocation.FACE_FRONTALdetectBiometricsOptions.biometricModality = BiometricModality.FACE
bioMatcherHandler.detectBiometric(detectBiometricsOptions, image, object : BioMatcherAsyncCallbacks<List<IMorphoTemplate?>?> {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask callback `onPreExecute`    }
    override fun onSuccess(result: List<IMorphoTemplate?>) {        //A List of templates extracted from the image    }
    override fun onError(e: Exception) {        // An error has occurred    }})

Function

An example snippet is shown.

Javapublic void detectBiometric(final IDetectBiometricOptions detectBiometricsOptions, final IImage image, BioMatcherAsyncCallbacks<List<IMorphoTemplate>> callbacks)

Errors

You will receive an exception reporting the error.

Detect biometric synchronous

This allows you to detect the biometrics in a MorphoImage.

This function extracts all the biometric templates contained in an image (such as, all the faces that are in an image).

Note: This function must be executed in a different thread than the UI. Check the use case named Detect Biometric.

An example snippet is shown.

//Create a populate optionsval detectBiometricsOptions: IDetectBiometricOptions = DetectBiometricsOptions()detectBiometricsOptions.biometricLocation = BiometricLocation.FACE_FRONTALdetectBiometricsOptions.biometricModality = BiometricModality.FACE
//A List of templates extracted from the imageval templates: List<IMorphoTemplate> = bioMatcherHandler.detectBiometric(detectBiometricsOptions, image)

Function

An example snippet is shown.

Javapublic List<IMorphoTemplate> detectBiometric(final IDetectBiometricOptions detectBiometricsOptions, final IImage image)

Errors

You will receive an exception reporting the error.

Destroy

This releases all the handler resources as shown in the snippet:

handler.destroy()

Creating a BioMatcher Handler 

This allows you to retrieve a handler to perform all the matching, identifying, and template coding operations.

• Review the use cases named Create BioMatcherHandler.

• Review the features provided by this handler here.

val bioMatcherSettings: IBioMatcherSettings = BioMatcherSettings()val debugSettingsBuilder: DebugSettingsBuilder = DebugSettingsBuilder()val debugDataSettings: DebugDataSettings = debugSettingsBuilder.logLevel(LogLevel.DISABLE)    .storingType(DataStoringType.LAST_SESSION_ONLY)    .build()bioMatcherSettings.debugDataSettings = debugDataSettings
BioSdk.createBioMatcherHandler(this, bioMatcherSettings, object : BioMatcherAsyncCallbacks<IBioMatcherHandler?> {    override fun onPreExecute() {        // Optional hook on the builtin Android AsyncTask call-back `onPreExecute`    }
    override fun onSuccess(result: IBioMatcherHandler) {        // Indicates that initialization succeeded. The returned handler can be used to perform the matching and identify operations.    }
    override fun onError(e: Exception) {        // An error has occurred.    }})

Errors

You will receive an exception reporting the error.

Enums 

ColorSpace

This is the colorspace enum.

Camera

This is the enum used to configure the camera for the capture.

CameraFlash enum

This enum is used to configure the camera flash of the capture.

Overlay

This is the enum used to configure the overlay for the capture.

LogLevel

This enum controls the log level.

CaptureHandlerStatus enum

This enum retrieves the status of the capture handler.

BioCaptureHandlerError

This enums gives information why msc async failed

FaceLiveness enum

This enum describes liveness verification mode.

FaceLivenessSecurityLevel enum

Security level for face liveness capture. Defines how restrictive the liveness verification will be. The higher the level is set, the more restrictive the verification will be.

FaceLivenessResult enum

This enum represents the result of a face liveness check.

FaceCaptureInfo enum

BiometricLocation enum

BiometricModality enum

Cr2dMode enum

MorphoFaceTemplateFormat enum

This enum retrieves information about the face template format.

FaceTemplateQuality enum

This enum retrieves information about quality of the face saved in template.

CaptureError enum

This enum reports the reason that a capture attempt failed.

AuthenticationStatus enum

This enum contains the authentication status.

LogLevel enum

This enum controls the logging level.

Example code

Kotlinval IMAGE_SIZE = 400val JPEG_COMPRESSION_LEVEL = 90
private fun prepareImage(image: ByteArray): ByteArray {        val imageBitmap = BitmapFactory.decodeByteArray(image, 0, image.size)        val scaledBitmap = Bitmap.createScaledBitmap(imageBitmap, IMAGE_SIZE, IMAGE_SIZE, true)        imageBitmap.recycle()        val byteArrayOutStream = ByteArrayOutputStream()        val result = scaledBitmap.compress(Bitmap.CompressFormat.JPEG, JPEG_COMPRESSION_LEVEL, byteArrayOutStream)        scaledBitmap.recycle()        return byteArrayOutStream.toByteArray()}