Mobile SDK Core

Il s'agit plutôt d'une bibliothèque que d'un SDK. Elle est utilisée pour chiffrer les données de carte en seToken, qui peut être transmis et stocké en toute sécurité dans n'importe quel système (par exemple, sur le serveur du marchand). C'est une bonne solution pour les marchands qui veulent une flexibilité maximale ou qui ne veulent pas traiter les données de carte sur leurs serveurs.

Méthodes de paiement supportées par ce SDK :

Processus de paiement SDK Core

Web View pour 3DS

Le diagramme ci-dessous montre le processus de paiement SDK Core avec redirection 3DS via Web View.

1. Le client crée une commande
2. Le serveur mobile enregistre cette commande dans la passerelle de paiement via register.do. Utilisez le paramètre returnUrl comme marqueur pour fermer la Web View après redirection depuis ACS à l'Étape 14.
3. Le serveur mobile reçoit en réponse le numéro unique de commande mdOrder.
4. Le client remplit les données de paiement dans l'application mobile.

5. L'application mobile appelle le SDK pour créer seToken. (Android: sdkCore.generateWithCard; iOS: CKCToken.generateWithCard).

   La clé publique, qui est requise dans la méthode correspondante, doit être prise depuis la ressource online https://dev.bpcbt.com/payment/se/keys.do. Si plusieurs clés sont disponibles via cette liaison, il faut utiliser la première clé. (Gardez à l'esprit que des clés différentes sont utilisées pour les environnements de test et de production.)

6. L'application mobile envoie seToken sur le serveur mobile.

7. Le serveur mobile utilise ce seToken pour effectuer le paiement via paymentorder.do.

   • Utilisez seToken au lieu de pan, cvc et date d'expiration.
   • N'oubliez pas de spécifier le nom du porteur de carte dans le champ TEXT. Si vous ne collectez pas le nom du porteur de carte, envoyez simplement la valeur CARDHOLDER.

8. Le serveur mobile reçoit une réponse sans redirection vers ACS. Cela signifie que le paiement est terminé et nous devons passer à l'Étape 16.

9. Le serveur mobile reçoit une réponse avec une redirection vers ACS.

10. L'application mobile ouvre Web View avec les données de redirection vers ACS.

11. Le client saisit son mot de passe à usage unique dans le formulaire ACS.

12. ACS redirige le client vers la passerelle de paiement.

13. La passerelle de paiement effectue le paiement.

14. La passerelle de paiement redirige le client vers returnUrl, qui peut être utilisé comme marqueur pour fermer Web View.

15. L'application mobile ferme Web View.

16. La passerelle de paiement envoie notification de rappel au serveur du marchand, si elle est configurée pour le marchand.

17. Le serveur mobile vérifie le statut final du paiement via getOrderStatusExtended.do.

18. L'application mobile affiche le résultat du paiement au client.

IOS

Intégration iOS

Intégration SDKCore.framework

Vous pouvez intégrer SDKCore.framework en l'ajoutant manuellement.

SDKCore.framework

• Téléchargez la dernière version du framework ici.

• Sélectionnez le fichier SDKCore.framework et ajoutez-le dans le dossier du projet.

• Ouvrez la page Targets -> General -> Frameworks, Libraries, and Embedded Content. Pour SDKCore.framework dans la colonne Embed, remplacez Do not Embed par Embed & Sign.

//ViewController.swift
...
import SDKCore
...

Travail avec API V2

Dépendances externes

Pour générer le jeton, il est nécessaire de définir la clé publique.

let publicKey: String =
    "-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoIITqh9xlGx4tWA+aucb0V0YuFC9aXzJb0epdioSkq3qzNdRSZIxe/dHqcbMN2SyhzvN6MRVl3xyjGAV+lwk8poD4BRW3VwPUkT8xG/P/YLzi5N8lY6ILlfw6WCtRPK5bKGGnERcX5dqL60LhOPRDSYT5NHbbp/J2eFWyLigdU9Sq7jvz9ixOLh6xD7pgNgHtnOJ3Cw0Gqy03r3+m3+CBZwrzcp7ZFs41bit7/t1nIqgx78BCTPugap88Gs+8ZjdfDvuDM+/3EwwK0UVTj0SQOv0E5KcEHENL9QQg3ujmEi+zAavulPqXH5907q21lwQeemzkTJH4o2RCCVeYO+YrQIDAQAB-----END PUBLIC KEY-----"

