El Payment Widget es una herramienta integrada que permite a los comercios ofrecer múltiples métodos de pago a sus clientes de manera sencilla y eficiente. Este widget es compatible tanto con Métodos de Pago Alternativos (APMs) como con tarjetas de crédito y débito, proporcionando flexibilidad en las opciones de pago para los usuarios.

El Payment Widget soporta:

Métodos de Pago Alternativos (APMs): como OXXO, KueskiPay, entre otros.
Tarjetas de Crédito y Débito: MasterCard, Visa, American Express, etc.

Paso 1: Completar los Primeros Pasos

Antes de integrar el Payment Widget, es necesario que completes la sección de primeros pasos. En esta sección, te explicamos los requisitos necesarios y cómo inicializar el SDK. Puedes encontrar más información en Primeros Pasos con el SDK de Android.

Una vez que hayas completado estos pasos, podrás continuar con el paso 2.

Paso 2: Mostrar el Widget

2.1 Mostrar el Widget en un Dialogo

Para mostrar el Payment Widget en un DialogFragment, llama a la función initPaymentWidget pasando los siguientes datos:

let deunaSDK: DeunaSDK = ....

deunaSDK.initPaymentWidget(
  context = YOUR_ACTIVITY_CONTEXT,
  orderToken = "<DEUNA order token>",
  userToken = "<DEUNA user token>", // Opcional
  styleFile: "<DEUNA theme ID to customize the look and feel of the widget>", // Opcional
  callbacks = PaymentWidgetCallbacks().apply {
    onSuccess = { data ->
      deunaSDK.close() // Cierra el DialogFragment del  widget de pago
      // Tu código adicional
    }
    onCardBinDetected = { metadata, refetchOrder ->
      if (metadata != null) {
        // Tu código aquí
      }
    }
    onInstallmentSelected = { metadata, refetchOrder ->
      // Tu código aquí
    }
    onError = { error ->
      // Manejo de errores
    }
    onClosed = { action ->
      // Widget cerrado
    }
  },
)

2.1. Mostrar el Widget de forma embebida (Jetpack Compose)

Para mostrar el widget de pago de forma embebida en tu aplicación con Compose, usa el composable AndroidView y el view DeunaWidget.

IMPORTANTE: DeunaWiget no admite dimensiones dinámicas por lo que el contenedor del AndroidView debe definir las dimensiones que utilizará el widget de DEUNA.

@Composable
fun YourScreen(
    deunaSDK: DeunaSDK,
    orderToken: String,
    userToken: String,
) {
    // Maintains the Deuna WebView instance across recompositions
    val deunaWidget = remember { mutableStateOf<DeunaWidget?>(null) }

    Column(modifier = Modifier.padding(16.dp)) {
        // Container for the embedded payment widget
        // MUST specify dimensions (e.g., .height(400.dp) or .weight(1f) in parent Column)
        Box(
            modifier = yourModifier 
        ) {
            AndroidView(
                modifier = Modifier.fillMaxSize(),
                factory = { context ->
                    DeunaWidget(context).apply {
                        // Set true to handle payment submission manually via submit()
                        // Set false to use Deuna's built-in payment button
                        hidePayButton = true

                        // Configure payment widget callbacks
                        bridge = PaymentWidgetBridge(
                            callbacks = PaymentWidgetCallbacks().apply {
                                onSuccess = { order -> 
                                    // Called when payment is successfully processed
                                    // 'order' contains transaction details
                                }
                                onError = { error -> 
                                    // Called when payment processing fails
                                    // 'error' contains failure information
                                }
                            },
                            deunaWidget = this
                        )

                        // Initialize widget with payment details
                        val widgetUrl = deunaSDK.buildPaymentWidgetUrl(
                            orderToken = orderToken,
                            userToken = userToken
                        )
                        loadUrl(widgetUrl)
                        
                        // Store reference for later submission
                        deunaWidget.value = this
                    }
                }
            )
        }

        Spacer(modifier = Modifier.height(16.dp))

        // Custom payment submission button
        // Only needed when hidePayButton = true
        Button(
            onClick = {
                // Programmatically submit payment details to Deuna
                // Required when hidePayButton = true
                deunaWidget.value?.submit { result ->
                    // Handle submission result
                    // result.status: "success"|"error"
                    // result.message: Detailed status message
                }
            },
            modifier = Modifier.fillMaxWidth()
        ) {
            Text("Complete Payment")
        }
    }

    // Critical: Clean up DeunaWidget resources when composable leaves composition
    DisposableEffect(Unit) {
        onDispose {
            deunaWidget.value?.destroy()
            Log.d("DeunaWidget", "WebView resources cleaned up")
        }
    }
}

