---
title: Capture Android
description: Exécutez la capture d'un flux Journey dans une application Android avec les Custom Tabs, en utilisant le lien renvoyé par la création Human Plugin.
canonical: https://developer.unico.io/fr/human-plugin/integrations/android
locale: fr
generated_by: markdown-export
---

# Capture Android

Ouvrez la capture dans un Custom Tab et ramenez la personne dans votre application.

Votre back-end crée le processus dans Human Plugin avec un flux Journey et un `callbackUri` qui utilise le schéma d'URL de votre application. L'application ouvre le `link` de la réponse dans un [Custom Tab](https://developer.chrome.com/docs/android/custom-tabs). Lorsque la capture se termine, le navigateur ouvre votre schéma et l'application reprend la main.

Conservez le `id` Human Plugin de la réponse de création. Votre back-end lit le résultat avec cet identifiant.

## Prérequis

- Android 8 (API 26) ou version ultérieure
- `androidx.browser:browser:1.5.0`
- Un schéma d'URL propre à votre application, tel que `myapp`

## 1. Ajouter la dépendance

Dans `build.gradle` :

```groovy
implementation("androidx.browser:browser:1.5.0")
```

## 2. Créer le processus avec votre schéma

Votre back-end envoie le schéma comme `callbackUri` :

```json
{
  "flow": "humantoken",
  "clientId": "client-a",
  "correlationId": "order-1001",
  "credential": { "type": "DUI_TYPE_NG_BVN", "value": "<document number>" },
  "callbackUri": "myapp://callback"
}
```

puis renvoie `id` et `link` à l'application.

## 3. Créer l'activité

```kotlin
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.browser.customtabs.CustomTabsIntent

class CaptureActivity : AppCompatActivity() {

    private var processId: String? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        processId = intent.getStringExtra(EXTRA_PROCESS_ID)
        val link = intent.getStringExtra(EXTRA_LINK) ?: return finish()

        CustomTabsIntent.Builder()
            .build()
            .launchUrl(this, Uri.parse(link))
    }

    override fun onNewIntent(intent: Intent) {
        super.onNewIntent(intent)
        if (intent.data?.scheme == "myapp") {
            // La capture est terminée. Demandez à votre back-end de lire le résultat
            // avec GET /v1/processes/{id}, en utilisant l'identifiant Human Plugin.
            onCaptureEnded(processId)
        }
    }

    private fun onCaptureEnded(processId: String?) {
        finish()
    }

    companion object {
        const val EXTRA_PROCESS_ID = "process_id"
        const val EXTRA_LINK = "link"
    }
}
```

## 4. Déclarer le schéma dans `AndroidManifest.xml`

```xml
<uses-feature android:name="android.hardware.camera" android:required="false" />
<uses-permission android:name="android.permission.CAMERA" />

<activity
    android:name=".CaptureActivity"
    android:launchMode="singleTop"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="myapp" android:host="callback" />
    </intent-filter>
</activity>
```

`singleTop` fait en sorte qu'Android remette le retour à `onNewIntent()` de la même activité.

## 5. Démarrer la capture

```kotlin
val intent = Intent(this, CaptureActivity::class.java)
    .putExtra(CaptureActivity.EXTRA_PROCESS_ID, id)
    .putExtra(CaptureActivity.EXTRA_LINK, link)
startActivity(intent)
```

## Récapitulatif

| Fichier | Rôle |
|---|---|
| `build.gradle` | Dépendance `androidx.browser` |
| `CaptureActivity.kt` | Ouvre le Custom Tab et gère le retour |
| `AndroidManifest.xml` | Intent filter pour votre schéma |

```mermaid
sequenceDiagram
  participant A as Your app
  participant B as Your back-end
  participant H as Human Plugin
  participant T as Custom Tab
  A->>B: start the capture
  B->>H: POST /v1/processes (Journey flow, callbackUri myapp://callback)
  H-->>B: 201, id + link
  B-->>A: id + link
  A->>T: open link
  Note over T: capture
  T-->>A: myapp://callback
  A->>B: capture ended (id)
  B->>H: GET /v1/processes/{id}
  H-->>B: 200, final state
```

## Utiliser une WebView

> **Avertissement:** Privilégiez les Custom Tabs. N'utilisez une WebView que si les Custom Tabs ne sont pas envisageables.

La capture nécessite JavaScript, le DOM storage, la lecture automatique des médias et les autorisations de caméra et de localisation :

```kotlin
webView.settings.javaScriptEnabled = true
webView.settings.domStorageEnabled = true
webView.settings.mediaPlaybackRequiresUserGesture = false
webView.settings.setGeolocationEnabled(true)

webView.webChromeClient = object : WebChromeClient() {
    override fun onPermissionRequest(request: PermissionRequest) {
        if (PermissionRequest.RESOURCE_VIDEO_CAPTURE in request.resources) {
            request.grant(arrayOf(PermissionRequest.RESOURCE_VIDEO_CAPTURE))
        } else {
            request.deny()
        }
    }

    override fun onGeolocationPermissionsShowPrompt(
        origin: String,
        callback: GeolocationPermissions.Callback
    ) {
        callback.invoke(origin, true, false)
    }
}
```

Déclarez les autorisations dans `AndroidManifest.xml` et demandez la caméra et la localisation à l'exécution avant de charger le `link` :

```xml
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
```

Dans une WebView, ouvrez directement le `link`. Ne chargez pas le SDK Journeys à l'intérieur.