Mobile SDK Core

Es más bien una biblioteca que un SDK. Se utiliza para cifrar los datos de la tarjeta en seToken, que se puede transmitir y almacenar de forma segura en cualquier sistema (por ejemplo, en el servidor del comerciante). Es una buena solución para comerciantes que desean máxima flexibilidad o no quieren tratar con datos de tarjetas en sus servidores.

Métodos de pago admitidos por este SDK:

Proceso de pago SDK Core

Web View para 3DS

El siguiente diagrama muestra el proceso de pago SDK Core con redirección 3DS a través de Web View.

1. El cliente crea un pedido
2. El servidor móvil registra este pedido en la pasarela de pago a través de register.do. Use el parámetro returnUrl como marcador para cerrar Web View después de la redirección desde ACS en el Paso 14.
3. El servidor móvil recibe en respuesta el número único de pedido mdOrder.
4. El cliente completa los datos de pago en la aplicación móvil.

5. La aplicación móvil llama al SDK para crear seToken. (Android: sdkCore.generateWithCard; iOS: CKCToken.generateWithCard).

   La clave pública, que se requiere en el método correspondiente, debe tomarse del recurso online https://dev.bpcbt.com/payment/se/keys.do. Si hay varias claves disponibles en este enlace, se debe usar la primera clave. (Tenga en cuenta que se utilizan claves diferentes para los entornos de prueba y producción.)

6. La aplicación móvil envía seToken al servidor móvil.

7. El servidor móvil utiliza este seToken para realizar el pago a través de paymentorder.do.

   • Use seToken en lugar de pan, cvc y fecha de vencimiento.
   • No olvide especificar el nombre del titular de la tarjeta en el campo TEXT. Si no recopila el nombre del titular de la tarjeta, simplemente envíe el valor CARDHOLDER.

8. El servidor móvil recibe respuesta sin redirección a ACS. Esto significa que el pago está completado y necesitamos ir al Paso 16.1. El servidor móvil recibe una respuesta con redirección a ACS.

9. La aplicación móvil abre Web View con los datos de redirección a ACS.

10. El cliente introduce su contraseña de un solo uso en el formulario ACS.

11. ACS redirige al cliente a la pasarela de pago.

12. La pasarela de pago realiza el pago.

13. La pasarela de pago redirige al cliente a returnUrl, que se puede utilizar como marcador para cerrar Web View.

14. La aplicación móvil cierra Web View.

15. La pasarela de pago envía notificación de callback al servidor del comerciante, si está configurado para el comerciante.

16. El servidor móvil verifica el estado final del pago a través de getOrderStatusExtended.do.

17. La aplicación móvil muestra el resultado del pago al cliente.

IOS

Integración iOS

Integración SDKCore.framework

Puede integrar SDKCore.framework agregándolo manualmente.

SDKCore.framework

• Descargue la última versión del framework aquí.

• Seleccione el archivo SDKCore.framework y agréguelo a la carpeta del proyecto.

• Abra la página Targets -> General -> Frameworks, Libraries, and Embedded Content. Para SDKCore.framework en la columna Embed reemplace Do not Embed por Embed & Sign.

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

Trabajo con API V2

Dependencias externas

Para generar el token es necesario establecer la clave pública.

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

Método de generación de token

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)

Configuración iOS

Registro de eventos

Los procesos internos se registran con la etiqueta SDKCore. También puede registrar sus propios procesos.

El registro de eventos está disponible a través del objeto Logger.shared.

• Para agregar interfaces de registro es necesario llamar al método addLogInterface() de Logger.

Ejemplo:

...
final class LoggerImplementation: LogInterface {

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

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

Por defecto se utiliza la etiqueta SDKCore. Puede establecer la suya propia si lo desea.

• Para registrar eventos propios es necesario llamar al método log() de Logger.shared.

Ejemplo:

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

Ejemplo Swift_core (sin interfaz gráfica)

Ejemplo de formación de criptograma

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)
    }
  }

Modelos

NewPaymentMethodParams

StoredPaymentMethodParams

TokenResult

Errores de validación de campos

Trabajo con API V1

Dependencias externas

Para generar el token es necesario establecer la clave pública.

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

Método de generación 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)

Modelos

CardParams

BindingParams

Errores de validación de campos

Android

Integración Android

Conexión al proyecto Gradle agregando archivos .aar de la biblioteca

Es necesario agregar el archivo de biblioteca sdk_core-release.aar en la carpeta libs, y luego especificar la dependencia de la biblioteca agregada.

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')
}

Trabajo con API V2

Dependencias externas

Para generar el token es necesario instalar la clave pública.

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

Método de generación de tokens

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)

Configuración Android

Registro de eventos

Los procesos internos se registran con la etiqueta SDK-Core. También puedes registrar tus propios procesos.

El registro está disponible a través del objeto Logger.

• Para agregar interfaces de registro es necesario llamar al método Logger addLogInterface().

  Ejemplo para registro en LogCat:

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

Por defecto se utiliza la etiqueta SDK-Core. Puedes establecer la tuya propia, si quieres.