Parámetros

Dependiendo de la forma que como muestres el widget de pago deberas usar una de las siguientes funciones:

Dialog: initPaymentWidget.
Embebido: buildPaymentWidgetUrl

Atributos	Dialogo	Embebido	Descripción
`context`	✅	❌	El context es el contexto de tu Activity en Android. Proporciona acceso a recursos específicos de la aplicación y a la información del entorno en el que se está ejecutando la aplicación.
`orderToken`	✅	✅	El orderToken es un token único generado para la orden de pago. Este token es generado a través del API de DEUNA y debes implementar el endpoint correspondiente en tu backend para obtener esta información. IMPORTANTE: Al momento de crear la orden con la API de DEUNA no se debe definir una URL de redirección (redirect_url) para que el callback onSuccess se ejecute correctamente.
`callbacks`	✅	❌	Los callbacks son funciones de retorno que se encargan de escuchar y manejar los eventos del widget de pago. Estos eventos permiten gestionar acciones específicas basadas en el estado del pago. Los principales callbacks incluyen: `onSuccess`, `onError`, `onClosed`, `onCanceled`, `onCardBinDetected`, `onInstallmentSelected` Si le widget de DEUNA se muestra de forma embebida se debe pasar los callbacks dentro de una instancia de la clase `PaymentWidgetBridge`, tal como se muestra en el código de ejemplo de Compose.
`userToken` (Opcional)	✅	✅	El bearer token del usuario de DEUNA. Cuando este es enviado, todas las acciones dentro del widget van a hacer sobre este usuario de DEUNA. Importante: para que este userToken sea usado y se le muestren las tarjetas guardadas al cliente, el correo asociado a ese userToken debe ser el mismo que se envía al crear la orden en `billing_address.email`. En caso que ambos correos no coincidan, se usará el flujo sin mostrar las tarjetas por seguridad.
`styleFile` (Opcional)	✅	✅	UUID proporcionado por DEUNA. Esto aplica si quieres configurar un archivo `custom styles` personalizado (Cambiar colores, textos, logo, etc). Si se proporciona un valor válido para `styleFile` el payment widget utilizará la configuración de la UI proporcionada por la configuración del tema que coincida con el UUID proporcionado.
`paymentMethods` (Opcional)	✅	✅	Una lista métodos de pago permitidos. Este parámetro determina qué tipo de widget se debe renderizar.
`language`(Opcional)	✅	✅	Este parámetro permite especificar el idioma en el que se mostrará la interfaz del widget. Debe proporcionarse como un código de idioma válido (por ejemplo, "es" para español, "en" para inglés, "pt" para portugués). Comportamiento: - Si se proporciona: El widget utilizará el idioma especificado en este parámetro, independientemente de la configuración del comerciante. - Si no se proporciona: El widget utilizará el idioma configurado por el comerciante.
`behavior` (Opcional)	✅	✅	Utiliza este parámetro para configurar el comportamiento del widget.

Parámetro `behavior` (Opcional)

El método initPaymentWidget y buildPaymentWidgetUrl aceptan el parámetro behavior que debe ser una instancia de la clase WidgetBehavior que permite personalizar el comportamiento del widget de pago, incluyendo:

