---
title: Capture iOS
description: Exécutez la capture d'un flux Journey dans une application iOS avec ASWebAuthenticationSession, à partir du lien renvoyé par la création Human Plugin.
canonical: https://developer.unico.io/fr/human-plugin/integrations/ios
locale: fr
generated_by: markdown-export
---

# Capture iOS

Ouvrez la capture dans une session de navigateur système 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 scheme d'URL de votre application. L'application ouvre le `link` de la réponse dans une `ASWebAuthenticationSession`. Lorsque la capture se termine, la session revient dans l'application via votre scheme.

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

## Prérequis

- iOS 13 ou version ultérieure
- Xcode 14 ou version ultérieure
- Le framework `AuthenticationServices` (intégré)
- Un scheme d'URL propre à votre application, tel que `myapp`

## 1. Créer le processus avec votre scheme

Votre back-end envoie le scheme comme `callbackUri` :

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

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

## 2. Créer le fournisseur de contexte de présentation

```swift
import AuthenticationServices
import UIKit

class CaptureContextProvider: NSObject, ASWebAuthenticationPresentationContextProviding {
    func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
        guard let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
              let window = windowScene.windows.first else {
            return ASPresentationAnchor()
        }
        return window
    }
}
```

## 3. Créer le gestionnaire de session

```swift
import AuthenticationServices

class CaptureSessionManager {
    static let shared = CaptureSessionManager()
    private var session: ASWebAuthenticationSession?
    private let contextProvider = CaptureContextProvider()

    /// Appelle completion avec true lorsque la capture est terminée, false lorsque la personne l'a fermée.
    func start(link: URL, completion: @escaping (Bool) -> Void) {
        let newSession = ASWebAuthenticationSession(
            url: link,
            callbackURLScheme: "myapp"
        ) { callbackURL, _ in
            self.session = nil
            completion(callbackURL != nil)
        }
        newSession.presentationContextProvider = contextProvider
        newSession.prefersEphemeralWebBrowserSession = true
        newSession.start()
        session = newSession
    }
}
```

> **Info:** `callbackURLScheme` n'accepte que le nom du scheme (`myapp`), sans `://`.

## 4. Démarrer la capture

```swift
guard let url = URL(string: link) else { return }

CaptureSessionManager.shared.start(link: url) { ended in
    if ended {
        // La capture est terminée. Demandez à votre back-end de lire le résultat
        // avec GET /v1/processes/{id}, en utilisant l'id Human Plugin.
    } else {
        // La personne a fermé la session.
    }
}
```

## Récapitulatif

| Fichier | Rôle |
|---|---|
| `CaptureContextProvider.swift` | Fournisseur de contexte de présentation |
| `CaptureSessionManager.swift` | Cycle de vie de `ASWebAuthenticationSession` |

```mermaid
sequenceDiagram
  participant A as Your app
  participant B as Your back-end
  participant H as Human Plugin
  participant S as Browser session
  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->>S: open link
  Note over S: capture
  S-->>A: myapp://callback
  A->>B: capture ended (id)
  B->>H: GET /v1/processes/{id}
  H-->>B: 200, final state
```