Méthode de génération de jeton

let sdkCore = SdkCore()

  // TokenResult with NewPaymentMethod
  let newPaymentMethodParams = NewPaymentMethodParams(
       pan: "5536913776755304",
       cvc: "123",
       expiryMMYY: "12/22",
       cardholder: "TEST CARDHOLDER",
       pubKey: publicKey
  )
  let newPaymentMethodConfig = SDKCoreConfig(
      paymentMethodParams: .newPaymentMethodParams(params: newPaymentMethodParams)
  )
  let tokenResult = sdkCore.generateWithConfig(config: newPaymentMethodConfig)

  // TokenResult with StoredPaymentMethod
  let storedPaymentMethodParams = StoredPaymentMethodParams(
      pubKey: publicKey,
      storedPaymentMethodId: "storedPaymentMethodId",
      cvc: "123"
  )
  let storedPaymentMethodConfig = SDKCoreConfig(
      paymentMethodParams: .storedPaymentMethodParams(params: storedPaymentMethodParams)
  )
  let tokenResult = sdkCore.generateWithConfig(config: storedPaymentMethodConfig)

Configuration iOS

Journalisation

Les processus internes sont journalisés avec le tag SDKCore. Vous pouvez également journaliser vos processus.

La journalisation est disponible via l'objet Logger.shared.

• Pour ajouter des interfaces de log, il est nécessaire d'appeler la méthode addLogInterface() de Logger.

Exemple :

...
final class LoggerImplementation: LogInterface {

    func log(class: AnyClass, tag: String, message: String, exception: (any Error)?) {
        // Do something for logging
    }
}

Logger.shared.addLogInterface(logger: LoggerImplementation())
...

Par défaut, le tag SDKCore est utilisé. Vous pouvez définir le vôtre si vous le souhaitez.

• Pour journaliser vos propres événements, il est nécessaire d'appeler la méthode log() de Logger.shared.

Exemple :

...
     Logger.shared.log(classMethod: type(of: self),
                       tag: "MyTag",
                       message: "My process...",
                       exception: nil)
...

Exemple Swift_core (sans interface graphique)

Exemple de formation de cryptogramme

import UIKit
  import SDKCore

  final class MainViewController: UIViewController {

    private let cardNumberValidator = CardNumberValidator()
    private let cardExpiryValidator = CardExpiryValidator()
    private let cardCodeValidator = CardCodeValidator()
    private let cardHolderValidator = CardHolderValidator()
    private let sdkCore = SdkCore()

    private var cardNumberValidationResult: ValidationResult = .VALID
    private var cardExpiryValidationResult: ValidationResult = .VALID
    private var cardCodeValidationResult: ValidationResult = .VALID
    private var cardHolderValidationResult: ValidationResult = .VALID

    private func checkValidation() {
      cardNumberValidationResult = cardNumberValidator.validate(data: cardNumberValue)
      cardExpiryValidationResult = cardNumberValidator.validate(data: cardExpiryValue)
      cardCodeValidationResult = cardNumberValidator.validate(data: cardCodeValue)
      cardHolderValidationResult = cardNumberValidator.validate(data: cardHolderValue)
    }

    private func generateTokenResult() {
      let newPaymentMethodParams = NewPaymentMethodParams(
           pan: cardNumberValue,
           cvc: cardExpiryValue,
           expiryMMYY: cardExpiryValue,
           cardholder: cardHolderValue,
           pubKey: publicKey
      )

      let newPaymentMethodConfig = SDKCoreConfig(
          paymentMethodParams: .newPaymentMethodParams(params: newPaymentMethodParams)
      )
      let tokenResultWithNewPaymentMethod = sdkCore.generateWithConfig(config: newPaymentMethodConfig)


      let storedPaymentMethodParams = StoredPaymentMethodParams(
          pubKey: publicKey,
          storedPaymentMethodId: "storedPaymentMethodId",
          cvc: "123"
      )
      let storedPaymentMethodConfig = SDKCoreConfig(
          paymentMethodParams: .storedPaymentMethodParams(params: storedPaymentMethodParams)
      )
      let tokenResultWithStoredPaymentMethod = sdkCore.generateWithConfig(config: storedPaymentMethodConfig)
    }
  }