Habilitar pagos con múltiples tarjetas.
Entre otras opciones de configuración.

Nota: Estas configuraciones aplican a todos los métodos de pago habilitados en el widget.

Comportamiento de los métodos de pago `paymentMethods`

El parámetro paymentMethods dentro de behavior permite configurar comportamientos globales para todos los métodos de pago habilitados en el widget.

flowType (Tipo de Flujo)

Valores (string): twoStep o singleStep

Compatibilidad actual: Exclusivo para PayPal.

Controla el flujo de visualización para métodos de pago específicos que requieren mostrar información previa antes del formulario de pago.

/// DIALOG
deunaSDK.initPaymentWidget(
  orderToken = "TOKEN",
  ...
  behavior = WidgetBehavior(
    paymentMethods = mapOf(
      "flowType" to "twoStep"
    )
  )
);

/// EMBEDDED
deunaSDK.buildPaymentWidgetUrl(
  orderToken = "TOKEN",
  ...
  behavior =  WidgetBehavior(
    paymentMethods = mapOf(
      "flowType" to "twoStep"
    )
  )
);

Pago dividido en multiples tarjetas (Split Payments)

La función de Split Payments permite a los clientes dividir el pago de una compra entre múltiples tarjetas de crédito/débito.

Requisitos Previos:

La opción debe estar habilitada en la configuración del comercio.
Actualmente solo se admite división entre 2 tarjetas como máximo.

/// DIALOG
deunaSDK.initPaymentWidget(
  orderToken = "TOKEN",
  ...
  behavior = WidgetBehavior(
    paymentMethods = mapOf(
      "creditCard" to mapOf(
      	"splitPayments" to mapOf(
          "maxCards" to 2  // Número máximo de tarjetas permitidas
        )
      )
    )
  )
);

/// EMBEDDED
deunaSDK.buildPaymentWidgetUrl(
  orderToken = "TOKEN",
  ...
  behavior = WidgetBehavior(
    paymentMethods = mapOf(
      "creditCard" to mapOf(
      	"splitPayments" to mapOf(
          "maxCards" to 2
        )
      )
    )
  )
);

Configuración de Auto Purchase para PayPal

La función Auto Purchase (compra automática) para PayPal permite procesar pagos instantáneamente cuando:

El cliente tiene previamente vinculada su cuenta de PayPal.
Ha autorizado pagos rápidos en su cuenta.

deunaSDK.initPaymentWidget(
    orderToken = "<DEUNA order token>",
    paymentMethods =
        listOf(
            mapOf(
                "paymentMethod" to "wallet",
                "processors" to listOf("paypal_wallet"),
                "configuration" to mapOf("express" to true)
            )
        )
)

Parámetros de Configuración

Parámetro	Tipo	Valor por Defecto	Descripción
express	Boolean	true	Cuando es `true`, procesa el pago automáticamente si el cliente tiene PayPal vinculado. Cuando es `false`, permite seleccionar/confirmar la cuenta.

IMPORTANTE: la configuración de express solo funcionará si en el parámetro paymentMethods se le pasa únicamente la configuración para PayPal.

2.1. Mostrar u ocultar métodos de pago

El Payment Widget puede desplegar varios métodos de pago disponibles para una orden, sin que el comercio tenga que agregar individualmente cada botón de APM en su Frontend.

Al invocar la función initPaymentWidget, el parámetro paymentMethods define los métodos de pago que el widget mostrará:

Si se pasa 1 solo método en paymentMethods el widget abre automáticamente el formulario del método de pago sin mostrar botones de otros AMPs.

// DIALOG
deunaSDK.initPaymentWidget(
  orderToken = "<DEUNA order token>",
  userToken = ..., // optional
  styleFile = ..., // optional
  callbacks = ...,
  paymentMethods = listOf(
    mapOf(
        "paymentMethod" to "voucher",
        "processors" to listOf("payu_oxxo_cash")
    )
  )
)

