Intégration du workflow

Intégrez des workflows KYC dans les applications iOS à l’aide du SDK iOS ComplyCube.

Vue d'ensemble

Ce guide vous guide à travers l’intégration du SDK iOS avec ComplyCube flux de travail.

Flux d'intégration

Le SDK mobile s’exécute dans votre application mobile, mais s’appuie sur votre backend pour créer des jetons sécurisés. Voici comment cela fonctionne :

Créer un client

Enregistrez un nouveau client (c.-à-d. client) à l’aide de l’API ComplyCube.

Générez un jeton SDK

Votre backend demande un jeton JWT lié à ce client.

Initialisez le SDK dans votre application mobile

Passez le jeton et les paramètres à l’initialiseur du SDK.

Capturez des données, des documents, des vidéos et des selfies

Le SDK guide votre client à travers les étapes requises.

Effectuer des vérifications

Les données capturées sont envoyées en toute sécurité à ComplyCube pour les vérifications, et les résultats sont fournis en temps réel via l’API ou les webhooks.

Guide d'intégration

Explorez le code source et les projets d’exemple dans notre dépôt : .

Installer le SDK

Avant d’utiliser le SDK ComplyCube, installez le CocoaPods plugin en exécutant la commande suivante dans votre terminal :
```
sudo gem install cocoapods
```

Ajoutez les dépôts du plugin et installez le pod en utilisant votre Podfile:

source 'https://github.com/CocoaPods/Specs.git'
…
platform :iOS, ’13.0’

target ‘YourApp’ do
    …
  pod 'ComplyCubeMobileSDK'
end

post_install do |installer|
    installer.pods_project.targets.each do |target|
        target.build_configurations.each do |build_configuration|
            build_configuration.build_settings['ENABLE_BITCODE'] = 'NO'
            build_configuration.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'YES'
            build_configuration.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '13.1'
            build_configuration.build_settings['ARCHS'] = ['$(ARCHS_STANDARD)', 'x86_64']
            build_configuration.build_settings['EXCLUDED_ARCHS[sdk=iphonesimulator*]'] = ['arm64', 'arm64e', 'armv7', 'armv7s']
            build_configuration.build_settings['GENERATE_INFOPLIST_FILE'] = 'YES'
        end
    end
end

Autorisations de l’application

Notre SDK utilise la caméra et le microphone de l’appareil pour la capture. Vous devez ajouter les clés suivantes à votre application Info.plist fichier.

NSCameraUsageDescription

<key>NSCameraUsageDescription</key>
<string>Utilisé pour capturer des données biométriques faciales et des documents</string>

NSMicrophoneUsageDescription

<key>NSMicrophoneUsageDescription</key>
<string>Utilisé pour capturer des données biométriques vidéo</string>

Créer un client

Chaque parcours de vérification commence par un client (c.-à-d. le client). Utilisez l’API pour créer le client.

Cela doit être fait sur votre backend de l’application mobile serveur, et non dans l’application mobile elle-même.

Exemple de requête

curl -X POST https://api.complycube.com/v1/clients \
     -H 'Authorization: <YOUR_API_KEY>' \
     -H 'Content-Type: application/json' \
     -d '{
          "type": "person",
          "email": "john.doe@example.com",
          "personDetails":{
               "firstName": "John",
               "lastName" :"Doe"
          }
        }'

const { ComplyCube } = require("@complycube/api");

const complycube = new ComplyCube({ apiKey: "<YOUR_API_KEY>" });

const client = await complycube.client.create({
  type: "person",
  email: "john.doe@example.com",
  personDetails: {
    firstName: "John",
    lastName: "Doe"
  }
});

from complycube import ComplyCubeClient
cc_api = ComplyCubeClient(api_key='<YOUR_API_KEY>')

new_client = {
    'type':'person',
    'email':'john.doe@example.com',
    'personDetails': {
        'firstName':'John',
        'lastName':'Doe'
    }
}

client = cc_api.clients.create(**new_client)

use ComplyCube\ComplyCubeClient;

$ccapi = new ComplyCubeClient('<YOUR_API_KEY>');

$result = $ccapi->clients()->create([
    'type' => 'person',
    'email' => 'john@doe.com',
    'personDetails' => [
        'firstName' => 'John',
        'lastName' => 'Doe'
    ]
]);

using ComplyCube.Net;
using ComplyCube.Net.Resources.Clients;