Modèles

NewPaymentMethodParams

StoredPaymentMethodParams

TokenResult

Erreurs de validation des champs

Travail avec API V1

Dépendances externes

Pour générer le token, il est nécessaire de définir la clé publique.

let publicKey: String =
      "-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoIITqh9xlGx4tWA+aucb0V0YuFC9aXzJb0epdioSkq3qzNdRSZIxe/dHqcbMN2SyhzvN6MRVl3xyjGAV+lwk8poD4BRW3VwPUkT8xG/P/YLzi5N8lY6ILlfw6WCtRPK5bKGGnERcX5dqL60LhOPRDSYT5NHbbp/J2eFWyLigdU9Sq7jvz9ixOLh6xD7pgNgHtnOJ3Cw0Gqy03r3+m3+CBZwrzcp7ZFs41bit7/t1nIqgx78BCTPugap88Gs+8ZjdfDvuDM+/3EwwK0UVTj0SQOv0E5KcEHENL9QQg3ujmEi+zAavulPqXH5907q21lwQeemzkTJH4o2RCCVeYO+YrQIDAQAB-----END PUBLIC KEY-----"

Méthode de génération de token

let sdkCore = SdkCore()

let cardParams = CardParams(
     pan: "4111111111111111",
     cvc: "123",
     expiryMMYY: "12/28",
     cardholder: "TEST CARDHOLDER", 
     mdOrder: "mdOrder",
     pubKey: publicKey
)

let cardParamsConfig = SDKCoreConfig(
    paymentMethodParams: .cardParams(params: cardParams)
)
let tokenResult = sdkCore.generateWithConfig(config: cardParamsConfig)

let bindignParams = BindingParams(
    pubKey: publicKey,
    bindingId: "das",
    cvc: "123",
    mdOrder: "mdOrder"
)
let bindingParamsConfig = SDKCoreConfig(
    paymentMethodParams: .bindingParams(params: bindignParams)
)
let tokenResult = sdkCore.generateWithConfig(config: bindingParamsConfig)

Modèles

CardParams

BindingParams

Erreurs de validation des champs

Android

Intégration Android

Connexion au projet Gradle par ajout des fichiers .aar de la bibliothèque

Il est nécessaire d'ajouter le fichier de la bibliothèque sdk_core-release.aar dans le dossier libs, puis d'indiquer la dépendance de la bibliothèque ajoutée.

build.gradle.kts

allprojects {
    repositories {
        // ...
        flatDir {
            dirs("libs")
        }
    }
}

dependencies {
    // dependency is mandatory to add
    implementation(group = "", name = "sdk_core-release", ext = "aar")
}

build.gradle

allprojects {
    repositories {
        // ...
        flatDir {
            dirs 'libs'
        }
    }
}

dependencies {
    // dependency is mandatory to add
    implementation(group: '', name: 'sdk_core-release', ext: 'aar')
}

Travail avec l'API V2

Dépendances externes

Pour générer le token, il est nécessaire d'établir la clé publique.

val publicKey: String =
    "-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoIITqh9xlGx4tWA+aucb0V0YuFC9aXzJb0epdioSkq3qzNdRSZIxe/dHqcbMN2SyhzvN6MRVl3xyjGAV+lwk8poD4BRW3VwPUkT8xG/P/YLzi5N8lY6ILlfw6WCtRPK5bKGGnERcX5dqL60LhOPRDSYT5NHbbp/J2eFWyLigdU9Sq7jvz9ixOLh6xD7pgNgHtnOJ3Cw0Gqy03r3+m3+CBZwrzcp7ZFs41bit7/t1nIqgx78BCTPugap88Gs+8ZjdfDvuDM+/3EwwK0UVTj0SQOv0E5KcEHENL9QQg3ujmEi+zAavulPqXH5907q21lwQeemzkTJH4o2RCCVeYO+YrQIDAQAB-----END PUBLIC KEY-----"