// EMBEDDED
val widgetUrl = deunaSDK.buildPaymentWidgetUrl(
   orderToken ="<DEUNA order token>",
   userToken = ..., // optional
   paymentMethods = listOf(
    mapOf(
        "paymentMethod" to "voucher",
        "processors" to listOf("payu_oxxo_cash")
    )
  )
)

// DIALOG
deunaSDK.initPaymentWidget(
  orderToken = "<DEUNA order token>",
  userToken = ..., // optional
  styleFile = ..., // optional
  callbacks = ...,
  paymentMethods = listOf(
    mapOf(
        "paymentMethod" to "voucher",
        "processors" to listOf("daviplata")
    )
  )
)

// EMBEDDED
val widgetUrl = deunaSDK.buildPaymentWidgetUrl(
   orderToken ="<DEUNA order token>",
   userToken = ..., // optional
   paymentMethods = listOf(
    mapOf(
        "paymentMethod" to "voucher",
        "processors" to listOf("daviplata")
    )
  )
)

// DIALOG
deunaSDK.initPaymentWidget(
  orderToken = "<DEUNA order token>",
  userToken = ..., // optional
  styleFile = ..., // optional
  callbacks = ...,
  paymentMethods = listOf(
    mapOf(
        "paymentMethod" to "voucher",
        "processors" to listOf("nequi_push_voucher")
    )
  )
)

// EMBEDDED
val widgetUrl = deunaSDK.buildPaymentWidgetUrl(
   orderToken ="<DEUNA order token>",
   userToken = ..., // optional
   paymentMethods = listOf(
    mapOf(
        "paymentMethod" to "voucher",
        "processors" to listOf("nequi_push_voucher")
    )
  )
)

Si se especifica más de 1 método de pago en el parámetro paymentMethods, el widget solo mostrará esos métodos habilitados los cuales deben estar configurados a nivel comercio.
- 📘
  For credit card processing there is no need to pass the processors's array since the merchant can have multiple configured for the use of routing.

// DIALOG
deunaSDK.initPaymentWidget(
  orderToken = "<DEUNA order token>",
  userToken = ..., // optional
  styleFile = ..., // optional
  callbacks = ...,
  paymentMethods = listOf(
    mapOf(
        "paymentMethod" to "credit_card"
    ),
    mapOf(
        "paymentMethod" to "voucher",
        "processors" to listOf("payu_oxxo_cash")
    ),
     mapOf(
        "paymentMethod" to "bnpl",
        "processors" to listOf("kueski")
    )
  )
)

// EMBEDDED
val widgetUrl = deunaSDK.buildPaymentWidgetUrl(
   orderToken ="<DEUNA order token>",
   userToken = ..., // optional
   paymentMethods = listOf(
    mapOf(
        "paymentMethod" to "credit_card"
    ),
    mapOf(
        "paymentMethod" to "voucher",
        "processors" to listOf("payu_oxxo_cash")
    ),
     mapOf(
        "paymentMethod" to "bnpl",
        "processors" to listOf("kueski")
    )
  )
)

Si no se especifica una lista de métodos en paymentMethods y no se utilizó el parámetro include_payment_options al crear la orden, el widget mostrará todos los métodos de pago configurados para el comercio.

// DIALOG
deunaSDK.initPaymentWidget(
  orderToken = "<DEUNA order token>",
  userToken = ..., // optional
  styleFile = ..., // optional
  callbacks = ...,
  paymentMethods = null
)

// EMBEDDED
val widgetUrl = deunaSDK.buildPaymentWidgetUrl(
   orderToken ="<DEUNA order token>",
   userToken = ..., // optional
   paymentMethods = null
)

2.2. Tabla de Prioridades de Configuración de Métodos de Pago

