Headless SDK (Inscription Android)

Cette page fournit un guide pour l'inscription au Yuno Headless SDK pour Android.

Le Headless SDK de Yuno pour Android offre une solution flexible et sans interface utilisateur (UI) pour enregistrer des méthodes de paiement et tokeniser des cartes.

Ce SDK offre un contrôle total sur le processus d'enregistrement des méthodes de paiement, ce qui le rend idéal pour les commerçants qui :

Ont besoin d'un contrôle total sur l'interface utilisateur et l'expérience client
Souhaitent implémenter des flux d'enregistrement personnalisés
Nécessitent des capacités d'intégration avancées

Le Headless SDK comprend des fonctionnalités de base telles que :

Tokenisation de carte
Enregistrement sécurisé de méthode de paiement
Accès direct à l'API
Gestion d'erreurs personnalisée

Pour les commerçants nécessitant une solution d'interface utilisateur pré-construite ou une intégration plus simple, veuillez envisager d'utiliser nos autres implémentations de SDK :

Prérequis

Avant de commencer l'intégration du SDK Android de Yuno, assurez-vous que votre projet répond aux exigences techniques. De plus, les pré-requis suivants doivent être en place :

Vous devez disposer d'un compte Yuno actif
Vous avez besoin de vos identifiants API Yuno :
- account_id
- public-api-key
- private-secret-key

Vous pouvez obtenir ces identifiants dans la section Développeurs du tableau de bord de Yuno. Ils sont requis pour :

Créer un customer, ce qui est obligatoire avant d'enregistrer des méthodes de paiement
Créer un customer_session, qui initialise le flux d'enregistrement

📘
Information sur la version du SDK
Vérifiez la version actuelle du SDK en accédant aux Notes de version ou en visitant le Dépôt du SDK Android Yuno.

Étape 1 : Créer un client

Créez un client en utilisant le endpoint Créer un client avant d'enregistrer des méthodes de paiement.

Prérequis :

Compte Yuno actif
Identifiants API

Requis pour :

Identifier la personne qui enregistre la méthode de paiement
Activer la fonctionnalité de méthode de paiement enregistrée
Suivre l'historique d'enregistrement
Conservez l'identifiant du client en toute sécurité pour l'étape suivante.

Étape 2 : Créer une session client

Créez une nouvelle customer_session à l'aide du endpoint Créer session client valide :

Prérequis :

ID du client de l'Étape 1
Identifiants API

Actions requises :

Incluez l'ID du client dans la requête
Conservez l'ID de la customer_session ID
Générez une nouvelle customer_session pour chaque enregistrement de méthode de paiement.

Étape 3 : Ajouter le SDK à votre projet

Prérequis :

Projet Android configuré
Accès à la configuration Gradle

Ajoutez la source du dépôt :

maven { url "https://yunopayments.jfrog.io/artifactory/snapshots-libs-release" }

Ajoutez la dépendance du SDK :

dependencies {
    implementation 'com.yuno.payments:android-sdk:{last_version}'
}

📘
Permission Internet requise
Le SDK Yuno inclut automatiquement la permission INTERNET , nécessaire pour les requêtes réseau. Assurez-vous que votre AndroidManifest.xml contient :
<uses-permission android:name="android.permission.INTERNET" />

Étape 4 : Initialiser le Headless SDK avec la clé publique

Récupérez vos clés API publiques depuis le Tableau de bord Yuno.

Si vous n'avez pas implémenté une classe Application personnalisée, créez-en une. Dans la méthode onCreate() de votre classe d'application, appelez la fonction d'initialisation (Yuno.initialize) :

class CustomApplication : Application() {
  override fun onCreate() {
    super.onCreate()
    Yuno.initialize(
      this,
      PUBLIC_API_KEY,
      config: YunoConfig,
    )
  }
}

Étape 5 : Créer une session client

Pour démarrer le processus d'enregistrement :

Créez un client en utilisant le endpoint Créer un client . La réponse inclura l' id.
Créez une session client en utilisant :
- L'objet id de l'étape 1
- Le endpoint Créer une session client

La réponse de l'endpoint fournira la valeur de la customer_session requise pour l'enregistrement.

