Android Beginners Guide 

Intro sentence 

This guide is for developers and integrators who want to integrate the DC SDK into an Android application.

Overview 

DC SDK is a modular identity platform for Android apps. It provides the building blocks to:

• onboard users through identity enrollment,
• issue and manage credentials in an on-device wallet,
• handle online authentication and request-driven flows,
• share identity attributes in person (ISO 18013 scenarios),
• maintain credential trust over time with update and lifecycle operations.

1. Get Started 

Prerequisites 

Before integrating the SDK, make sure your development environment meets the following requirements.

Supported CPU architectures (required by the Capture SDK):

• armeabi-v7a (32-bit ARM devices)
• arm64-v8a (64-bit ARM devices)

NOTE: The SDK does not support x86/x64 architecture. Android Emulators on Intel-based machines are not supported. A physical Android device is required. Emulators running on Apple Silicon (M-series Macs) works due to ARM64 compatibility.

Skills Required 

You must have working knowledge of:

• Android Studio
• Kotlin
• Android SDK
• Maven/Gradle dependency management
• Kotlin Coroutines

Resources Required 

Android integration may be performed on macOS, Linux, or Windows with the following tools:

• Android Studio
• JDK: preferred the latest version (17 or above) — Android Studio includes a bundled JDK
• Android SDK tools: preferred the latest version (API level 29 or above)
• Minimum Android SDK version: 29 (Android 10.0)
• Physical Android device (emulator is not supported)

Access to Artifactory 

SDK artefacts are published to a dedicated Maven repository. You will need:

• Access credentials (artifactoryUser / artifactoryPassword) — provided together with the licenses and SDK configuration file
• Access to the sample app: mobileid-sdk-sample-app-XX.XX.XX.zip — available from Artifactory

2. Project Configuration 

Before configuring your project manually, it is recommended to download the sample app from Artifactory and import it into Android Studio. The sample app contains the most up-to-date working configuration as a reference.

Credentials DC repositories 

Define in your ~/.gradle/gradle.properties following properties credentials to required repositories

Properties
1mobileIdArtifactoryUser=
2mobileIdArtifactoryPassword=
3artifactoryUserMI=
4artifactoryPasswordMI=

Repositories required to build DC SDK and Sample App are defined in gradle.properites.

Properties
1idemiaRepositoryUrl=
2remoteRepositoryUrl=
3mobileIdSdkRepositoryUrl=

NOTE: The username and password are provided together with the licenses and SDK configuration file.

Dependencies 

Add the required SDK dependencies in your application build.gradle file. Repository URLs and exact version numbers are available in the sample app (mobileid-sdk-sample-app/app/build.gradle).

Groovy
1dependencies {
2   // sdk api library
3   implementation "com.idemia.mid.sdk:sdk-api:${Versions.mobileIdSdkVersion}"
4   implementation "com.idemia.mid.sdk:unlock:${Versions.mobileIdSdkVersion}"
5   implementation "com.idemia.mid.sdk:remote-face-liveness-plugin:${Versions.idemiaMobileIdSdkVersion}"
6   implementation "com.idemia.mid.sdk:document-capture-plugin:${Versions.idemiaMobileIdSdkVersion}"
7
8   // Kotlin Coroutines
9   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:${Versions.coroutines}"
10   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:${Versions.coroutines}"
11}

NOTE: The SDK does not support app data backup after uninstall. If you generate a new project from Android Studio, it adds android:allowBackup="true" to the application tag by default. You must either remove this attribute or explicitly set it to false.

App Name 

The SDK requires the integrator to provide the application name via the R.string.app_name string resource:

XML
1<string name="app_name">Your App Name</string>

This value is used by the SDK in the following ways:

1. As part of the User-Agent header sent to backend services:

   Language not specified
   1User-Agent: Your App Name/XX.XX.XX SDK/XX.XX.XX Android

2. To customize messages shown to the end user, for example on error screens.

3. SDK Integration 

Initialization 

Before using the SDK, it must be initialized with a configuration. The configuration is delivered as part of the SDK package as a Kotlin data class (not a JSON file) for security reasons, as it contains confidential data such as API and license keys.