var clientApi = new ClientApi(new ComplyCubeClient("<YOUR_API_KEY>"));
var newClient = new ClientRequest {
  type = "person",
  email = "john@doe.com",
  personDetails = new PersonDetails {
    firstName = "John",
    lastName = "Doe"
  }
}

var client = await clientApi.CreateAsync(newClient);

Exemple de réponse

La réponse contiendra un id (l’ID du client). Il est requis pour l’étape suivante.

{
    "id": "5eb04fcd0f3e360008035eb1",
    "type": "person",
    "email": "john.doe@example.com",
    "personDetails": {
        "firstName": "John",
        "lastName": "Doe"
    },
    "createdAt": "2020-01-04T17:24:29.146Z",
    "updatedAt": "2020-01-04T17:24:29.146Z"
}

Voir Référence de l’API Clients pour en savoir plus.

Générez un jeton SDK

Votre backend doit créer un jeton SDK pour chaque nouveau flux. Ce jeton permet aux clients d’envoyer des données personnelles en toute sécurité depuis votre application mobile vers ComplyCube.

Les jetons ont une courte durée de vie et ne doivent pas être réutilisés.

Exemple de requête

curl -X POST https://api.complycube.com/v1/tokens \\
     -H 'Authorization: <YOUR_API_KEY>' \\
     -H 'Content-Type: application/json' \\
     -d '{
           "clientId":"CLIENT_ID",
           "appId": "com.complycube.SampleApp"
         }'

const { ComplyCube } = require("@complycube/api");

const complycube = new ComplyCube({ apiKey: "<YOUR_API_KEY>" });

const token = await complycube.token.generate("CLIENT_ID", {
    appId: "com.complycube.SampleApp"
});

from complycube import ComplyCubeClient

cc_api = ComplyCubeClient(api_key='<YOUR_API_KEY>')

token = cc_api.tokens.create('CLIENT_ID', appId='com.complycube.SampleApp')

using ComplyCube.Net;
using ComplyCube.Net.Resources.SDKTokens;

var sdkTokenApi = new SDKTokenApi(new ComplyCubeClient("<YOUR_API_KEY>"));

var sdkTokenRequest = {
  clientId = "CLIENT_ID",
  appId = "com.complycube.SampleApp"
}

var sdkToken = await sdkTokenApi.GenerateToken(sdkTokenRequest);

Exemple de réponse

{
    "token": "<CLIENT_TOKEN>"
}

Voir Référence de l'API du jeton SDK pour en savoir plus.

Initialiser le SDK

Dans le cadre de l'initialisation du SDK, vous devez spécifier un ID du modèle de workflow. Le SDK exécutera automatiquement la active version du workflow sélectionné.

let sdk = ComplyCubeMobileSDK.FlowBuilder()
  .withSDKToken("SDK_TOKEN")
  .withClientId("CLIENT_ID")
  .withWorkflowTemplateId("WORKFLOW_TEMPLATE_ID")
  .start(fromVc: self)

var clientAuth = ClientAuth("SDK_TOKEN", "CLIENT_ID")

Effectuer des vérifications

Une fois que votre client démarre le flux, une session de flux de travail est automatiquement créée. Cette session contient toutes les données capturées (documents, images et vidéos), ainsi que le suivi de la progression. Vous pouvez les consulter via la page des sessions de flux de travail sur le portail ou via l'API.

Lorsque le flux se termine, le SDK déclenche le onSuccess rappel. Le rappel fournit un données qui inclut le workflowSessionId. Votre backend mobile doit utiliser cet identifiant pour informer ComplyCube que le flux de travail est terminé, ce qui déclenche à son tour les contrôles de vérification définis dans le flux de travail.

Si vous avez configuré des webhooks comme décrit dans notre guide des webhooks, vous serez averti une fois qu'une session de flux de travail sera terminée.

Exemple d'une requête complète de session de flux de travail

curl -X POST https://api.complycube.com/v1/workflowSessions/{:wfSessionId}/complete \
     -H 'Authorization: <YOUR_API_KEY>' \\
     -H 'Content-Type: application/json'

const { ComplyCube } = require("@complycube/api");

const complycube = new ComplyCube({ apiKey: "<YOUR_API_KEY>" });

const wfSession = await complycube.workflowSession.complete("WORKFLOW_SESSION_ID");

from complycube import ComplyCubeClient

cc_api = ComplyCubeClient(api_key='<YOUR_API_KEY>')

workflow_session = cc_api.workflowsessions.complete('WORKFLOW_SESSION_ID')