Méthode de génération de token

val context: Context //android context for getting string resources
val sdkCore: SDKCore = SDKCore(context)

// TokenResult with NewPaymentMethod
val newPaymentMethodCardParams = NewPaymentMethodCardParams(
       pan = "4111111111111111",
       cvc = "123",
       expiryMMYY = "12/28",
       cardHolder = "John Smith",
       pubKey= publicKey
  )
val newPaymentMethodConfig = SDKCoreConfig(paymentCardParams = newPaymentMethodCardParams)
val tokenResult = sdkCore.generateWithConfig(config = newPaymentMethodConfig)

// TokenResult with NewPaymentMethodStoredCard
val newPaymentMethodStoredCardParams = NewPaymentMethodStoredCardParams(
      pubKey = publicKey,
      storedPaymentId = "storedPaymentMethodId",
      cvc = "123"
  )
val storedPaymentMethodConfig = SDKCoreConfig(paymentCardParams = newPaymentMethodStoredCardParams)
val tokenResult = sdkCore.generateWithConfig(config = storedPaymentMethodConfig)

Configuration Android

Journalisation

Les processus internes sont journalisés avec le tag SDK-Core. Vous pouvez également journaliser vos propres processus.

La journalisation est disponible via l'objet Logger.

• Pour ajouter des interfaces de log, il faut appeler la méthode addLogInterface() du Logger.

  Exemple pour la journalisation dans LogCat :

...
    Logger.addLogInterface(object : LogInterface {
        override fun log(classMethod: Class<Any>, tag: String, message: String, exception: Exception?) {
                Log.i(tag, "$classMethod: $message", exception)
            }
        })
...

Par défaut, le tag SDK-Core est utilisé. Vous pouvez définir le vôtre si vous le souhaitez.

• Pour journaliser vos propres événements, il faut appeler la méthode log() du Logger.

  Exemple :

...
     Logger.log(this.javaClass, "MyTag", "My process...", null)
...

Exemple Kotlin_core (sans interface graphique)

Exemple de formation de cryptogramme

import net.payrdr.mobile.payment.sdk.core.SDKCore
import net.payrdr.mobile.payment.sdk.core.TokenResult
import net.payrdr.mobile.payment.sdk.core.model.BindingParams
import net.payrdr.mobile.payment.sdk.core.model.CardParams
import net.payrdr.mobile.payment.sdk.core.validation.BaseValidator
import net.payrdr.mobile.payment.sdk.core.validation.CardCodeValidator
import net.payrdr.mobile.payment.sdk.core.validation.CardExpiryValidator
import net.payrdr.mobile.payment.sdk.core.validation.CardHolderValidator
import net.payrdr.mobile.payment.sdk.core.validation.CardNumberValidator
import net.payrdr.mobile.payment.sdk.core.validation.OrderNumberValidator

class MainActivity : AppCompatActivity() {
    // initialisation des validateurs pour les champs de saisie des informations de carte
    private val cardNumberValidator by lazy { CardNumberValidator(this) }
    private val cardExpiryValidator by lazy { CardExpiryValidator(this) }
    private val cardCodeValidator by lazy { CardCodeValidator(this) }
    private val cardHolderValidator by lazy { CardHolderValidator(this) }
    private val orderNumberValidator by lazy { OrderNumberValidator(this) }
    private val sdkCore by lazy { SDKCore(context = this) }