La siguiente tabla muestra como el payment widget decide que formas de pago debe mostrar cuando no se pasa el parámetro paymentMethods.

Prioridad	Fuente de Configuración	Descripción	Comportamiento en caso de un solo método de pago
1	Métodos de pago pasados al ejecutar la función `.initPaymentWidget` o `.buildPaymentWidgetUrl`	Los métodos de pago se muestran según los que se pasan al iniciar el widget, siempre y cuando estén activados y configurados a nivel comercio.	Si solo se pasa un método de pago, el widget abre automáticamente el formulario del método de pago sin mostrar botones.
2	Orden e `include_payment_options`	Se revisa la orden para verificar si `include_payment_options` tiene métodos de pago que estén configurados y activados a nivel comercio. Los métodos no configurados no se muestran.	Si solo se pasa un método de pago, el widget abre automáticamente el formulario del método de pago sin mostrar botones.
3	Métodos configurados a nivel comercio (API `/payment-methods`)	Si no se pasa ningún método de pago ni en la función `.initPaymentWidget` ni en `include_payment_options` al momento de crear la order, se toman los métodos configurados a nivel comercio.	Si solo se pasa un método de pago, el widget abre automáticamente el formulario del método de pago sin mostrar botones.

Paso 3: Escuchar los Eventos del Widget de Pago

Cuando una transacción es exitosa o falla, es importante actualizar tu interfaz para notificar a los usuarios sobre el resultado de la transacción. Esto lo puedes realizar escuchando los eventos del widget de pago mediante los callbacks.

La instancia de la clase PaymentWidgetCallbacks pasada a la función initPaymentWidget te permite escuchar los eventos del widget mediante callbacks. Define los callbacks respectivos para actualizar la interfaz de tu app.

3.1. Callbacks

Callback	¿Cuándo se dispara?
`onSuccess`	Se ejecuta cuando se completó el pago. Este callback contiene un parámetro de tipo Map<String,Any> con la información de la orden.
`onError`	Se ejecuta cuando ocurre un error. Este callback contiene un parámetro tipo PaymentsError el cual identifica el tipo de error producido. Consulta un ejemplo de la respuesta del callback aquí.
`onClosed` (Opcional)	Se ejecuta cuando se cierra el dialogo que contiene el widget de pago. Este callback contiene un parámetro de tipo enum `CloseAction` con los siguientes valores: - `userAction`: Cuando el widget fue cerrado manualmente por el usuario, presionando en el botón cerrar (X) o en el botón de retroceso en Android sin que la operación se haya completado. - `systemAction`: Cuando el widget se cierra debido a la ejecución de la función `close`. NOTA: Para implementación embebida el callback onClosed no ejecuta.
`onCardBinDetected` (Opcional)	Se ejecuta cuando el widget de pago detecta el BIN de una tarjeta de crédito o débito ingresada o cuando el usuario borra el número de la tarjeta ingresada. Este callback contiene un parámetro de tipo Map<String,Any> con la información del bin y la marca de la tarjeta ingresada. NOTA: El parámetro de tipo `Map<String,Any>` será `nulo` cuando el usuario elimina el texto ingresado en el campo del número de tarjeta.
`onInstallmentSelected` (Opcional)	Si la orden se puede diferir, este callback se ejecutará cuando el usuario seleccione los meses a diferir. Este callback contiene un parámetro de tipo Map<String,Any> con la información de los meses a diferir seleccionados por el usuario. NOTA: El parámetro de tipo `Map<String,Any>` será `nulo` cuando el usuario selecciona pago corriente (Sin cuotas).
`onPaymentProcessing` (Opcional)	Este callback se ejecutará cuando el usuario presiona en el botón pagar y se esta procesando el pago. NOTA: Si existe algún campo incorrecto en el formulario de pago este evento no se ejecutará.
`onEventDispatch` (Opcional)	Se ejecuta en todas los eventos que pueda producir el widget. Este callback contiene un parámetro de tipo `CheckoutEvent` y la data asociada a dicho evento

