For the complete documentation index, see llms.txt. You can also append .md to any page URL to get its markdown version.
Skip to main content
For the complete documentation index, see llms.txt.

For the complete documentation index, see llms.txt

Android

This section describes how to set up the Verify Android SDK for Android use.

System requirements​

The SDK uses the following versions;

  • Minimum SDK: 26.

    Your application's minSdk must be 26 or higher.

  • Compile SDK: 36.

    If you use AGP 9+, you must match or exceed this value.

  • Kotlin version: 2.2.21.

    Due to Kotlin's compatibility rules, your application must use Kotlin 2.1.0 or higher.

1. Set up repositories​

The SDK itself is hosted in an authenticated Maven repository. In your settings.gradle.kts (or project-level build.gradle), add the required repository:

dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
google()
mavenCentral()

//Ensure the following is in ~/.aws/credentials
//
//[default]
//aws_access_key_id=CHANGEME
//aws_secret_access_key=CHANGEME

maven {
url = uri("s3://maven-readid-7npn738r9muhb5r6mm97b7pxcck84euw1a-s3alias")
authentication { register("awsIm", AwsImAuthentication::class) }
}
maven {
url = uri("https://europe-west4-maven.pkg.dev/technology-prod-vid-midgard/maven-repo-sdks/")
}
}
}
Dependency access issues

If you are experiencing problems pulling the dependencies, please contact contact us by creating a support ticket in the Signicat Dashboard.

2. Add dependencies and packaging rules​

dependencies {
implementation("com.signicat.idproofing:idproofing:<VERSION>")
}

Packaging configuration​

android {
// Required to resolve transitive conflicts from the ReadID dependency
packaging.resources.excludes.add("META-INF/LICENSE.md")
}

3. Launching the SDK​

In your appropriate context, register an ActivityResultLauncher using IdProofing.Verify();

import com.signicat.idproofing.IdProofing

// Activity or fragment
class MyActivity : AppCompatActivity() {
private val idProofingLauncher = registerForActivityResult(IdProofing.Verify()) { result ->
//handle result
}

private fun handleNavAction() {
idProofingLauncher.launch(input)
}
}

// Compose
@Composable
fun MyComposable() {
val idProofingLauncher = rememberLauncherForActivityResult(IdProofing.Verify()) {
//handle result
}

// Launch safely via a side-effect to avoid recomposition loops
LaunchedEffect(uiState.verifyIdentity) {
if (uiState.verifyIdentity) {
idProofingLauncher.launch(input)
}
}
}

Start a session​

To start the UI, you need a sessionId and an sdkToken.

Warning

Ensure you obtain the sessionId and sdkToken securely through your backend system.

val input = IdProofing.Input(
sessionId = "YOUR_SESSION_ID",
sdkToken = "YOUR_SDK_TOKEN",
configuration = IdProofing.Input.Configuration(
// Optional: Overrides the UI language.
language = "en"
)
)

// Start the flow
idProofingLauncher.launch(input)

4. Understanding output signals​

The IdProofing.Result strictly communicates the terminal state of the SDK flow on the device. The Verify SDK tries its best to categorise and attribute failures to the appropriate culprit.

Important

The SDK itself never returns the verified identity data, documents, or an authoritative "Approved/Rejected" status.

  • Finished: The user completed the necessary SDK steps (e.g., captured an ID and face). It does not mean the identity was successfully verified. You must retrieve the final verdict securely from the Signicat API, likely through your own backend.
  • Failure.Canceled: The user intentionally or otherwise manually cancelled the SDK process.
  • Failure.Provider: Terminal error within a providers SDK process. Will attempt to propagate provider error code.
  • Failure.Orchestration: A crash or unrecoverable error occurred within the IdProofing SDK process.
  • Failure.AlreadyInProgress: A duplicate Verify flow was attempted while a previous was still active.

5. Advanced error monitoring (optional)​

If you need deeper insights or want to pipe diagnostics to your crash reporting tool (e.g., Crashlytics, Sentry), you can attach a global ErrorListener.

import com.signicat.idproofing.IdProofing
import com.signicat.idproofing.IdProofingException
import com.signicat.idproofing.setErrorListener
import com.signicat.idproofing.clearErrorListener

// Register this once in an appropriate location, likely during application create
IdProofing.setErrorListener { exception ->
when (exception) {
is IdProofingException.ProviderException -> {
// Logs a vendor-specific issue
println("Provider failure: ${exception.providerType} / Code: ${exception.errorCode}")
println("Diagnostic: ${exception.diagnosticMessage}")
}
is IdProofingException.OrchestrationException -> {
// Logs an internal SDK issue
println("Orchestration failure: ${exception.message}")
}
}
}
Memory management

This listener is held statically. Avoid capturing inappropriate references (e.g. a local Context) inside the lambda to prevent memory leaks.