use ComplyCube\ComplyCubeClient;

$ccapi = new ComplyCubeClient('<YOUR_API_KEY>');

$workflowSession = $ccapi->workflowSessions()->complete('WORKFLOW_SESSION_ID');

using ComplyCube.Net;
using ComplyCube.Net.Resources.WorkflowSessions;

var wfSessionApi = new WorkflowSessionApi(new ComplyCubeClient("<YOUR_API_KEY>"));

var workflowSession = await wfSessionApi.CompleteAsync("WORKFLOW_SESSION_ID");

Récupérer les résultats de vérification

Votre backend mobile peut récupérer les détails de la session de workflow et les résultats de vérification associés à l'aide de notre API.

Tous nos contrôles sont asynchrones. Si vous avez configuré des webhooks comme décrit dans notre guide des webhooks, vous serez informé lorsqu'une vérification sera terminée.

Vous pouvez récupérer les détails d'une session de flux de travail en appelant la requête de récupération de session de flux de travail.

Pour récupérer les résultats de la vérification, vous pouvez effectuer une requête GET de vérification.

Exemple de requête de récupération d’une session de workflow

curl -X GET https://api.complycube.com/v1/workflowSessions/{:workflowSessionId} \
     -H 'Authorization: <YOUR_API_KEY>'

const { ComplyCube } = require("@complycube/api");

const complycube = new ComplyCube({ apiKey: "<YOUR_API_KEY>" });

const wfSession = await complycube.workflowSession.get("WORKFLOW_SESSION_ID");

from complycube import ComplyCubeClient

cc_api = ComplyCubeClient(api_key='<YOUR_API_KEY>')

workflow_session = cc_api.workflowsessions.get('WORKFLOW_SESSION_ID')

using ComplyCube.Net;
using ComplyCube.Net.Resources.WorkflowSessions;

var wfSessionApi = new WorkflowSessionApi(new ComplyCubeClient("<YOUR_API_KEY>"));

var workflowSession = await wfSessionApi.GetAsync("WORKFLOW_SESSION_ID");

Exemple de requête de récupération d’un contrôle

curl -X GET https://api.complycube.com/v1/checks/{:checkId} \\
     -H 'Authorization: <YOUR_API_KEY>'

const { ComplyCube } = require("@complycube/api");

const complycube = new ComplyCube({ apiKey: "<YOUR_API_KEY>" });

const check = await complycube.check.get("CHECK_ID");

using ComplyCube.Net;
using ComplyCube.Net.Resources.Checks;

var checkApi = new CheckApi(new ComplyCubeClient("<YOUR_API_KEY>"));

var check = await checkApi.GetAsync("CHECK_ID");

Capture NFC

Le SDK mobile ComplyCube prend en charge la lecture basée sur la NFC puce RFID des documents d'identité équipés de puces intégrées. Cela permet une extraction sécurisée des données et une authentification documentaire hautement fiable.

Veuillez contacter votre Responsable de compte ou service d’assistance pour accéder à notre SDK mobile compatible NFC.

Prérequis

Pour utiliser cette fonctionnalité, votre application doit avoir la Lecture des balises Near Field Communication capacité activée. Pour ajouter cette capacité à votre application, reportez-vous à au guide d'Apple ici.

Installez le CocoaPods Artifactory plugin en exécutant la commande suivante dans votre terminal :
```
gem install cocoapods-art
```
Pour ajouter la bibliothèque, copiez les identifiants de votre dépôt dans un .netrc fichier dans votre répertoire personnel et configurez le dépôt :
```
pod repo-art add cc-cocoapods-release-local "https://complycuberepo.jfrog.io/artifactory/api/pods/cc-cocoapods-release-local"
```
N'oubliez pas de récupérer vos identifiants depuis JFrog en utilisant le Set Me Up bouton ici.

Ajoutez les dépôts du plugin et installez le pod à l'aide de votre Podfile:

 plugin 'cocoapods-art', :sources => [
   'cc-cocoapods-release-local',
   'trunk'
 ]
 ...
 platform :ios, '13.0' # Ou supérieur

 target 'YourApp' do
   use_frameworks!
   use_modular_headers!
   ...
   pod 'ComplyCubeMobileSDK', '2.0.x-nfc'
   ...
 en

Vous devez ajouter les clés suivantes à votre application Info.plist fichier :
```
<key>NFCReaderUsageDescription</key>
<string>Nécessaire pour lire des documents compatibles NFC</string>
```

