Installation

Using Zip files

1. Create a new Android project (or use an existing one).

2. Import all provided .aar libraries into the app/libs directory:

   The following libraries must be included:

   genuine-ds-X.Y.Z.aar
   platform-common-definitions-X.Y.Z.aar
   platform-common-image-manipulation-X.Y.Z.aar
   platform-common-utils-X.Y.Z.aar
   platform-nativeds-X.Y.Z.aar
   sdk-camera-X.Y.Z.aar
   sdk-core-X.Y.Z.aar
   sdk-document-X.Y.Z.aar
   

3. Add the SDK libraries to the app build.gradle dependencies:

   implementation(files("libs/genuine-ds-X.Y.Z.aar"))
   implementation(files("libs/platform-common-definitions-X.Y.Z.aar"))
   implementation(files("libs/platform-common-image-manipulation-X.Y.Z.aar"))
   implementation(files("libs/platform-common-utils-X.Y.Z.aar"))
   implementation(files("libs/platform-nativeds-X.Y.Z.aar"))
   implementation(files("libs/sdk-camera-X.Y.Z.aar"))
   implementation(files("libs/sdk-core-X.Y.Z.aar"))
   implementation(files("libs/sdk-document-X.Y.Z.aar"))
   

4. Add the required Jetpack Compose dependencies.

   The SDK UI is built using Jetpack Compose. Since local .aar integrations do not automatically expose all transitive dependency metadata, the host application must explicitly include the required Compose dependencies:

   implementation(platform("androidx.compose:compose-bom:<version>"))
   implementation("androidx.compose.material3:material3")
   implementation("androidx.activity:activity-compose:<version>")
   implementation("androidx.lifecycle:lifecycle-runtime-compose:<version>")
   implementation("androidx.lifecycle:lifecycle-viewmodel-compose:<version>")
   

5. Add the required external dependencies:

   implementation("com.google.ai.edge.litert:litert:<version>")
   implementation("io.coil-kt:coil-compose:<version>")
   implementation("io.coil-kt:coil-gif:<version>")
   implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:<version>")
   implementation("org.jetbrains.kotlin:kotlin-reflect:<version>")
   

6. Use tested dependency versions

   Dependency	Compatible version
   Compose BOM	2025.06.00
   Activity Compose	1.10.1
   Lifecycle	2.8.7
   LiteRT	1.4.1
   Coil Compose	2.6.0
   Kotlinx Serialization JSON	1.6.3
   Kotlin Reflect	1.9.25

   Newer versions may work, but compatibility should be validated by the integrator. This is especially important for Jetpack Compose dependencies, where incompatible module versions may lead to runtime errors such as NoSuchMethodError or NoClassDefFoundError.

7. Sync the project with Gradle and build the application.

   android:largeHeap="true" is strongly recommended in the application manifest to improve memory availability during image processing flows.

Prepare the configuration

• Provide a DocumentCaptureConfiguration instance (you can build it in code or load it from a JSON).
• Ensure camera permission is defined in AndroidManifest.xml.

Minimal code usage

Import the SDK, create the configuration (programmatically or from JSON), and start the flow:

import androidx.activity.ComponentActivity
import com.veridas.sdk.document.entrypoint.DocumentCapture
import com.veridas.sdk.document.entrypoint.DocumentCaptureEventsListener
import com.veridas.sdk.document.entrypoint.DocumentCaptureListener
import com.veridas.sdk.document.error.DocumentCaptureError
import com.veridas.sdk.document.event.DocumentCaptureEvent
import com.veridas.sdk.document.result.DocumentCaptureResult

class DocumentIntegratorActivity : 
    ComponentActivity(), 
    DocumentCaptureListener, 
    DocumentCaptureEventsListener {
    private companion object {
        private val TAG = DocumentIntegratorActivity::class.simpleName
    }

    fun startCapture() {
        DocumentCapture.start(
            listener = this,
            configuration = getConfigurationFromAsset(fileName),
            context = this
        )
        DocumentCapture.setEventsListener(this)
    }

    // DocumentCaptureListener
    override fun onDocumentCaptureStarted() {
        Log.i(TAG, "Document SDK -- Started")
    }

    override fun onDocumentCaptureResults(results: DocumentCaptureResult) {
        Log.i(TAG, "Document SDK -- Capture Results: $results")
    }

    override fun onDocumentCaptureFinished(error: DocumentCaptureError) {
        Log.i(TAG, "Document SDK -- Finished with error $error")
    }

    // DocumentCaptureEventsListener
    override fun onDocumentCaptureEvent(event: DocumentCaptureEvent) {
        Log.i(TAG, "$TAG - Document SDK -- Event: $event")
    }
}

Example helper for loading JSON configs (shared by all SDKs):

import kotlinx.serialization.ExperimentalSerializationApi
import kotlinx.serialization.json.Json

@OptIn(ExperimentalSerializationApi::class)
private val json = Json {
    ignoreUnknownKeys = true
    explicitNulls = false
}
fun getConfigurationFromAsset(fileName: String): DocumentCaptureConfiguration {
    val jsonString = applicationContext
        .assets
        .open(fileName)
        .bufferedReader()
        .use { it.readText() }

    return json.decodeFromString<DocumentCaptureConfiguration>(jsonString)
}

DocumentCaptureListener covers onDocumentCaptureResults, onDocumentCaptureStarted, and onDocumentCaptureFinished, while DocumentCaptureEventsListener can be implemented optionally to receive tracking events through onDocumentCaptureEvent. Details are in the API section.