---
title: User Journeys
description: Multi-step capture sessions orchestrated by the SDK based on the configured flow, such as selfie, document capture, and signature in a single session.
canonical: https://developer.unico.io/developers/sdks-and-tools/android/capture-flow/user-journeys
locale: en
generated_by: markdown-export
---

- [/](/)
- [SDKs and Tools](/developers/sdks-and-tools/overview)
- [Android SDK](/developers/sdks-and-tools/android/requirements)
- Capture flow
- User Journeys

# User Journeys

User Journeys are multi-step capture sessions orchestrated by the SDK in conjunction with the configured flow. For example, a flow with Liveness + Risk Score + Document Capture + Electronic Signature executes selfie, document capture, and signature in a single session.

ProductsThe available journeys depend on the flow configured for your integration. Refer to [Products](/products) for the full mapping of product → flow → capability.

How it works
The SDK:

1. Reads the flow configuration provided during initialization.
2. Orchestrates the sequence of captures required for the flow (selfie, document, signature).
3. Returns a `processId` via `onSuccess` when the journey completes. For the selfie step, image data (`base64` / `encrypted`) is also returned via `onSuccessSelfie`. Document and signature captures are processed internally by the SDK — no per-step artifact is exposed to the client.

The orchestration is handled entirely by the SDK — you do not need to implement the step sequence in your app.

Starting a User Journey
**Step 1** — Implement `AcessoBioListener``AcessoBioListener` handles the SDK lifecycle callbacks. Implement the four mandatory methods:

| Method | When it's called |
| --- | --- |
| `onErrorAcessoBio(errorBio)` | An error occurred during SDK operation |
| `onUserClosedCameraManually()` | The user manually closed the camera |
| `onSystemClosedCameraTimeoutSession()` | The session time limit was reached — see [Session limits](/developers/sdks-and-tools/android/requirements#session-limits) |
| `onSystemChangedTypeCameraTimeoutFaceInference()` | The face inference time limit was reached — switches to manual capture — see [Session limits](/developers/sdks-and-tools/android/requirements#session-limits) |

- Kotlin
- Java

```
val callback = object : AcessoBioListener {**  override fun onErrorAcessoBio(errorBio: ErrorBio?) { }  override fun onUserClosedCameraManually() { }  override fun onSystemClosedCameraTimeoutSession() { }  override fun onSystemChangedTypeCameraTimeoutFaceInference() { }}
```

```
AcessoBioListener callback = new AcessoBioListener() {  @Override  public void onErrorAcessoBio(ErrorBio errorBio) { }  @Override  public void onUserClosedCameraManually() { }  @Override  public void onSystemClosedCameraTimeoutSession() { }  @Override  public void onSystemChangedTypeCameraTimeoutFaceInference() { }};
```

**Step 2** — Implement `iAcessoBioSelfie``iAcessoBioSelfie` handles the journey capture result callbacks:MethodDescription`onSuccessSelfie(result)`Image captured successfully — returns `ResultCamera` for subsequent REST API calls`onSuccess(result)`Journey completed successfully — returns `SuccessResult` with a `processId` used to query validation results`onErrorSelfie(errorBio)`Capture failed — returns an `ErrorBio` with error detailsKotlinJava```
val cameraListener: iAcessoBioSelfie = object : iAcessoBioSelfie {  override fun onSuccessSelfie(result: ResultCamera?) { }  override fun onSuccess(result: SuccessResult) { }  override fun onErrorSelfie(errorBio: ErrorBio?) { }}
```

```
iAcessoBioSelfie cameraListener = new iAcessoBioSelfie() {  @Override  public void onSuccessSelfie(ResultCamera result) { }  @Override  public void onSuccess(SuccessResult result) { }  @Override  public void onErrorSelfie(ErrorBio errorBio) { }};
```

**Step 3** — Call `prepareCamera`With `unicoCheckCamera` initialized and both listeners implemented, call `prepareCamera` passing the SDK config, a `CameraListener`, and your `webAppToken`:webAppTokenThe `webAppToken` is the `process.webAppToken` field returned by [Create Process](/developers/api-reference/post-processes) when creating the process on your backend.
`onCameraReady` — camera is ready; call `open` passing the `cameraListener` and your `webAppToken`.
`onCameraFailed` — camera preparation failed; handle the error message.
KotlinJava```
unicoCheckCamera.prepareCamera(unicoConfig, object : CameraListener {  override fun onCameraReady(cameraOpener: UnicoCheckCameraOpener.Camera?) {    cameraOpener?.open(cameraListener, "your_web_app_token")  }  override fun onCameraFailed(message: String?) {    Log.e(TAG, message)  }})
```

```
unicoCheckCamera.prepareCamera(unicoConfig, new CameraListener() {  @Override  public void onCameraReady(UnicoCheckCameraOpener.Camera cameraOpener) {    cameraOpener.open(cameraListener, "your_web_app_token");  }  @Override  public void onCameraFailed(String message) {    Log.e(TAG, message);  }});
```

For the full result handling, see [Receiving the result](/developers/sdks-and-tools/android/capture-flow/receiving-the-result).Last updated on Oct 8, 2026**