IDentity-SDK

Introduction

This guide introduces the IDentity Android SDK within the IDmission product suite. Developers, project managers and QA testers should reference this guide for information on configuration and use of the IDentity SDK on the Android platform. We recommend reviewing the entire implementation guide to fully understand the IDentity SDK functionality and its respective capabilities.

This guide details processes and procedures for embedding the IDentity SDK into your host application and utilizing its current features. For additional IDentity SDK support, please contact our Customer Support team at support@idmission.com.

Overview and Key Features

The IDmission IDentity SDK is a comprehensive toolkit that enables the use of any combination of factors of identity to complete digital transformation goals. The goal of the IDentity SDK is to offer seamless integration into an existing digital paradigm where the end-to-end customer experience is still owned and managed in-house.

Quick Links to get started with IDentity SDK for Android

SDK Flavours Download Links - As per your requirement you can downloads the below IDentityMediumSDK / IDentityMediumSDKWithoutModels.

Download IDentityMediumSDK - Directly links to the IDentityMediumSDK Sample app on IDmission GitHub Repository
Download IDentityMediumSDKWithoutModels - Directly links to the IDentityMediumSDKWithoutModels Sample app on IDmission GitHub Repository

The main features supported in this SDK are:

• Live face Check
  
• ID Validation
  
• ID Validation and face match
  
• Enrollment
  
• Enrollment with Biometrics
  
• Customer Verification
  
• Auto Fill
  
• Video ID
  
  

SDK Server API call

• Initialize SDK
  
• Final Submit
  
• Generic Final Submit
  
  

Technical Prerequisites

Before integrating the SDK, ensure your environment meets the following requirements:

Android Manifest Permissions

The SDK requires the following permissions and features to be declared in your AndroidManifest.xml:

<!-- Hardware Features -->
<uses-feature android:name="android.hardware.camera.any" />

<!-- Required Permissions -->
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.VIBRATE" />
<uses-permission android:name="android.permission.WAKE_LOCK" />

<!-- Optional/Feature Specific Permissions -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />

Note: android.permission.NFC and the android.hardware.nfc feature are not part of this base manifest. They're declared inside the optional idmission-nfc module and merge into your app automatically only if you add that module as a dependency.

Getting Started

1. Please contact to sales@idmission.com for Login Credentials, which you will later pass to the SDK.

2.1. (Groovy) Go to your project-level build.gradle file, and add the following in the allprojects block:

```
allprojects {  
    repositories {  
        google()  
        mavenCentral()  
        // important stuff below  
        maven {
            url "https://gitlab.idmission.com/api/v4/projects/220/packages/maven"
            name "GitLab"
            credentials(HttpHeaderCredentials) {
                name = "Private-Token"
                value = "WESesyuSD9fQeqNEyig6"
            }
            authentication {
                header(HttpHeaderAuthentication)
            }
        }
        //Required for fingerprint capture
        maven { url 'https://jitpack.io' }
    }  
}
```

2.2. (Kotlin DSL) Go to your project-level settings.gradle.kts file, and add the following:

   pluginManagement {
        repositories {
            google()
            mavenCentral()
            gradlePluginPortal()
        }
    }
    dependencyResolutionManagement {
        repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
        repositories {
            google()
            mavenCentral()
            // important stuff below 
            maven {
                url = uri("https://gitlab.idmission.com/api/v4/projects/220/packages/maven")
                name = "GitLab"
                credentials(HttpHeaderCredentials::class) {
                    name = "Private-Token"
                    value = "WESesyuSD9fQeqNEyig6"
                }
                authentication {
                    create<HttpHeaderAuthentication>("header")
                }
            }
            //Required for fingerprint capture
            maven {
                 url = uri("https://jitpack.io")
            }
        }
    } 
    rootProject.name = "AndroidSDKWithKTS"
    include(":app")

3. In your app-level build.gradle (or build.gradle.kts) file, add the following:

```
android {  
    // Java 17 is required for the latest CameraX and SDK features
    compileOptions {  
        sourceCompatibility JavaVersion.VERSION_17  
        targetCompatibility JavaVersion.VERSION_17  
    }  
    kotlinOptions {  
        jvmTarget = "17"  
    }  
}

//IdentityVideoID SDK
dependencies {  
     implementation 'com.idmission.sdk2:idmission-videoidsdk:11.1.5.2.29'     
}

//IdentityVideoIDWithoutModels SDK
dependencies {  
    implementation 'com.idmission.sdk2:idmission-videoidsdkwithoutmodels:11.1.5.2.29'     
}

//IdentityMedium SDK
dependencies {  
     implementation 'com.idmission.sdk2:idmission-mediumsdk:11.1.19.2.10'     
}

//IdentityMediumWithoutModels SDK
dependencies {  
     implementation 'com.idmission.sdk2:idmission-mediumsdkwithoutmodels:11.1.19.2.10'     
}

//IdentityLite SDK
dependencies {  
     implementation 'com.idmission.sdk2:idmission-litesdk:11.1.19.2.10'     
}

//IdentityLiteWithoutModels SDK
dependencies {  
     implementation 'com.idmission.sdk2:idmission-litesdkwithoutmodels:11.1.19.2.10'     
}

//IdentityLiveness SDK
dependencies {  
implementation 'com.idmission.sdk2:idmission-livenesssdk:11.1.19.2.10'     
}

//IdentityLivenessWithoutModels SDK
dependencies {  
    implementation 'com.idmission.sdk2:idmission-livenesssdkwithoutmodels:11.1.19.2.10'     
}
```

4. Sync your project with Gradle

5. Generate Access Token :

Tokens are to be obtained on your server and sent to the client in the initialize call.

Login Credentials required for token generation.

The following details are required to generate a token:

* Auth_url : Authentication url for the given environment

* client_id : Client ID generated for the specific company

