---
title: Parcours utilisateur
canonical: https://developer.unico.io/fr/dual-api/developers/sdks-and-tools/android/capture-flow/capture-types/user-journeys
locale: fr
generated_by: markdown-export
---

Les parcours utilisateur sont des sessions de capture multi-étapes orchestrées par le SDK en conjonction avec le flux configuré. Par exemple, un flux avec Détection de Vie + Score de Risque + Capture de document + Signature électronique exécute le selfie, la capture de document et la signature en une seule session.

:::secondary[Produits]
Les parcours disponibles dépendent du flux configuré pour votre intégration. Consultez les [Produits](/products) pour la correspondance complète produit → flux → capacité.
:::

## Fonctionnement

Le SDK :

1. Lit la configuration du flux fournie lors de l'initialisation.
2. Orchestre la séquence des captures requises pour le flux (selfie, document, signature).
3. Retourne un `processId` via `onSuccess` lorsque le journey se termine. Pour l'étape selfie, les données d'image (`base64` / `encrypted`) sont également retournées via `onSuccessSelfie`. Les captures de documents et de signature sont traitées en interne par le SDK — aucun artefact par étape n'est exposé au client.

L'orchestration est entièrement gérée par le SDK — vous n'avez pas besoin d'implémenter la séquence des étapes dans votre application.

## Démarrer un parcours utilisateur

****Étape 2** — Implémenter `iAcessoBioSelfie`**

`iAcessoBioSelfie` gère les callbacks du résultat de capture du parcours :

  | Méthode | Description |
  |---|---|
  | `onSuccessSelfie(result)` | Image capturée avec succès — retourne `ResultCamera` pour les appels REST API ultérieurs |
  | `onSuccess(result)` | Journey terminé avec succès — retourne `SuccessResult` avec un `processId` utilisé pour interroger les résultats de validation |
  | `onErrorSelfie(errorBio)` | Échec de la capture — retourne un `ErrorBio` avec les détails de l'erreur |

  ### Kotlin

    ```kotlin
    val cameraListener: iAcessoBioSelfie = object : iAcessoBioSelfie {
      override fun onSuccessSelfie(result: ResultCamera?) { }
      override fun onSuccess(result: SuccessResult) { }
      override fun onErrorSelfie(errorBio: ErrorBio?) { }
    }
    ```

### Java

    ```java
    iAcessoBioSelfie cameraListener = new iAcessoBioSelfie() {
      @Override
      public void onSuccessSelfie(ResultCamera result) { }

      @Override
      public void onSuccess(SuccessResult result) { }

      @Override
      public void onErrorSelfie(ErrorBio errorBio) { }
    };
    ```

****Étape 3** — Appeler `prepareCamera`**

Avec `unicoCheckCamera` initialisé et les deux listeners implémentés, appelez `prepareCamera` en passant la configuration du SDK, un `CameraListener` et votre `webAppToken` :

  :::note[webAppToken]
  Le `webAppToken` est le champ `process.webAppToken` retourné par `POST /client/v1/process` lors de la création du processus sur votre backend. Voir [Créer un processus](/dual-api/developers/api-reference/web-sdk/post-process).
  :::

  - `onCameraReady` — la caméra est prête ; appelez `open` en passant le `cameraListener` et votre `webAppToken`.
  - `onCameraFailed` — la préparation de la caméra a échoué ; gérez le message d'erreur.

  ### Kotlin

    ```kotlin
    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)
      }
    })
    ```

### Java

    ```java
    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);
      }
    });
    ```

Pour la gestion complète du résultat, voir [Réception du résultat](/developers/sdks-and-tools/android/capture-flow/receiving-the-result).