Pour lire correctement les balises NFC, vous devez ajouter les entrées suivantes à la cible de votre application Info.plist fichier :

<key>com.apple.developer.nfc.readersession.felica.systemcodes</key>
<array>
  <string>12FC</string>
</array>
<key>com.apple.developer.nfc.readersession.iso7816.select-identifiers</key>
<array>
  <string>A0000002471001</string>
  <string>A0000002472001</string>
  <string>00000000000000</string>
  <string>D2760000850101</string>
  <string>E80704007F00070302</string>
  <string>A000000167455349474E</string>
  <string>A00000045645444C2D3031</string>
</array>

Ajoutez ce qui suit dans votre Runner.entitlements fichier :
```
<key>com.apple.developer.nfc.readersession.formats</key>
<array><string>TAG</string></array>
```
Pour activer NFC lors de la compilation de votre application iOS, transmettez la USE_CCNFC variable d'environnement pendant la compilation :
```
USE_CCNFC=true flutter build ios
```
Pour conserver cette option activée pour toutes les compilations iOS, ajoutez la ligne suivante en haut de votre ios/Podfile:
```
ENV['USE_CCNFC'] ||= 'true'
```

Branding

Vous pouvez personnaliser les couleurs, les logos et d’autres éléments de marque via la page des paramètres de l’image de marque, si cette option est disponible dans votre forfait.

Localisation

Le SDK prend en charge plusieurs langues, notamment celles énumérées ci-dessous.

Arabe - ar 🇦🇪
Chinois (simplifié) - zh 🇨🇳
Chinois (traditionnel) - hk 🇨🇳
Néerlandais - nl 🇳🇱
Anglais - en 🇺🇸
Français - fr 🇫🇷
Allemand - de 🇩🇪
Hindi - hi 🇮🇳
Indonésien - identifiant 🇮🇩
Italien - it 🇮🇹

Japonais - ja 🇯🇵
Coréen - ko 🇰🇷
Norvégien - no 🇳🇴
Polonais - po 🇵🇱
Portugais - pt 🇵🇹
Espagnol - es 🇪🇸
Suédois - sv 🇸🇪
Thaï - th 🇹🇭
Vietnamien - vi 🇻🇳
et plus encore...

Gestion des résultats

Pour exécuter une session de vérification, vous devez implémenter le succès, annulé, et erreur callbacks.

En cas d’achèvement réussi (onSuccess), vous pouvez déclencher un requêtes de fin de session de workflow depuis votre backend en utilisant l'ID de session de workflow renvoyé dans l'objet de résultat.

Si l’utilisateur quitte le flux avant la fin, le onCancelled callback est appelée avec une raison descriptive indiquant pourquoi la session a été annulée (par ex. sortie de l’utilisateur, délai d’attente, autorisation refusée)

Dans certains cas, le client peut annuler le flux après avoir terminé une ou plusieurs étapes de capture. Si cela se produit, toutes les données capturées avant l’annulation, comme des documents ou des médias biométriques, peuvent déjà avoir été téléversées vers son dossier client.

Si le SDK rencontre un problème, le onError callback est déclenchée avec un ComplyCubeError objet contenant le type d’erreur et le message. Consultez les codes d’erreur (voir ci-dessous) pour une liste complète des cas d’erreur possibles.

extension ViewController: ComplyCubeMobileSDKDelegate {
  func onSuccess(_ result: ComplyCubeResult) {
   /*
    Gestion des résultats réussis :
      Le paramètre « results » contiendra : 
      - "workflowSessionId": "xxxxx"
    */
    print("Le flux est terminé - voici les ID renvoyés")
  }
  
  func onError(_ error: ComplyCubeError) {
    // Gérer les erreurs
    print("Une erreur s'est produite")
  }

  func onCancelled(_ error: ComplyCubeError) {
    // Gérer les annulations
    print("L'utilisateur a annulé le flux ou n'a pas accepté les conditions")
  }  
}

Codes d’erreur

Type d'erreur

Description

Nombre d'étapes biométriques

La configuration contient des doublons photo de selfie ou vidéo selfie étapes.

Annulé

Le client a annulé le flux et quitté le SDK (a déclenché le onCancelled callback).

Connectivité

Une erreur réseau s'est produite.

Document obligatoire

Un étape de document est requise en fonction des étapes configurées, mais n'a pas été incluse.

Jeton expiré

Le jeton du SDK a expiré. Générez un nouveau jeton et redémarrez le flux.