NOTA: Utiliza el callback onError para identificar si el widget no puedo ser mostrado o si ocurrió un error al procesar el pago.

onError = { error ->
    when (error.type) {
       // The widget could not be loaded
       PaymentsError.Type.INITIALIZATION_FAILED -> {
          deunaSDK.close()
       }

       // The payment was failed
       PaymentsError.Type.PAYMENT_ERROR -> {
           // YOUR CODE HERE
       }

      else -> {}
   }
}

Paso 4 (Opcional): Cerrar el Widget

Por defecto cuando el widget se muestra en un dialog a través de la función initPaymentWidget, el widget de pago solo se cierra cuando el usuario presiona el botón de cerrar del widget o cuando presiona el botón de "retroceso" en Android. Para cerrar el dialogo cuando un pago es exitoso o cuando ocurre un error, debes llamar a la función close.

El siguiente código de ejemplo muestra cómo cerrar el widget cuando un pago es exitoso.

deunaSDK.initPaymentWidget(
  context = YOUR_ACTIVITY_CONTEXT,
  orderToken = "<DEUNA order token>",
  userToken = "<DEUNA user token>", // optional
  callbacks = PaymentWidgetCallbacks().apply {
    onSuccess = { order -> 
      deunaSDK.close() // Cierra el widget de pago
      // Tu código adicional
    }
  }
)

Paso 5 (Opcional): Personalizar la apariencia del widget

Si el payment widget esta visible y quieres personalizar la apariencia del mismo utiliza la función setCustomStyle.

Consulta la siguiente documentación para conocer más a detalle todas las opciones de personalización del payment widget.

A continuación se muestra como cambiar los colores y el logo del payment widget mediante setCustomStyle

// DIALOG
deunaSDK.initPaymentWidget(
  context = YOUR_ACTIVITY_CONTEXT,
  orderToken = "<DEUNA order token>",
  userToken = "<DEUNA user token>", // optional
  callbacks = PaymentWidgetCallbacks().apply {
    onCardBinDetected = { cardBinMetadata ->
         this.deunaSDK.setCustomStyle(
             data = JSONObject(
                        """
                        {
                          "theme": {
                            "colors": {
                              "primaryTextColor": "#023047",
                              "backgroundSecondary": "#8ECAE6",
                              "backgroundPrimary": "#F2F2F2",
                              "buttonPrimaryFill": "#FFB703",
                              "buttonPrimaryHover": "#FFB703",
                              "buttonPrimaryText": "#000000",
                              "buttonPrimaryActive": "#FFB703"
                            }
                          },
                          "HeaderPattern": {
                            "overrides": {
                              "Logo": {
                                "props": {
                                  "url": "https://images-staging.getduna.com/ema/fc78ef09-ffc7-4d04-aec3-4c2a2023b336/test2.png"
                                }
                              }
                            }
                          }
                        }
                        """
         ).toMap()
        )
     }
   ...
  }
)

// EMBEDDED JETPACK COMPOSE
// Maintains the Deuna WebView instance across recompositions
val deunaWidget = remember { mutableStateOf<DeunaWidget?>(null) }
.
.
.
deunaWidget.value.setCustomStyle(data = ... )

Paso6 (Opcional): Refrescar el widget de pago

La función refetchOrder actualiza el widget de pago y retorna los datos de la orden actualizada.

Esta función es útil, por ejemplo, cuando el comercio ofrece promociones. Un caso común es una "promoción del 20% al pagar con Mastercard". En este escenario, el comercio escucha el evento onCardBinDetected para identificar la franquicia de la tarjeta. Luego, el comercio actualiza la orden en DEUNA (siendo el responsable de calcular las promociones) y, a través de esta función, notifica al widget para que se actualice, ya que el monto de la orden podría haber cambiado.

A continuación se muestra un ejemplo del uso de la función refetchOrder.