    override fun onCreate(savedInstanceState: Bundle?) {
        // installation des validateurs sur les champs de saisie des informations de carte
        cardNumberInput.setupValidator(cardNumberValidator)
        cardExpiryInput.setupValidator(cardExpiryValidator)
        cardCodeInput.setupValidator(cardCodeValidator)
        cardHolderInput.setupValidator(cardHolderValidator)
        mdOrderInput.setupValidator(orderNumberValidator)

        // création d'un objet et initialisation des champs pour une nouvelle carte
        val params = NewPaymentMethodCardParams(
            pan = cardNumberInput.text.toString(),
            cvc = cardCodeInput.text.toString(),
            expiryMMYY = cardExpiryInput.text.toString(),
            cardHolder = cardHolderInput.text.toString(),
            pubKey = pubKeyInput.text.toString()
        )
        // appel de méthode pour obtenir le cryptogramme pour une nouvelle carte
        sdkCore.generateWithConfig(SDKCoreConfig(params))

        // Création d'un objet et initialisation des champs pour la carte liée
        val params = NewPaymentMethodStoredCardParams(
            storedPaymentId = "storedPaymentMethodId",
            cvc = "123",
            pubKey = pubKeyInput.text.toString()
        )
        // appel de méthode pour obtenir le cryptogramme pour la carte liée
        sdkCore.generateWithConfig(SDKCoreConfig(params))
    }
}

Modèles

NewPaymentMethodCardParams

NewPaymentMethodStoredCardParams

TokenResult

Erreurs de validation des champs

Travail avec API V1

Dépendances externes

Pour générer le jeton, il est nécessaire d'installer la clé publique.

val publicKey: String =
    "-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoIITqh9xlGx4tWA+aucb0V0YuFC9aXzJb0epdioSkq3qzNdRSZIxe/dHqcbMN2SyhzvN6MRVl3xyjGAV+lwk8poD4BRW3VwPUkT8xG/P/YLzi5N8lY6ILlfw6WCtRPK5bKGGnERcX5dqL60LhOPRDSYT5NHbbp/J2eFWyLigdU9Sq7jvz9ixOLh6xD7pgNgHtnOJ3Cw0Gqy03r3+m3+CBZwrzcp7ZFs41bit7/t1nIqgx78BCTPugap88Gs+8ZjdfDvuDM+/3EwwK0UVTj0SQOv0E5KcEHENL9QQg3ujmEi+zAavulPqXH5907q21lwQeemzkTJH4o2RCCVeYO+YrQIDAQAB-----END PUBLIC KEY-----"

Méthode de génération du jeton

// TokenResult with CardParams
val cardParams: CardParams = CardParams(
    mdOrder = "mdOrder",
    pan = "4111111111111111",
    cvc = "123",
    expiryMMYY = "12/28",
    cardHolder = "TEST CARDHOLDER",
    pubKey = "publicKey"
)
val tokenResult = sdkCore.generationWithConfig(paymentCardParams = cardParams)

// TokenResult with BindingParams
val bindingParams: BindingParams = BindingParams(
    mdOrder = "mdOrder",
    bindingID = "das",
    cvc = "123",
    pubKey = "publicKey"
)

val tokenResult = sdkCore.generationWithConfig(paymentCardParams = bindingParams)

React Native

Pour réaliser l'intégration Mobile SDK Core dans une application React Native, il est nécessaire de configurer un pont — une enveloppe sur Kotlin/Java ou Swift/Objective-C, qui recevra les appels depuis JavaScript et les transmettra au code natif du SDK.

Les ponts dans React Native permettent à votre code JS d'appeler les méthodes des bibliothèques natives aussi simplement que des fonctions asynchrones ordinaires : vous déclarez un module natif avec des méthodes qui retournent le résultat via Promise, React Native lie automatiquement ces méthodes avec JavaScript, et ensuite vous travaillez avec elles dans l'application sans connaissances approfondies des API de plateforme.

IOS

1. Intégrez SDKCore dans votre projet conformément à la section iOS-intégration.

2. Vérifiez que pour le framework SDKCore.xcframework dans la colonne Embed est sélectionné Embed & Sign.