Erreur de flux

Une erreur irrécupérable s'est produite pendant le flux.

Code pays invalide

Un code pays invalide a été fourni.

Jailbroken

Le SDK ne peut pas s'exécuter sur cet appareil car il a été jailbreaké ou compromis.

Aucun accès au disque

Le client a refusé les autorisations d'accès au disque requises par le SDK.

Aucun type de document

Un étape de document a été initialisé sans spécifier de types de document.

Aucun résultat

Aucun résultat n'a été renvoyé au rappel. Si cela persiste, veuillez contacter l'assistance.

Aucun consentement de l'utilisateur

Le client n'a pas fourni son consentement pour poursuivre le flux du SDK.

Non autorisé

Le SDK a tenté d'accéder à un point de terminaison qu'il n'est pas autorisé à utiliser.

Inconnu

Une erreur inattendue s'est produite. Si cela se reproduit régulièrement, contactez l'assistance.

Combinaison pays/type de document non prise en charge

La combinaison sélectionnée de pays et de type de document n'est pas prise en charge.

Type de document non pris en charge

Le type de document fourni n'est pas pris en charge.

Erreur de téléversement

Une erreur est survenue lors du téléversement d'un document ou d'un selfie.

Téléversement nécessitant une assistance

Si useLiveCaptureOnly est défini sur false, l'assistance doit être activée en définissant isGuidanceEnabled à true.

Suivi des événements

Le SDK suit une gamme de événements tout au long du parcours de vérification, couvrant toutes les interactions clés des utilisateurs à chaque étape. Consultez ci-dessous la liste des événements.

Si vous devez mettre en œuvre des analyses personnalisées, vous pouvez vous raccorder à ces événements et déclencher en conséquence votre propre logique de suivi.

Pour intégrer votre propre suivi, définissez une fonction et appliquez-la à l’aide de withEventHandler lors de l’initialisation du FlowBuilder:

let sdk = ComplyCubeMobileSDK.FlowBuilder()
  .withEventHandler({ (event: Event) -> Void in
    // Insérez ici le code de suivi utilisateur personnalisé
  })

Événements

Événement

INTRODUCTION Le client a atteint l'écran d'introduction.

ÉTAPE_DE_CONSENTEMENT Le client a atteint l'écran de consentement.

AVERTISSEMENT_ÉTAPE_DE_CONSENTEMENT Le client a tenté de quitter sans donner son consentement.

AUTORISATION_D'ACCÈS_À_LA_CAMÉRA Le client a atteint l'écran de demande d'autorisation de la caméra.

ÉTAPE_GUIDE_DE_CAPTURE_DE_DOCUMENT Le client a atteint l'écran de guide de capture de document.

ÉTAPE_TYPE_DE_DOCUMENT Le client a atteint l'écran de sélection du type de document pour une capture de document.

ÉTAPE_SÉLECTION_DU_PAYS Le client a atteint l'écran de sélection du pays pour une capture de document.

ÉTAPE_DOCUMENT_À_UNE_FACE_CAMÉRA Le client a atteint l'étape de capture par caméra pour un document d'identité à une face.

ÉTAPE_DOCUMENT_À_UNE_FACE_CAMÉRA_MODE_MANUEL Le client a atteint l'écran de capture manuelle par caméra pour un document d'identité à une face.

ÉTAPE_DOCUMENT_À_UNE_FACE_VÉRIFICATION_QUALITÉ Le client a atteint l'écran d'aperçu de qualité pour un document d'identité à une face.

ÉTAPE_DOCUMENT_FACE_AVANT_CAMÉRA Le client a atteint l'écran de capture par caméra pour la face avant d'un document d'identité à deux faces.

ÉTAPE_DOCUMENT_FACE_AVANT_CAMÉRA_MODE_MANUEL Le client a atteint l'écran de capture manuelle par caméra pour la face avant d'un document d'identité à deux faces.

ÉTAPE_DOCUMENT_FACE_AVANT_VÉRIFICATION_QUALITÉ Le client a atteint l'écran d'aperçu de qualité pour la face avant d'un document d'identité à deux faces.

ÉTAPE_DOCUMENT_FACE_ARRIÈRE_CAMÉRA Le client a atteint l'écran de capture par caméra pour la face arrière d'un document d'identité à deux faces.

ÉTAPE_DOCUMENT_FACE_ARRIÈRE_CAMÉRA_MODE_MANUEL Le client a atteint l'écran de capture manuelle par caméra pour la face arrière d'un document d'identité à deux faces.