* client_secret : Client credentials/secret generated for the specific company

* Username : Integ user name

* Password: Password of the Integ user

All company login details needed are provided upon sign up on the Identity Portal.

Token Generation using RESTful API

Token Generation Sample Request:

         curl --location --request POST 'https://auth.idmission.com/auth/realms/identity/protocol/openid-connect/token' \
         --header 'Content-Type: application/x-www-form-urlencoded' \
         --data-urlencode 'grant_type=password' \
         --data-urlencode 'client_id=XXXXXXX' \
         --data-urlencode 'client_secret=XXXXXXXX' \
         --data-urlencode 'username=XXXXXXXX' \
         --data-urlencode 'password=XXXXXXXXX' \
         --data-urlencode 'scope=api_access'

Sample Response - Token Generation:

     {
        "access_token": "eyJhbGciO....5gNZx03Myb8ZuyY2gu3u-8KgGmULBs9mkPcg",
        "expires_in": 18000,
        "refresh_expires_in": 0,
        "token_type": "Bearer",
        "session_state": "e0b689e8-e7c6-47b7-bf9d-1349ea813c96",
        "scope": "email profile api_access"
     }

The following details are the response parameters

* access_token : Access Token value

* expires_in : Access token expires time in seconds

* refresh_expires_in : Refresh access token expires time in seconds

* token_type : Token type

* session_state : session state value

* scope : Token scope

6. SDK Initialization API.

• Initialize SDK
  

Token obtained from server needs to be passed in initialize call as below

     IdentityProofingSDK.initialize(
     activity,
     apiBaseUrl = apiBaseUrl,
     sdkCustomizationOptions = SDKCustomizationOptions(language = "EN"),
     enableDebug = false,
     accessToken = accessTokenValue)

7. You may now use the library. Example usage below:

    ```kotlin
    class LaunchActivity : AppCompatActivity() {    
    
         private var apiBaseUrl = "https://api.idmission.com/"
         private val enableDebug = false
         private val enableGPS = true
         
         // 1. Initialize the launcher to receive results
         private val idMissionLauncher = registerForActivityResult(
             IdMissionCaptureLauncher()
         ) { result ->
             // Handle the capture result here
             if (result != null) {
                // do whatever you want with the data!
             }
         }
        
        override fun onCreate(savedInstanceState: Bundle?) {  
            super.onCreate(savedInstanceState)  
            setContentView(R.layout.activity_launch)
            
            // 2. SDK initialize call (Recommended to do this early)
            init_button.setOnClickListener {
                lifecycleScope.launch {
                    val response = withContext(Dispatchers.IO) {
                        // Generate a token as described in the 'Generate Access Token' section.
                        IdentityProofingSDK.initialize(
                            applicationContext, 
                            apiBaseUrl = apiBaseUrl, 
                            enableDebug = enableDebug,
                            enableGPS = enableGPS,
                            sdkCustomizationOptions = SDKCustomizationOptions(language = "EN"),
                            accessToken = "YOUR_ACCESS_TOKEN"
                        )
                    }
                    // Handle initialization response
                }
            }
            
            // 3. Launch a service (e.g., ID Validation & Enrollment)
            someButton.setOnClickListener {
                IdentityProofingSDK.idValidationAndcustomerEnroll(
                    this,
                    uniqueNumber = "UNIQUE_ID_123"
                ) 
            }  
            
            // 4. Final submit call to send data to the server
            submitDataButton.setOnClickListener {
                lifecycleScope.launch {
                    IdentityProofingSDK.finalSubmit(applicationContext)
                }
            }  
        }
    }
    ```

Additional supported features

• Document Capture
  
• Voice Capture
  

• Signature Capture
  

• Four Fingerprint Capture
  
  

Getting Started for Signature Capture

1. In your app-level build.gradle file, add the following:

    android {  
        // Java 17 is required for latest SDK features
        compileOptions {  
            sourceCompatibility JavaVersion.VERSION_17  
            targetCompatibility JavaVersion.VERSION_17  
        }  
        kotlinOptions {  
            jvmTarget = "17"  
        }  
    }
    
    dependencies {  
         implementation 'com.idmission.sdk2:signatureLib:11.01.07.05'    
    }
    

   Content copied to clipboard

2. Sync your project with Gradle

3. To capture a signature, use the following code.

    SignatureSDK.captureSignature(Activity activityContext)
    
    SignatureSDK.captureSignature(
        Activity activityContext, 
        JSONObject captureSignatureConfig)

   Content copied to clipboard

   Signature Capture Parameters

   Parameter	Type	Description
   activityContext	Context	Instance of your Activity
   captureSignatureConfig	JSONObject	{

      "signature_capture_screen_background_color": "#FFFFFF",
         "signature_capture_screen_box_border_color": "#000000",
   
         "signature_stroke_color": "#0000FF",
         "signature_stroke_size": "20",
   
         "signature_title_text": "Please Sign Below",
         "signature_title_text_color": "#0000FF",
         "signature_title_text_font": "font/custom_font.ttf",
         "signature_title_text_font_size": "20",
       
         "signature_done_btn_text": "Done 1",
         "signature_done_btn_text_color": "#FFFFFF",
         "signature_done_btn_text_font_size": "20",
         "signature_done_btn_text_font": "font/custom_font.ttf",
         "signature_done_btn_background": "done_button",
       
         "signature_clear_btn_text": "Clear 1",
         "signature_clear_btn_text_color": "#FF0000",
         "signature_clear_btn_text_font_size": "20",
         "signature_clear_btn_text_font": "font/custom_font.ttf",
         "signature_clear_btn_background": "cancel_button",
       
         "signature_back_btn_tint_color": "#FF0000",
         "signature_back_btn_image": "back_cancel_arrow",
         
       } 

   Content copied to clipboard