// DIALOG
deunaSDK.initPaymentWidget(
  context = YOUR_ACTIVITY_CONTEXT,
  orderToken = "<DEUNA order token>",
  userToken = "<DEUNA user token>", // optional
  callbacks = PaymentWidgetCallbacks().apply {
    onCardBinDetected = { metadata ->
      val cardBrand = metadata["cardBrand"] as String?
      if (cardBrand != null && cardBrand == "Mastercard"){
        deunaSDK.refetchOrder { order ->
          print("ORDER: $order")
        }
      }
    }
   ...
  }
)

// EMBEDDED JETPACK COMPOSE
// Maintains the Deuna WebView instance across recompositions
val deunaWidget = remember { mutableStateOf<DeunaWidget?>(null) }
.
.
.
deunaWidget.value.refetchOrder { order ->
}

Paso 7 (Opcional): Revisar Ejemplo Demo App

Para comprender mejor la integración del Payment Widget, revisa el proyecto de ejemplo proporcionado por DEUNA. Este ejemplo te ayudará a entender mejor cómo implementar el widget en tu aplicación Android.

Para acceder al proyecto de ejemplo y obtener más información, consulta la documentación del Ejemplo de Proyecto para Android.

Ocultar el botón de pago (Widget Embebido)

Cuando se muestra el widget de pago de forma embebida se puede utilizar la propiedad hidePayButton para esconder el botón de pago del DeunaWidget.

// Maintains the Deuna WebView instance across recompositions
val deunaWidget = remember { mutableStateOf<DeunaWidget?>(null) }
.
.
.

DeunaWidget(context).apply {
   // Set true to handle payment submission manually via submit()
   // Set false to use Deuna's built-in payment button
   hidePayButton = true
   .
   .
   .
 }

deunaWidget.value?.isValid { it ->  }
deunaWidget.value?.submit {result -> }

Puedes emplear las siguientes funciones para validar y ejecutar el pago.

Método	Descripción	Respuesta
`.isValid{...}`	Valida si la información ingresada es correcta y si el pago puede ser procesado.	`true` si la información es válida, `false` en caso contrario.
`.submit{...}`	Ejecuta el proceso de pago, equivalente a presionar el botón de pagar. Realiza las mismas validaciones internas.	`{ status: "success", message: "Pago procesado exitosamente" }` o `{ status: "error", message: "The submit flow is not available" }`

Consideraciones

Se recomienda usar isValid{} antes de llamar a submit{} para evitar errores en el proceso de pago.
Si el flujo de pago aún no está disponible, submit{} siempre devolverá un error con el mensaje "The submit flow is not available"

Paso 1: Completar los Primeros Pasos

Paso 2: Mostrar el Widget

2.1 Mostrar el Widget en un Dialogo

2.1. Mostrar el Widget de forma embebida (Jetpack Compose)

Parámetros

Parámetro behavior (Opcional)

Comportamiento de los métodos de pago paymentMethods

Pago dividido en multiples tarjetas (Split Payments)

Configuración de Auto Purchase para PayPal

2.1. Mostrar u ocultar métodos de pago

📘For credit card processing there is no need to pass the processors's array since the merchant can have multiple configured for the use of routing.

2.2. Tabla de Prioridades de Configuración de Métodos de Pago

Paso 3: Escuchar los Eventos del Widget de Pago

3.1. Callbacks

Paso 4 (Opcional): Cerrar el Widget

Paso 5 (Opcional): Personalizar la apariencia del widget

Paso6 (Opcional): Refrescar el widget de pago

Paso 7 (Opcional): Revisar Ejemplo Demo App

Ocultar el botón de pago (Widget Embebido)

Consideraciones

Parámetro `behavior` (Opcional)

Comportamiento de los métodos de pago `paymentMethods`

📘
For credit card processing there is no need to pass the processors's array since the merchant can have multiple configured for the use of routing.