3. Créez un module Swift RadarSdkBridge.swift avec le contenu suivant :

   import Foundation
   import React
   import SDKCore
   
   @objc(RadarSdk)
   class RadarSdkBridge: NSObject {
       private let sdkCore = SdkCore()
   
       @objc
       func generateNewCardToken(
           _ pan: String,
           cvc: String,
           expiryMMYY: String,
           cardHolder: String,
           mdOrder: String,
           pubKey: String,
           resolver resolve: RCTPromiseResolveBlock,
           rejecter reject: RCTPromiseRejectBlock
       ) {
           do {
               let params = CardParams(
                   pan: pan,
                   cvc: cvc,
                   expiryMMYY: expiryMMYY,
                   cardholder: cardHolder,
                   mdOrder: mdOrder,
                   pubKey: pubKey
               )
               let config = SDKCoreConfig(paymentMethodParams: .cardParams(params: params))
               let result = try sdkCore.generateWithConfig(config: config)
               resolve(result.token)
           } catch {
               reject("TOKEN_ERROR", error.localizedDescription, error)
           }
       }
   
       @objc
       func generateStoredCardToken(
           _ storedPaymentId: String,
           cvc: String,
           pubKey: String,
           mdOrder: String,
           resolver resolve: RCTPromiseResolveBlock,
           rejecter reject: RCTPromiseRejectBlock
       ) {
           do {
               let params = BindingParams(
                   pubKey: pubKey,
                   bindingId: storedPaymentId,
                   cvc: cvc,
                   mdOrder: mdOrder
               )
               let config = SDKCoreConfig(paymentMethodParams: .bindingParams(params: params))
               let result = try sdkCore.generateWithConfig(config: config)
               resolve(result.token)
           } catch {
               reject("TOKEN_ERROR", error.localizedDescription, error)
           }
       }
   
       @objc
       static func requiresMainQueueSetup() -> Bool {
           return false
       }
   }

4. Implémentez le pont Objective-C dans le fichier RadarSdkBridge.m :

   #import <React/RCTBridgeModule.h>
   
   @interface RCT_EXTERN_MODULE(RadarSdk, NSObject)
   
   RCT_EXTERN_METHOD(generateNewCardToken:
     (NSString *)pan
     cvc:(NSString *)cvc
     expiryMMYY:(NSString *)expiryMMYY
     cardHolder:(NSString *)cardHolder
     mdOrder:(NSString *)mdOrder
     pubKey:(NSString *)pubKey
     resolver:(RCTPromiseResolveBlock)resolve
     rejecter:(RCTPromiseRejectBlock)reject
   )
   
   RCT_EXTERN_METHOD(generateStoredCardToken:
     (NSString *)storedPaymentId
     cvc:(NSString *)cvc
     pubKey:(NSString *)pubKey
     mdOrder:(NSString *)mdOrder
     resolver:(RCTPromiseResolveBlock)resolve
     rejecter:(RCTPromiseRejectBlock)reject
   )
   
   @end

Android

1. Téléchargez les fichiers sdk_core-release.aar et sdk_logs-release.aar et copiez-les dans le dossier android/app/libs/ selon la section Android-intégration.

2. Ajoutez le dépôt plat et les dépendances dans le fichier android/app/build.gradle:

   android {
       // … le reste de la configuration de votre projet …
   }
   
   repositories {
       flatDir {
           dirs 'libs'
       }
   }
   
   dependencies {
       // … autres dépendances …
       implementation(name: 'sdk_core-release', ext: 'aar')
       implementation(name: 'sdk_logs-release', ext: 'aar')
   }

Implémentation du Native Module pour Kotlin

1. Créez le fichier RadarSdkModule.kt dans le répertoire android/app/src/main/java/.../radar/:

   package com.mobilesdkdemo.radar
   
   import com.facebook.react.bridge.Promise
   import com.facebook.react.bridge.ReactApplicationContext
   import com.facebook.react.bridge.ReactContextBaseJavaModule
   import com.facebook.react.bridge.ReactMethod
   import net.payrdr.mobile.payment.sdk.core.SDKCore
   import net.payrdr.mobile.payment.sdk.core.model.SDKCoreConfig
   import net.payrdr.mobile.payment.sdk.core.model.CardParams
   import net.payrdr.mobile.payment.sdk.core.model.BindingParams
   
   class RadarSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
       override fun getName(): String = "RadarSdk"
   
       private val sdkCore by lazy { SDKCore(context = reactApplicationContext) }
   
       @ReactMethod
       fun generateNewCardToken(
           pan: String,
           cvc: String,
           expiryMMYY: String,
           cardHolder: String,
           mdOrder: String,
           pubKey: String,
           promise: Promise
       ) {
           try {
               val params = CardParams(
                   pan = pan,
                   cvc = cvc,
                   expiryMMYY = expiryMMYY,
                   cardHolder = cardHolder,
                   mdOrder = mdOrder,
                   pubKey = pubKey
               )
               val config = SDKCoreConfig(paymentCardParams = params)
               val result = sdkCore.generateWithConfig(config)
               promise.resolve(result.token)
           } catch (e: Exception) {
               promise.reject("TOKEN_ERROR", e)
           }
       }
   
       @ReactMethod
       fun generateStoredCardToken(
           storedPaymentId: String,
           cvc: String,
           pubKey: String,
           mdOrder: String,
           promise: Promise
       ) {
           try {
               val params = BindingParams(
                   bindingID = storedPaymentId,
                   mdOrder = mdOrder,
                   cvc = cvc,
                   pubKey = pubKey
               )
               val config = SDKCoreConfig(paymentCardParams = params)
               val result = sdkCore.generateWithConfig(config)
               promise.resolve(result.token)
           } catch (e: Exception) {
               promise.reject("TOKEN_ERROR", e)
           }
       }
   }