• Para registrar eventos propios es necesario llamar al método Logger log().

  Ejemplo:

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

Ejemplo Kotlin_core (sin interfaz gráfica)

Ejemplo de formación de criptograma

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() {
    // initialization of validators for card information entry fields
    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?) {
        // instalación de validadores en los campos de entrada de información de tarjeta
        cardNumberInput.setupValidator(cardNumberValidator)
        cardExpiryInput.setupValidator(cardExpiryValidator)
        cardCodeInput.setupValidator(cardCodeValidator)
        cardHolderInput.setupValidator(cardHolderValidator)
        mdOrderInput.setupValidator(orderNumberValidator)

        // creación de un objeto e inicialización de campos para una nueva tarjeta
        val params = NewPaymentMethodCardParams(
            pan = cardNumberInput.text.toString(),
            cvc = cardCodeInput.text.toString(),
            expiryMMYY = cardExpiryInput.text.toString(),
            cardHolder = cardHolderInput.text.toString(),
            pubKey = pubKeyInput.text.toString()
        )
        // llamada al método para obtener el criptograma para una nueva tarjeta
        sdkCore.generateWithConfig(SDKCoreConfig(params))

        // Creación de un objeto e inicialización de campos para la tarjeta vinculada
        val params = NewPaymentMethodStoredCardParams(
            storedPaymentId = "storedPaymentMethodId",
            cvc = "123",
            pubKey = pubKeyInput.text.toString()
        )
        // llamada al método para obtener el criptograma para la tarjeta vinculada
        sdkCore.generateWithConfig(SDKCoreConfig(params))
    }
}

Modelos

NewPaymentMethodCardParams

NewPaymentMethodStoredCardParams

TokenResult

Errores de validación de campos

Trabajo con API V1

Dependencias externas

Para generar el token es necesario instalar la clave pública.

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

Método de generación de token

// 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

Para implementar la integración de Mobile SDK Core en una aplicación React Native es necesario configurar un puente — un wrapper en Kotlin/Java o Swift/Objective-C, que recibirá llamadas desde JavaScript y las transmitirá al código nativo del SDK.

Los puentes en React Native permiten que tu código JS llame a métodos de bibliotecas nativas tan fácilmente como funciones asíncronas habituales: declaras un módulo nativo con métodos que devuelven el resultado a través de Promise, React Native vincula automáticamente estos métodos con JavaScript, y después trabajas con ellos en la aplicación sin conocimientos profundos de APIs de plataforma.

IOS

1. Integre SDKCore en su proyecto de acuerdo con la sección Integración iOS.

2. Verifique que para el framework SDKCore.xcframework en la columna Embed esté seleccionado Embed & Sign.

3. Cree un módulo Swift RadarSdkBridge.swift con el siguiente contenido:

   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. Implemente el puente Objective-C en el archivo 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. Descargue los archivos sdk_core-release.aar y sdk_logs-release.aar y cópielos en la carpeta android/app/libs/ según la sección Integración Android.

2. Agregue el repositorio plano y las dependencias en el archivo android/app/build.gradle:

   android {
       // … resto de la configuración de su proyecto …
   }
   
   repositories {
       flatDir {
           dirs 'libs'
       }
   }
   
   dependencies {
       // … otras dependencias …
       implementation(name: 'sdk_core-release', ext: 'aar')
       implementation(name: 'sdk_logs-release', ext: 'aar')
   }

Implementación del Native Module para Kotlin

1. Cree el archivo RadarSdkModule.kt en el directorio 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. Cree el paquete RadarSdkPackage.kt en el mismo directorio:

   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. Registre el paquete creado en 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()) // Registramos el paquete
                   }
   
               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()
           }
       }
   }

Uso en React Native

Utilice los métodos desde JavaScript/TypeScript de la siguiente manera:

import { NativeModules } from 'react-native';
const { RadarSdk } = NativeModules;
// Generación de token para nueva tarjeta
const token = await RadarSdk.generateNewCardToken(
  '4111111111111111', // PAN
  '123',              // CVC
  '12/25',            // Expiry MM/YY
  'CARDHOLDER NAME',  // Nombre del titular de la tarjeta
  'mdOrder',          // Número obtenido al registrar el pedido
  '-----BEGIN PUBLIC KEY-----...' // Clave pública de /payment/se/keys.do
);
// Generación de token para tarjeta vinculada
const bindToken = await RadarSdk.generateStoredCardToken(
  'bindingId',        // ID de la tarjeta guardada
  '123',              // CVC
  '-----BEGIN PUBLIC KEY-----…', // Clave pública de /payment/se/keys.do
  'mdOrder'           // Número obtenido al registrar el pedido
);

Aplicación demo

Un ejemplo de integración de Mobile Sdk Core en una aplicación React Native se puede ver en GitHub.

Mobile SDK Source

iOS

iOS código fuente en GitHub

iOS lanzamientos en GitHub

Requisitos: iOS 10.0 o superior

Android

Android código fuente en GitHub

Android lanzamientos en GitHub

Requisitos: Android 5.0 o superior