Kotlin
1fun create() {
2      val configuration = MobileIDConfiguration(...)
3      val tracker = TrackerImplementation(...)
4
5      val mobileIdProvider: MobileIDProvider = MobileID.initialize(
6         initialize(
7            application = application,
8            configuration = configuration,
9            analyticsTracker = tracker,   // optional: provide a Tracker implementation to receive analytics events
10            analyticsOptOut = false        // optional: set to true to disable analytics tracking
11         )
12      )
13      
14      launch {
15         val mobileId = mobileIdProvider.create()
16      }
17}

Parameters:

NOTE: Code examples are available in mid-sdk-sample-app — see SplashScreenActivity.

Retrieving Current SDK Status 

To retrieve the current SDK status and trigger any pending events:

Kotlin
1mobileId.update()

This method triggers registered events if any updates are available.

Additional Integration Points 

Handling Deep Links

To support phone binding and enrollment resumption via deep links, pass the incoming intent data to the EnrollmentController:

Kotlin
1val enrollmentController = EnrollmentController(this@SplashScreenActivity)
2
3when {
4    intent.dataString != null -> enrollmentController.resumeWith(otpDeeplink = URL(intent.dataString))
5    enrollmentController.canResume() -> enrollmentController.resume()
6    else -> navigator.navigate<MainActivity>(clearStack = true)
7}

NOTE: Code examples are available in mid-sdk-sample-app — see SplashScreenActivity.

4. Customization 

Color Configuration 

By default, the SDK uses predefined colors for its UI. You can override these by providing your own values in the SDK configuration.

The SDK UI uses two primary thematic colors:

• Primary: used for single, main elements (e.g., navigation bar background, photo borders)
• Secondary: used for elements that appear multiple times on screen (e.g., buttons, links)

Colors prefixed with grayscale are used for text, borders/dividers, and inactive elements. Colors prefixed with accent indicate success, error, and warning states.

The default SDK color palette is defined in app/src/main/res/values/colors.xml in the sample app:

XML
1<resources>
2    <color name="primary_dark">#230057</color>
3    <color name="primary_medium">#30006D</color>
4
5    <color name="secondary_dark">#00004A</color>
6    <color name="secondary_medium">#2F0077</color>
7    <color name="secondary_light">#6231A7</color>
8
9    <color name="gray_dark">#101010</color>
10    <color name="gray_medium_dark">#4A4A4A</color>
11    <color name="gray_medium">#9b9b9b</color>
12    <color name="gray_light">#b3babe</color>
13
14    <color name="accent_success">#429400</color>
15    <color name="accent_error">#D0021B</color>
16
17    <color name="background">#ffffff</color>
18    <color name="white">#ffffff</color>
19    <color name="black_40">#66000000</color>
20    <color name="black_60">#99000000</color>
21
22    <!-- Main app colors -->
23    <color name="colorPrimary">@color/primary_medium</color>
24    <color name="colorPrimaryDark">@color/primary_dark</color>
25    <color name="colorAccent">@color/secondary_dark</color>
26</resources>

NOTE: See the sample app at mid-sdk-sample-app/app/src/main/res/values/colors.xml for reference.

AppInfo Configuration 

AppInfo is used when the SDK needs to provide app-specific information to the end user, for example when an error occurs and the user needs support.

The appInfo section in MobileIDConfiguration contains two subsections:

• Contact: phone number and email address for support
• URLs: links for the More menu options

JSON
1"appInfo": {
2    "contact": {
3        "email": "support@yourapp.com",
4        "phone": "+1 800 000 0000"
5    },
6    "url": {
7        "about": "https://yourapp.com/about/",
8        "faq": "https://yourapp.com/faq/",
9        "help": "https://yourapp.com/help/",
10        "privacyPolicy": "https://yourapp.com/privacy/",
11        "termsAndConditions": "https://yourapp.com/terms/"
12    }
13}

Strings / Localization 

The SDK displays UI screens for features such as enrollment, PIN management, and request authorization. All strings in these screens can be customized, for example to add support for additional languages.

NOTE: The SDK ships with English only. Adding other languages is the integrator's responsibility.

String resources to be translated are available in the sample app inside the strings folder as mid_sdk_strings.xml.