ÉTAPE_DOCUMENT_FACE_ARRIÈRE_VÉRIFICATION_QUALITÉ Le client a atteint l'écran d'aperçu de qualité pour la face arrière d'un document d'identité à deux faces.

ÉTAPE_BIOMÉTRIE_GUIDE_DE_CAPTURE_DE_SELFIE Le client a atteint l'écran de guide de capture de selfie.

ÉTAPE_BIOMÉTRIE_CAMÉRA_SELFIE Le client a atteint l'écran de capture photo de selfie par caméra.

ÉTAPE_BIOMÉTRIE_CAMÉRA_SELFIE_MODE_MANUEL Le client a atteint l'écran de capture photo de selfie manuelle par caméra.

ÉTAPE_BIOMÉTRIE_VÉRIFICATION_QUALITÉ_SELFIE Le client a atteint l'écran de prévisualisation de la photo de selfie.

ÉTAPE_BIOMÉTRIE_CAMÉRA_VIDÉO Le client a atteint l'écran de caméra de selfie vidéo.

ÉTAPE_BIOMÉTRIE_CAMÉRA_VIDÉO_MODE_MANUEL Le client a atteint l'écran de capture manuelle par caméra pour un selfie vidéo.

ÉTAPE_BIOMÉTRIE_PREMIÈRE_ACTION_VIDÉO Le client a atteint la première action d'une capture de selfie vidéo.

ÉTAPE_BIOMÉTRIE_DEUXIÈME_ACTION_VIDÉO Le client a atteint la deuxième action d'une capture de selfie vidéo.

ÉTAPE_BIOMÉTRIE_VÉRIFICATION_QUALITÉ_VIDÉO Le client a atteint l'écran de capture manuelle par caméra pour un selfie vidéo.

ÉTAPE_GUIDE_DE_CAPTURE_DU_JUSTIFICATIF_DE_DOMICILE Le client a atteint l'écran de guide de capture du justificatif de domicile.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_TYPE_DE_DOCUMENT Le client a atteint l'écran de sélection du type de document pour une capture de justificatif de domicile.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_SÉLECTION_DU_PAYS Le client a atteint l'écran de sélection du pays pour une capture de justificatif de domicile.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_À_UNE_FACE_CAMÉRA Le client a atteint l'étape de capture par caméra pour un justificatif de domicile à une face.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_À_UNE_FACE_CAMÉRA_MODE_MANUEL Le client a atteint l'étape de capture manuelle par caméra pour un justificatif de domicile à une face.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_À_UNE_FACE_VÉRIFICATION_QUALITÉ Le client a atteint l'écran d'aperçu de qualité pour un justificatif de domicile à une face.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_FACE_AVANT_CAMÉRA Le client a atteint l'étape de capture par caméra pour la face avant d'un justificatif de domicile à deux faces.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_FACE_AVANT_CAMÉRA_MODE_MANUEL Le client a atteint l'étape de capture manuelle par caméra pour la face avant d'un justificatif de domicile à deux faces.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_FACE_AVANT_VÉRIFICATION_QUALITÉ Le client a atteint l'écran d'aperçu de qualité pour la face avant d'un justificatif de domicile à deux faces.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_FACE_ARRIÈRE_CAMÉRA Le client a atteint l'étape de capture par caméra pour la face arrière d'un justificatif de domicile à deux faces.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_FACE_ARRIÈRE_CAMÉRA_MODE_MANUEL Le client a atteint l'étape de capture manuelle par caméra pour la face arrière d'un justificatif de domicile à deux faces.

ÉTAPE_JUSTIFICATIF_DE_DOMICILE_FACE_ARRIÈRE_VÉRIFICATION_QUALITÉ Le client a atteint l'écran d'aperçu de qualité pour la face arrière d'un justificatif de domicile à deux faces.

ÉTAPE_DE_FINALISATION Le client a atteint l'écran de fin.

Gestion de l’expiration du jeton

Pour gérer l’expiration du jeton de manière fluide, vous pouvez fournir une fonction de rappel qui génère un nouveau jeton SDK lorsque nécessaire. Cela permet au flux de se poursuivre sans interruption, sans que l’utilisateur ait à redémarrer la session manuellement.

let sdk = ComplyCubeMobileSDK.FlowBuilder()
  .withTokenExpiryHandler({ () -> String in
    // Insérez ici votre code personnalisé de renouvellement du jeton
  })