🚧
Génération de Session Client
Vous devez générer une nouvelle customer_session chaque fois que vous enregistrez une méthode de paiement.

Étape 6 : Créer un objet de méthode de paiement d'enregistrement

Créez un objet de méthode de paiement d'enregistrement en utilisant le endpoint Enregistrer une méthode de paiement pour configurer l'intégration du Headless SDK pour l'enregistrement. Lors de la création de cet objet, spécifiez le type de méthode de paiement que votre client peut enregistrer. Actuellement, le Headless SDK ne prend en charge que le type de méthode de paiement CARD.

📘
Vérification de la carte
Pour vérifier les cartes (autorisation à valeur nulle) avant l'enregistrement, incluez l'objet verify lors de la création de l'objet de méthode de paiement pour la session client. En savoir plus

Étape 7 : Démarrer le processus d'enregistrement

Utilisez l'endpoint apiClientEnroll pour démarrer le processus d'enregistrement. Cette fonction nécessite des paramètres de configuration qui définissent la manière dont l'enregistrement sera traité. Le tableau suivant décrit les paramètres requis :

Paramètres	Description
`country_code`	Ce paramètre détermine le pays pour lequel le processus de paiement est configuré. La liste complète des pays pris en charge et leurs `country_code` est disponible sur la page Couverture par Pays .
`customer_session`	Fait référence à la session client de l'enregistrement actuel reçue en réponse à l'endpoint Créer session client . Exemple : `438413b7-4921-41e4-b8f3-28a5a0141638`

Le bloc de code suivant montre un exemple de configuration des paramètres :

override fun onCreate(savedInstanceState: Bundle?) {
	val apiClientEnroll = Yuno.apiClientEnroll(
  	country_code = "CO",
    
    customerSession = "eec6578e-ac2f-40a0-8065-25b5957f6dd3",

    context = this 
  )
 }

Étape 8 : Générer un token sécurisé

Après avoir collecté toutes les informations client requises, créez un vaulted_token à l'aide du endpoint apiClientEnroll.continueEnrollment . Comme il s'agit d'une fonction asynchrone, utilisez un bloc try/catch pour gérer les erreurs potentielles. L'exemple suivant montre comment créer un vaulted_token:

apiClientEnroll.continueEnrollment( 
 collectedData = EnrollmentCollectedData(
    customerSession = "customer_session",
    paymentMethod = EnrollmentMethod(
           type = "CARD",
           card = CardData(
               save = true,
               detail = Detail(
                   expirationMonth = 11,
                   expirationYear = 55,
                   number = "4111111111111111",
                   securityCode = "123",
                   holderName = "Prénom Nom",
                   type = CardType.DEBIT
               ),
           customer = Customer(
               id = "id",
               merchantCustomerId = "merchant_customer_id",
               firstName = "prénom",
 email "[email ]",
               country = « CO »,
document = Document(
documentType = « PAS »,
documentNumber = « PAS12312 »),

phone = Phone(
number = « 321123321123 »,
country_code = « 57 »)
)
),

context = this
 )

Le champ apiClientEnroll.continueEnrollment retourne un type Observable qui étend LiveData. Vous pouvez observer la réponse comme un LiveData standard de type SingleLiveEvent<Map<String, Any?>>. Ce LiveData émet une seule fois et retourne une Map contenant la réponse complète. Voici un exemple de réponse après l'appel à apiClientEnroll.continueEnrollment:

{
  "vaulted_token": "9104911d-5df9-429e-8488-ad41abea1a4b",
  "status": "SUCCEEDED",
  "customer": {
    "session": "eec6578e-ac2f-40a0-8065-25b5957f6dd3"
  }
}

Le bloc de code suivant montre un exemple d'observation de la réponse :

apiClientPayment.continueEnrollment(data, context).observe(context) { response ->
   val status = response["status"] as String ?
   val vauldtedtoken = response["vaulted_token"] as String ?
}

📘
Suivi du Statut par Webhook
Envisagez d'utiliser le statut d'enregistrement reçu via les Webhooks. Yuno recommande de toujours utiliser ce statut pour baser et prendre des décisions commerciales sur votre plateforme.