1. You may now use the library. Example usage below:

    class LaunchActivity : Activity() {    
   
        override fun onCreate(savedInstanceState: Bundle?) {  
            super.onCreate(savedInstanceState)  
            setContentView(R.layout.activity_launch)
         
            //SDK signature call
            signatureCapture.setOnClickListener{
            var doneBtnText = getString(R.string.done)
                var cancelBtnText = getString(R.string.clear)
                var signTitle = getString(R.string.sign_title)
   
                SignatureSDK.captureSignature(this@LaunchActivity, JSONObject("{
                "signature_capture_screen_background_color": "#FFFFFF",
                "signature_capture_screen_box_border_color": "#000000",
   
                "signature_stroke_color": "#0000FF",
                "signature_stroke_size": "20",
   
                "signature_title_text": "Please Sign Below",
                "signature_title_text_color": "#0000FF",
                "signature_title_text_font": "font/custom_font.ttf",
                "signature_title_text_font_size": "20",
         
                "signature_done_btn_text": "Done 1",
                "signature_done_btn_text_color": "#FFFFFF",
                "signature_done_btn_text_font_size": "20",
                "signature_done_btn_text_font": "font/custom_font.ttf",
                "signature_done_btn_background": "done_button",
         
                "signature_clear_btn_text": "Clear 1",
                "signature_clear_btn_text_color": "#FF0000",
                "signature_clear_btn_text_font_size": "20",
                "signature_clear_btn_text_font": "font/custom_font.ttf",
                "signature_clear_btn_background": "cancel_button",
         
                "signature_back_btn_tint_color": "#FF0000",
                "signature_back_btn_image": "back_cancel_arrow"
           
            }"))
         }
         
   
        // Signature result is received in onActivityResult and set this result to SDK 2.0 Api setSignatureData  
        override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {  
            data ?: return  
            if (requestCode == SignatureConstants.SIGNATURE_CAPTURE_REQUEST_CODE) {
                var signatureData = data?.getStringExtra("SignatureImage")
                var signatureDataCoordinates = data?.getStringExtra("SignatureDataCoordinates")
                IdentityProofingSDK.setSignatureData(signatureData,signatureDataCoordinates)
            } else if (requestCode == SignatureConstants.SIGNATURE_CANCEL_RESPONSE_CODE) {
                // cancelled by user
                IdentityProofingSDK.setSignatureData(null,null)
            }
        } 

   Content copied to clipboard

Getting Started for Four Fingerprint Capture

1. In your app-level build.gradle file, add the following:

    android {  
        // Java 17 is required for latest SDK features
        compileOptions {  
            sourceCompatibility JavaVersion.VERSION_17  
            targetCompatibility JavaVersion.VERSION_17  
        }  
        kotlinOptions {  
            jvmTarget = "17"  
        }  
    }
    
    dependencies {  
        implementation 'com.idmission.sdk2:4FingerprintCaptureLib:11.01.01.01' 
    }
    

   Content copied to clipboard

2. Sync your project with Gradle

3. You may now use the library. Example usage below:

    class LaunchActivity : Activity() {    
    
        override fun onCreate(savedInstanceState: Bundle?) {  
            super.onCreate(savedInstanceState)  
            setContentView(R.layout.activity_launch)
            
            //capture fingerprint
            fingerPrintCapture.setOnClickListener{
                val indexCapture: Boolean = true
                val middleCapture: Boolean = true
                val ringCapture: Boolean = true
                val babyCapture: Boolean = true
    
                val dIndexKeep = true
                val dMiddleKeep = true
                val dRingKeep = true
                val dBabyKeep = true
    
                val captureLeftHand: Boolean = true
                val instructionScreen: Boolean = false
                val config = JSONObject()
                config.put(
                    UIConfigurationParameters.CFC_PROCESS_INDEX_FINGER,
                    if (indexCapture) "Y" else "N"
                )
                config.put(
                    UIConfigurationParameters.CFC_PROCESS_MIDDLE_FINGER,
                    if (middleCapture) "Y" else "N"
                )
                config.put(
                    UIConfigurationParameters.CFC_PROCESS_RING_FINGER,
                    if (ringCapture) "Y" else "N"
                )
                config.put(
                    UIConfigurationParameters.CFC_PROCESS_BABY_FINGER,
                    if (babyCapture) "Y" else "N"
                )
                config.put(
                    UIConfigurationParameters.CFC_CAPTURE_LEFT_HAND,
                    if (captureLeftHand) "Y" else "N"
                )
    
                config.put(
                    UIConfigurationParameters.CFC_KEEP_INDEX_FINGER,
                    if (dIndexKeep) "Y" else "N"
                )
                config.put(
                    UIConfigurationParameters.CFC_KEEP_MIDDLE_FINGER,
                    if (dMiddleKeep) "Y" else "N"
                )
                config.put(
                    UIConfigurationParameters.CFC_KEEP_RING_FINGER,
                    if (dRingKeep) "Y" else "N"
                )
                config.put(
                    UIConfigurationParameters.CFC_KEEP_BABY_FINGER,
                    if (dBabyKeep) "Y" else "N"
                )
    
                config.put(
                    UIConfigurationParameters.CFC_SHOW_INSTRUCTION_SCREEN,
                    if (instructionScreen == true) "Y" else "N"
                )
                //set language for sdk capture
                FingerPrintCaptureSDK.setLanguage(LanguageUtils.LANGUAGE.ES.toString())
                
                FingerPrintCaptureSDK.captureFourFingerprint(this@IDCaptureActivity,
                    config
                ) { resultMap, response -> //set 4fingerPrintData in to the sdk 2.0
                    IdentityProofingSDK.set4FingerPrintData(resultMap)
                }
            }
    
        

   Content copied to clipboard

Custom Camera Fingerprint Capture Configurations

Getting Started for NFC / ePassport and Card Chip Reading

1. In your app-level build.gradle file, add the following:

    android {  
        // Java 17 is required for latest SDK features
        compileOptions {  
            sourceCompatibility JavaVersion.VERSION_17  
            targetCompatibility JavaVersion.VERSION_17  
        }  
        kotlinOptions {  
            jvmTarget = "17"  
        }  
    }
    
    dependencies {  
         implementation 'com.idmission.sdk2:idmission-nfc:11.1.19.2.10'    
    }
    

   Content copied to clipboard

2. Sync your project with Gradle

3. To capture NFC data, use the following code.

    IdentityProofingSDK.idValidation(
        activity,
        idType = idMaster,
        idCountry = countryMaster,
        idState = stateMasterVO,
        additionalFlag,
        SDKCustomizationOptions(
            idCaptureCustomizationOptions = IDCaptureCustomizationOptions(
                enablePassportNfc = true
            )
        )
    )

   Content copied to clipboard

   NFC Capture Parameters

   enablePassportNfc	Boolean	Toggles NFC/ePassport chip scanning. Requires the optional idmission-nfc module to be added as a dependency.

4. You may now use the library. Example usage below:

    class LaunchActivity : Activity() {    
    
        override fun onCreate(savedInstanceState: Bundle?) {  
            super.onCreate(savedInstanceState)  
            setContentView(R.layout.activity_launch)
            
            //SDK nfc call
            nfcCapture.setOnClickListener{
                IdentityProofingSDK.idValidation(
                    this@LaunchActivity,
                    idType = idMaster,
                    idCountry = countryMaster,
                    idState = stateMasterVO,
                    additionalCustomerFlagData = additionalFlag,
                    sdkCustomizationOptions = SDKCustomizationOptions(
                        idCaptureCustomizationOptions = IDCaptureCustomizationOptions(
                            enablePassportNfc = true
                        )
                    )
                )
            }
        }
    }

   Content copied to clipboard

NFC chip data comes back as eDocument: EDocument? on the same result object the MRZ side already carries.

Parameters Used-

SDK initialization-

• activityContext - Activity context.

• apiBaseUrl - Base url provided by IDmission for API calls.

• enableDebug - (Boolean) If you want to enable debug options or not.

• enableGPS - (Boolean) If you want to enable GPS options or not.

• sdkCustomizationOptions - SDKCustomizationOptions options if you want to add your customized UI details.

• isUpdateModelsData - (Boolean) If you want to update model from the server.

• accessToken - Access token value

Service Enroll Call

• UniqueNumber - Unique Number required.

SDK UI Customization Options-

You can customize almost every aspect of the ID and Selfie capture screens by passing SDKCustomizationOptions to the initialization or individual service calls. Below is the complete technical reference of every available field in the SDK.

1. The Main Customization Entry Point (SDKCustomizationOptions)

The SDKCustomizationOptions class acts as the master container for all UI and behavioral settings across the different capture modules (ID, Selfie, Document, etc.).

Sub-Option Modules

The main class also hosts specialized customization blocks for each workflow:

• idCaptureCustomizationOptions: Logic and UI for identity documents — see §2.

• selfieCaptureCustomizationOptions: Logic and UI for liveness and face capture — see §3.

• documentCaptureCustomizationOptions: Settings for generic document capture — see §5.

• signatureCaptureCustomizationOptions: Settings for signature pad screens — see §6.

• voiceCaptureCustomizationOptions: Settings for voice recording/biometrics — see §7.

• autoFillCaptureCustomizationOptions: Settings for automated data extraction flows — see §8.

• nfcCaptureCustomizationOptions: Settings for the NFC/ePassport chip reading screens (requires the optional idmission-nfc module) — see §4.

2. ID Capture Technical Reference (IDCaptureCustomizationOptions)

The IDCaptureCustomizationOptions class contains settings specific to the document scanning workflow, across four screens:

• Capture Screen — the live camera view: the per-side title label, a shared floating status/prompt text, the wrong-side mismatch override banner, the top bar, and the auto-capture progress ring.

• Instruction Screen — optional pre-capture instructions (enableIdInstructionScreen / enableDocumentInstructionScreen).

• Retry Screen — shown when a capture ultimately fails validation.

• Preview Screen — optional post-capture confirmation (isIDCapturePreviewEnabled).

2.1 General ID Capture Settings

2.2 ID Capture Core Logic (IDCaptureOptions)

2.3 ID Capture Screen Reference — Text, Font & Color (screen-wise)

Every text element on the ID Capture screens, grouped by screen and, on the Capture Screen, by the UI region it belongs to — same convention as §4.1. Font Key lists the size field and the custom-typeface field together (fontOptions.*FontSize / fontOptions.*Font); Color Key lists the text-color field and, where the row is a button, its background-color field together (colorOptions.*). Default Text is the literal fallback string shown when the field is left unset, verified against values/strings.xml/the call site — not a paraphrase.

Capture Screen — Per-Side Title

Capture Screen — Floating Status/Prompt Text

The messages below all render through a single shared floating text view, not independent labels — they cannot be individually colored or sized. Its typography is always fontOptions.labelPromptFont / labelPromptFontSize; its background/text color depends on the message's severity:

Fields confirmed live-wired, with their real default text:

Capture Screen — Wrong-Side Mismatch Override

Shown when the detected side doesn't match what's expected (e.g. Back shown when Front is required); pairs with the buttons in §2.6.

Capture Screen — Top Bar

Instruction Screen

Retry Screen

Two buttons — but note stringOptions' field naming doesn't match colorOptions/fontOptions here: the field literally named retryScreenCancelButtonText is the screen's Done button (its default falls back to "Done", and it's styled by the retryScreenDoneButton* fields, not by any retryScreenCancel* field).

Preview Screen

Declared here, but not ID front/back — the Additional Document Capture operation

Two fields live in IDCaptureCustomizationOptions (not DocumentCaptureCustomizationOptions, §5 — a genuinely different class) but actually style the SDK's separate "additional document" capture operation (Operation.DOCUMENT_CAPTURE, a distinct request code from ID front/back), used for capturing supplementary documents beyond the primary ID. Do not treat these as ID labels:

The matching illustration is imageOptions.documentInstructionImageResId (§2.4) — a separate image from idInstructionImageResId.

2.4 ID Capture Images (IDImageOptions)

2.5 ID Capture Layout & Visibility (IDLayoutOptions)

2.6 ID Capture Buttons — Quick Reference

Every button across the ID Capture flow in one place. All fields below live inside idCaptureCustomizationOptions, and each button's fields only affect that one button:

idCaptureCustomizationOptions = IDCaptureCustomizationOptions().apply {
    stringOptions.apply {
        captureScreenFrontIDLabel = "Front of your ID"
        idCaptureWarningMessage = "Please show the back of your ID"
        retryButtonText = "Try Again"
        retryScreenCancelButtonText = "Close" // this is the screen's Done button, not Cancel
    }
    colorOptions.apply {
        captureScreenFrontIDLabelColor = "#FFFFFF"
        warningLabelBackgroundColor = "#FFC107"
        retryScreenRetryButtonBgColor = "#2196F3"
        retryScreenDoneButtonBgColor = "#9E9E9E"
    }
    fontOptions.apply {
        captureScreenFrontIDTextFontSize = 18
        retryScreenRetryButtonFontSize = 16
    }
    layoutOptions.apply {
        captureAnywayButton = R.drawable.custom_capture_anyway_bg
        retryScreenRetryBtnBg = R.drawable.custom_retry_button_bg
    }
}

3. Selfie Capture Technical Reference (SelfieCaptureCustomizationOptions)

The SelfieCaptureCustomizationOptions class contains settings specific to the face capture workflow, across the same four kinds of screen as ID Capture (§2):

• Capture Screen — the live camera view: the toolbar title, a shared floating status/prompt text, and the top bar cancel control.

• Instruction Screen — optional pre-capture instructions (enableSelfieInstructionScreen).

• Retry Screen — shown when a capture ultimately fails validation.

• Preview Screen — optional post-capture confirmation (isSelfieCapturePreviewEnabled).

3.1 Selfie Capture Logic (SelfieCaptureOptions)

3.2 Selfie Capture Screen Reference — Text, Font & Color (screen-wise)

Every text element on the Selfie Capture screens, grouped by screen and, on the Capture Screen, by the UI region it belongs to — same convention as §2.3/§4.1.

Capture Screen — Toolbar Title

Capture Screen — Floating Status/Prompt Text

As with ID Capture (§2.3), every message below renders through a single shared floating text view — not independent labels. Its typography is always fontOptions.labelPromptFont / labelPromptFontSize; its background/text color depends on severity, using the same three-tier scheme as §2.3 (captureScreenSuccessTextColor/BgColor, captureScreenInfoTextColor/BgColor, captureScreenErrorTextColor/BgColor, all under colorOptions).

String keys sharing this text view: captureScreenError, moveCloser, moveAway, alignInsideOval, capturingFace, realFace, fakeFace, leftEyeClosed, rightEyeClosed, faceMaskDetected, tooMuchLight, tooDark, straightenHead, eyesClosed, multipleFaces, moveFaceDown, moveFaceUp, glassesDetected, hatDetected, scarfDetected, handDetected, scarfHatDetected, glassesHatDetected, holdStill, scarfGlassesDetected, maskDetected, maskHatDetected, scarfMaskDetected, maskGlassesDetected, faceNotInFocus, liveFaceNotDetected (all under stringOptions).

Capture Screen — Top Bar / Cancel Control

The Cancel control has two mutually exclusive modes: it renders as an icon when imageOptions.captureScreenCancelBtnImage is set, otherwise as text when stringOptions.captureScreenCancelBtnText is non-empty.

Instruction Screen

Retry Screen

Same naming quirk as ID Capture (§2.3): the field literally named retryCancelButtonText is the screen's Done button (defaults to "Done", styled by the retryScreenDoneButton* fields, not by any retryCancel*/retryScreenCancel* field).

Preview Screen

3.3 Selfie Capture Images (SelfieImageOptions)

3.4 Selfie Capture Layout & Visibility (SelfieLayoutOptions)

3.5 Selfie Capture Buttons — Quick Reference

Every button across the Selfie Capture flow in one place. All fields below live inside selfieCaptureCustomizationOptions, and each button's fields only affect that one button:

selfieCaptureCustomizationOptions = SelfieCaptureCustomizationOptions().apply {
    stringOptions.apply {
        captureScreenToolbarTitleText = "Take a Selfie"
        moveCloser = "Move closer to the camera"
        retryButtonText = "Try Again"
        retryCancelButtonText = "Close" // this is the screen's Done button, not Cancel
    }
    colorOptions.apply {
        captureScreenToolbarTitleTextColor = "#FFFFFF"
        retryScreenRetryButtonBgColor = "#2196F3"
        retryScreenDoneButtonBgColor = "#9E9E9E"
    }
    fontOptions.apply {
        captureScreenToolbarTitleTextFontSize = 18
        retryScreenRetryButtonFontSize = 16
    }
    layoutOptions.apply {
        retryScreenRetryBtnBg = R.drawable.custom_retry_button_bg
    }
}

4. NFC Capture Technical Reference (NfcCaptureCustomizationOptions)

The NfcCaptureCustomizationOptions class customizes the two screens shown during passport/ID NFC chip reading (added via the optional idmission-nfc module — see #getting-started-for-nfc--epassport-chip-reading):

• The scanning bottom sheet — shown while the chip is being read, with a Skip action.

• The error screen — shown when the scan fails, with Retry and Skip actions.

Both screens have their own Skip button, so Skip-related fields are duplicated: the nfcScreenSkipButton* fields style the scanning bottom sheet's Skip button, while the nfcErrorScreenSkipButton* fields style the error screen's Skip button. Retry-related fields (nfcErrorScreenRetryButton*) only apply to the error screen, since only that screen has a Retry button.

4.1 NFC Screen Reference — Text, Font & Color (screen- and type-wise)

Every text element on both NFC screens, grouped by screen. Font Key lists the size field and the custom-typeface field together (fontOptions.*FontSize / fontOptions.*Font); Color Key lists the text-color field and, where the row is a button, its background-color field together (colorOptions.*).

Instructions Screen (the scanning bottom sheet)

Error Screen

4.2 NFC Layout & Backgrounds (NfcLayoutOptions)

4.3 NFC Images (NfcImageOptions)

4.4 NFC Buttons — Quick Reference

Across both NFC screens there are three buttons total: the scanning bottom sheet's Skip, and the error screen's (PassportNfcReaderErrorActivity) Retry and Skip. All fields below live inside nfcCaptureCustomizationOptions, and each button's fields only affect that one button:

nfcCaptureCustomizationOptions = NfcCaptureCustomizationOptions().apply {
    stringOptions.apply {
        nfcErrorScreenRetryButtonText = "Try Again"
        nfcErrorScreenSkipButtonText = "Skip"
    }
    colorOptions.apply {
        nfcErrorScreenRetryButtonTextColor = "#FFFFFF"
        nfcErrorScreenRetryButtonBackgroundColor = "#2196F3"
        nfcErrorScreenSkipButtonTextColor = "#FFFFFF"
        nfcErrorScreenSkipButtonBackgroundColor = "#9E9E9E"
    }
    fontOptions.apply {
        nfcErrorScreenRetryButtonTextFontSize = 16
        nfcErrorScreenSkipButtonTextFontSize = 16
    }
    layoutOptions.apply {
        nfcErrorScreenRetryButtonBackground = R.drawable.custom_retry_button_bg
        nfcErrorScreenSkipButtonBackground = R.drawable.custom_skip_button_bg
    }
    imageOptions.apply {
        nfcErrorScreenImage = R.drawable.custom_error_icon
    }
}

4.5 Example

SDKCustomizationOptions(
    idCaptureCustomizationOptions = IDCaptureCustomizationOptions(
        enablePassportNfc = true
    ),
    nfcCaptureCustomizationOptions = NfcCaptureCustomizationOptions().apply {
        stringOptions.apply {
            nfcScreenReadyToScanTitle = "Hold your phone near the chip"
            nfcScreenSkipButtonText = "Skip for now"
            nfcErrorScreenSkipButtonText = "Skip"
        }
        colorOptions.apply {
            nfcScreenSkipButtonBackgroundColor = "#2196F3"
            nfcErrorScreenSkipButtonBackgroundColor = "#9E9E9E"
            nfcErrorScreenRetryButtonBackgroundColor = "#2196F3"
        }
        fontOptions.apply {
            nfcScreenReadyToScanTitleFontSize = 18
            nfcErrorScreenSkipButtonTextFontSize = 14
        }
    }
)

5. Document Capture Technical Reference (DocumentCaptureCustomizationOptions)

Settings for the generic (non-ID) document capture/upload flow. Unlike ID/Selfie/NFC, this class only has one customizable screen — the post-capture Preview screen — since the capture screen itself and the instruction screen (enableDocumentInstructionScreen) have no string/color/font/image options of their own.

Preview Screen — Text, Font & Color

Same field pattern as the ID Capture (§2.3) and Selfie Capture (§3.2) Preview screens:

Images & Layout

6. Signature Capture Technical Reference (SignatureCaptureCustomizationOptions)

The smallest customization block in the SDK — currently one field, with no string/color/font/image/layout sub-options:

7. Voice Capture Technical Reference (VoiceCaptureCustomizationOptions)

8. AutoFill Capture Technical Reference (AutoFillCaptureCustomizationOptions)

9. Comprehensive Usage Example (Kotlin)

private fun getCompleteSdkCustomization(): SDKCustomizationOptions {
    return SDKCustomizationOptions(
        language = LANGUAGE.EN.toString(),
        idCaptureCustomizationOptions = IDCaptureCustomizationOptions().apply {
            // General Configuration
            enableRealIDDetection = true
            enableIdInstructionScreen = true
            
            // Core Thresholds & Logic
            captureOptions.apply {
                allowOverrideWrongDocumentTypeAfterMs = 12000L
                wrongDocumentTypeHandlingMode = WrongDocumentTypeHandlingMode.MANUAL_CAPTURE
                frontRealnessThreshold = 0.85f
                separateIdCardCaptureSequence = true
            }
            // Strings & Feedback
            stringOptions.apply {
                captureScreenFrontIDLabel = "Verification: FRONT SIDE"
                previewScreenTitleIdFront = "FRONT VERIFIED"
                idCaptureWarningMessage = "Mismatch: Use Front side"
                moveCloser = "Bring the ID closer to the camera"
            }
            // Colors & Branding
            colorOptions.apply {
                warningLabelBackgroundColor = "#FFC107"
                progressBarColor = "#4CAF50"
                previewScreenBackgroundColor = "#F0F0F0"
                captureAnywayButtonColor = "#2196F3"
                exitButtonColor = "#2196F3"
            }
            // Typography (SP sizes and Font Resources)
            fontOptions.apply {
                labelFontSize = 18
                previewScreenTitleFontSize = 22
                labelFont = R.font.custom_bold
                previewScreenTitleFont = R.font.custom_bold_italic
            }
            // Layout & Visibility
            layoutOptions.apply {
                isIdCaptureProgressBarEnabled = true
                idCaptureProgressBarLineWidth = 8.0f
                isCaptureScreenToolbarTitleHide = true
            }
        },
        selfieCaptureCustomizationOptions = SelfieCaptureCustomizationOptions().apply {
            enableSelfieInstructionScreen = true
            captureOptions.liveFaceProbabilityThreshold = 0.92f
            stringOptions.liveFaceNotDetected = "Verification failed. Please stay in a well-lit area."
            colorOptions.captureScreenBgColor = "#121212" // Dark mode selfie
        }
    )
}

Setting an on cancelled callback

See the code snippet below for how to specify a callback function to be triggered when cancelling/backing out of an SDK operation:

IdentityProofingSDK.setOnCancelled(fun() { print("Cancelled") })

SDK documentation

You can find SDK documentation here

SDK Flavours

• IdentityVideoID SDK

• IdentityVideoID SDK Without Models

• IdentityMedium SDK

• IdentityMedium SDK Without Models

• IdentityLite SDK

• IdentityLite SDK Without Models

• IdentityLiveness SDK

• IdentityLiveness SDK Without Models

SDK Flavours Supported Features

Reduce APK size

1. Exclude specific ABI (Application Binary Interface) support like arm64-v8a, armeabi-v7a, x86_64, or x86

android {
    ...
    defaultConfig {
        ...
        ndk {
            abiFilters 'arm64-v8a' // Include only the ABIs you need
        }
    }
}

2. Enable app optimization

android {
    buildTypes {
        release {
            // Enables code-related app optimization.
            isMinifyEnabled = true

            // Enables resource shrinking.
            isShrinkResources = true        
            ...
        }
    }
    ...
}        

3. Enable optimized resource shrinking, add the following to your project's gradle.properties file:

android.r8.optimizedResourceShrinking=true

4. Use SDK Flavours without models. Models are downloaded upon the first initialization of the SDK.

Please note that Download Size in Android Studio's built-in APK Analyzer tool represents the estimated compressed size of the entity as it would be delivered by Google Play

ProGuard / R8 Configuration

If you use ProGuard or R8 for code obfuscation and shrinking, add the following rules to your proguard-rules.pro file to ensure the SDK functions correctly:

# Prevent package name conflicts
-repackageclasses 'com.idmission.sdk2.internal.obfuscated'
-allowaccessmodification
-flattenpackagehierarchy 'com.idmission.sdk2.internal.obfuscated'

# Core SDK classes
-keep class com.idmission.sdk2.identityproofing.IdentityProofingSDK { *; }
-keep class com.idmission.sdk2.client.cache.SDKCache { *; }
-keep class com.idmission.sdk2.client.model.** { *; }
-keep class com.idmission.sdk2.capture.presentation.camera.helpers.ProcessedCapture { *; }
-keep class * extends com.idmission.sdk2.capture.presentation.camera.helpers.ProcessedCapture { *; }

# Kotlin Serialization
-keepclassmembers class kotlinx.serialization.json.** {
    *** Companion;
}
-keepclasseswithmembers class kotlinx.serialization.json.** {
    kotlinx.serialization.KSerializer serializer(...);
}

# ML Kit & TensorFlow Lite
-keep class com.google.mlkit.** { *; }
-keep class org.tensorflow.** { *; }
-dontwarn org.tensorflow.**

# Retrofit & OkHttp
-keepattributes *Annotation*, InnerClasses, EnclosingMethod, Signature, Kotlin.Metadata
-keepclasseswithmembers interface * {
    @retrofit2.http.* <methods>;
}

# Preserve Enums
-keep public enum com.idmission.sdk2.** { *; }

SDK Version History

v11.1.19.2.10 (22nd October 2026)

• Dynamic ID Capture & Barcode Handling: Enabled flexible two-sided ID capture that automatically detects the front and back of an ID in any order, while seamlessly processing barcode data on either side.

• Dynamic ID Orientation & Auto-Correction: Introduced a .dynamic capture mode that automatically adapts capture guidelines for horizontal or vertical IDs in real time and automatically rotates the final captured image to an upright orientation.

• NFC Support: Added optional NFC chip reading capabilities for supported IDs and passports through the dedicated IDentityMediumNFC framework, allowing integrators to include or exclude NFC functionality based on application requirements.

• NFC Data Extraction & Modular Framework: Added support for extracting NFC chip data and artifacts, including face images, document images, and digital signatures, through the modular NFC framework.

• Server Payload & Swagger v4 Support: Updated API data models to Swagger v4 specifications to support transmitting extracted NFC chip artifacts, including face images, document images, and digital signatures, directly to the backend server.

• Android SDK Size Reduction: Optimized the SDK footprint by replacing PNG assets with WebP, stripping unused native code, removing unused resources, and unifying serialization libraries with kotlinx.serialization.

• MRZ Extraction Improvements: Enhanced Machine Readable Zone (MRZ) capture reliability and performance.

• Stability & Crash Handling: Improved internal crash handling to prevent unexpected application termination during scanning sessions.

• Bug Fix – Event Log URL: Fixed an issue where switching environments did not update the Event_log endpoint URL correctly.

• OpenSSL Library Upgrade: Updated the bundled OpenSSL library to the latest supported version for improved security and stability.

v11.1.13.2.18 (23rd July 2026)

• Added a maximum retry limit for ID and selfie capture.

• Added a conditional ID success preview screen.

• Added a conditional selfie success preview screen.

• Added a barcode cropping support.

• Added a barcode recovery flow.

• Added on-device AAMVA parsing.

• Added support for mandatory geolocation enforcement.

• Added support for vertical ID capture orientation.

• Implemented image sequence animations for the Vertical ID capture instruction screen.

• Implemented image sequence animations for the ID capture instruction screen.

• Removed glasses detection from the Android Liveness module.

• Fixed an issue where the larger selfie image size on Pixel 8 devices caused increased upload time.

• Updated Android SDK 2.0 to prevent uploading screen and photocopy images to GTE when the Real ID Check is disabled.

• Updated the SDK initialization endpoint.

v11.1.07.2.23 (28th April 2026)

• Added customizable properties

• Updated DocumentDetect model with ID back-side prediction

• Reduced overall SDK package size

• Introduced a timeout timer for capture to improve user flow and prevent indefinite waiting.

• Implemented prompt and error messages on the ID Capture screen and Selfie screen aligned with iOS behavior.

• Added support for separate front and back ID capture flow for improved control and user experience.

v11.1.01.2.04 (15th January 2026)

• Server-Side Autofill Implementation

• UI Enhancements to support additional options for customizations.

v10.1.24.2.04 (08th December 2025)

• Added event logging capability within the SDK

• Security Enhancements

• Updated the SDK to ensure Error Code 31 is no longer shown to end users

• Removal of NFC passport scanning functionality from Full SDK version

• Removal of ImageLabeling module in Medium SDK

• Enabled more efficient multi-document workflows in custom product

v10.1.18.2.01 (11th November 2025)

• Updated the default maximum allowed fake face capture count from 15 to 10.

v10.1.16.2.11 (25th August 2025)

• Updated new encryption and decryption logic.

• Ability to submit request on custom product.

• Updated Google Play Store policy requirements (Android 35).

• Updated native .so with 16KB page size as per Google Play Store policy.

• UI improvement related to the Continue button.

v10.1.12.2.10 (24th June 2025)

• Added support for custom product request.

v10.1.4.2.03 (26th February 2025)

• Reduced the overall size of SDK.

• Added configuration options to change the sequence of ID and Selfie capture.

• Added support for the face mask detection model in the Medium version of the Android SDK.

• Updated libraries to comply with Google Play Policy changes for READ_MEDIA_IMAGES and READ_MEDIA_VIDEO.

• Added support to customize overlay and instruction images.

• Non-English data fields are included in the response.

• Updated all default AI models to the latest versions.

v9.6.24.2.15 (03rd December 2024)

• Improved capture quality with model updates that notify users of obstructions over key ID information.

v9.6.22.2.13 (18th November 2024)

• Integrated the latest swagger V4 API version. This includes updates to model download based on V4, updates to the new initialization process, as well as ensuring backward compatibility.

• Added the selfie image in the response.

• Added support for an initialization parameter that will enable / disable Location / GPS capture.

• Improved ID capture guidance messages to inform the user to hold still once the document is detected to ensure a higher quality capture.

• Added configuration support to allow selfie capture with the back camera.

• Added support for additional date and timestamp capture as Exif for ID capture and Selfie capture image.

• QR code for the test applications supports the new initialization process.

• Update to support multiple security enhancements including the removal of outdated/unused libraries.

• Enhanced API 34 Support in Android

• Bug fixes and performance improvements.

• Updated all default AI models to the latest versions.

v9.6.4.2.07 (February 2024)

• Reduce response callback time for SDK Initialization Method.

• Use the doc-detect model to determine document is ID or Passport.

• Updated all default AI models to the latest versions.

v9.6.3.2.04 (January 2024)

• Updated SDK support for additional flags (sendProcessedImagesInResponse and sendInputImagesInResponse)

• Added ID extracted profession and profession non English data in response

• Updated all default AI models to the latest versions.

v9.5.18.2.03 (December 2023)

• Changed default app_name key to sdk_app_name.

• Updated all default AI models to the latest versions.

v9.5.15.2.09 (November 2023)

• Enhanced Android SDK to support a new feature for voice capture.

• Enhanced Android SDK to support a new face focus model for improved quality at the time of capture.

• Updated the Android SDK to ensure the user is not prompted for file storage permission for ID capture as no images are stored on the device.

• Updated the Android SDK with new Spanish translations for server response status messages.

• Updated the base URLs used in Android SDK for initialization to ensure they are consistent.

• Updated fingerprint feature libraries to be consistent with SDK 1.0

• Updated all default AI models to the latest versions.

v9.5.9.2.05

• UI Changes and bug Fixes for Passport NFC detection

• Removed Firebase Analytics

• Bug fixes and performance improvements.

v9.5.7.2.08

• Integrate ID Chip reading ability for passport

• Improvement for real ID detection and bug fixes.

v9.5.4.2.02

• Fixed GTE Data upload issue for ID capture

v9.5.3.2.04

• Updated all local models

v9.5.2.2.06

• Updated focus model to be downloaded from server and updated

• default focus threshold.

• Updated UI elements to allow for customization by integrator - all UI elements are now customizable.

• Instruction Screen button text and colors

• Instruction text and colors

• Enhancements added to improve handling of Video ID

v9.4.8.2.15

• New IdentityVideoID SDK for capturing a selfie and ID to match against a previous ID validation call, and then recording a video instructing the user to speak a customizable phrase.

• Added SignatureCapture support

• Added FingerPrintCapture support

v9.3.10.2.9

• Prevent two faces from being captured during selfie capture.

• Model Decryption using latest algorithm(AES/GCM/NoPadding).

• Handle the CAN BC DL barcode XSLT

• Added Spanish language support

• Now fitting instead of filling the camera preview to better support the 600px height requirement.

• Added additional customer response data parameters; state and postalCode.

• Updated instruction screen for IDCapture & SelfieCapture

• Bug fixes and performance improvements.

v9.3.4.2.8

• Additional document upload and capture feature.

• Added customization of overlay images while capturing ID and selfie.

• Added focus model for better image capture.

• Bug fixes and performance improvements.

v9.3.1.7

• Autofill.

• Added SDK UI Customization.

• Instruction screens for selfie and ID capture.

• Bug fixes and performance improvements.

v9.2.3.4

• Bug fixes and performance improvements

v9.1.7.20

• Enrollment

• Enrollment with Biometrics

• Customer Verification

• ID Validation and face match