2. Créez le package RadarSdkPackage.kt dans le même répertoire:

   package com.mobilesdkdemo.radar
   
   import com.facebook.react.ReactPackage
   import com.facebook.react.bridge.NativeModule
   import com.facebook.react.bridge.ReactApplicationContext
   import com.facebook.react.uimanager.ViewManager
   
   class RadarSdkPackage : ReactPackage {
       override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
           listOf(RadarSdkModule(reactContext))
   
       override fun createViewManagers(
           reactContext: ReactApplicationContext
       ): List<ViewManager<*, *>> = emptyList()
   }

3. Enregistrez le package créé dans MainApplication.kt:

   package com.mobilesdkdemo
   
   import android.app.Application
   import com.facebook.react.PackageList
   import com.facebook.react.ReactApplication
   import com.facebook.react.ReactNativeHost
   import com.facebook.react.ReactHost
   import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.load
   import com.facebook.react.defaults.DefaultReactNativeHost
   import com.facebook.soloader.SoLoader
   import com.mobilesdkdemo.radar.RadarSdkPackage
   
   class MainApplication : Application(), ReactApplication {
   
       override val reactNativeHost: ReactNativeHost =
           object : DefaultReactNativeHost(this) {
               override fun getPackages(): List<ReactPackage> =
                   PackageList(this).packages.apply {
                       add(RadarSdkPackage()) // Enregistrement du package
                   }
   
               override fun getJSMainModuleName(): String = "index"
               override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
               override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
               override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
           }
   
       override val reactHost: ReactHost
           get() = getReactNativeHost(applicationContext, reactNativeHost)
   
       override fun onCreate() {
           super.onCreate()
           SoLoader.init(this, false)
           if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
               load()
           }
       }
   }

Utilisation dans React Native

Utilisez les méthodes depuis JavaScript/TypeScript de la manière suivante :

import { NativeModules } from 'react-native';
const { RadarSdk } = NativeModules;
// Génération de token pour une nouvelle carte
const token = await RadarSdk.generateNewCardToken(
  '4111111111111111', // PAN
  '123',              // CVC
  '12/25',            // Expiry MM/YY
  'CARDHOLDER NAME',  // Nom du porteur de la carte
  'mdOrder',          // Numéro obtenu lors de l'enregistrement de la commande
  '-----BEGIN PUBLIC KEY-----...' // Clé publique depuis /payment/se/keys.do
);
// Génération de token pour une carte liée
const bindToken = await RadarSdk.generateStoredCardToken(
  'bindingId',        // ID de la carte sauvegardée
  '123',              // CVC
  '-----BEGIN PUBLIC KEY-----…', // Clé publique depuis /payment/se/keys.do
  'mdOrder'           // Numéro obtenu lors de l'enregistrement de la commande
);

Application de démonstration

Un exemple d'intégration de Mobile Sdk Core dans une application React Native peut être consulté sur GitHub.

Mobile SDK Source

iOS

iOS sources sur GitHub

iOS releases sur GitHub

Exigences: iOS 10.0 ou supérieur

Android

Android sources sur GitHub

Android releases sur GitHub

Exigences: Android 5.0 ou supérieur