> ## Documentation Index
> Fetch the complete documentation index at: https://docs.y.uno/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Test in the sandbox first: base URL https://api-sandbox.y.uno (Test Mode in the Dashboard). Production is https://api.y.uno (Live Mode).
> Every API request needs the public-api-key and private-secret-key headers. Get them in the Dashboard at https://dashboard.y.uno/developers (Developers > Credentials); sandbox and production keys are different.
> Send an X-Idempotency-Key (a UUID) when creating payments, refunds and cancels, so retries do not create duplicates.
> Start with the Quickstart (https://docs.y.uno/docs/quickstart.md) and the agent guide (https://docs.y.uno/agents.md). To search these docs from a coding agent, connect the docs MCP server at https://docs.y.uno/mcp.

# Modo Seamless

> Migra las integraciones Seamless de Android (Activity.startPaymentSeamlessLite) a la API Transaction unificada.

Seamless era el punto de entrada heredado más simple en Android: tras configurar el lanzador con `startCheckout(…)`, una sola llamada a `startPaymentSeamlessLite(paymentSelected, …)` lo delegaba todo: el SDK mostraba el formulario, tokenizaba, creaba el pago, ejecutaba 3DS y reportaba el resultado a través de una lambda `callbackPaymentState`.

En la API unificada el mismo flujo es el **comportamiento predeterminado** de `Transaction.start(activity, paymentSelected)`. No hay que sobrescribir nada en el controlador salvo `onStatus`. El cambio estructural es el modelo de entrega del resultado: antes era una lambda pasada a la llamada de inicio, ahora es un callback mediante `onStatus` en un `TransactionController`.

## Antes de empezar

* Reemplaza las importaciones `com.yuno.sdk.*` y `com.yuno.presentation.*` por sus equivalentes `com.yuno.payments.sdk.api.*` (la comparación lado a lado las enumera). Tu clave de API pública y las sesiones de checkout que crea tu backend no cambian ([Antes de comenzar](https://docs.y.uno/es/docs/yuno-sdk/get-started.md#before-you-begin)).
* Decide quién crea el pago. El `workflow` de la sesión de checkout debe coincidir con esa decisión:

| Quién crea el pago | En Seamless tenías | En la API unificada | `workflow` de la sesión |
| - | - | - | - |
| Tu backend | Sin equivalente: Seamless nunca te permitía crearlo | Sobrescribir `createPayment` | Predeterminado (`SDK_CHECKOUT`) |
| El SDK | Siempre | Sin sobrescritura | `SDK_SEAMLESS` |

> [!WARNING]
>
> Una sesión con el workflow predeterminado y sin sobrescritura de `createPayment` termina en `INTERNAL_ERROR`: el backend rechaza la creación del pago del SDK. Consulta [`createPayment`](https://docs.y.uno/es/docs/yuno-sdk/controllers/create-payment).

## Comparación lado a lado

```kotlin Before. Seamless mode theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
import com.yuno.sdk.Yuno
import com.yuno.sdk.payments.startCheckout
import com.yuno.sdk.payments.startPaymentSeamlessLite
import com.yuno.presentation.core.components.PaymentSelected

class CheckoutActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // 1. Initialize once at app startup
        Yuno.initialize(applicationContext, apiKey = "your-public-api-key")

        // 2. Wire up the checkout launcher
        startCheckout(
            checkoutSession = "session-from-backend",
            countryCode = "CO",
        )
    }

    // 3. Trigger the payment with a single call; result arrives in the lambda
    fun pay(paymentSelected: PaymentSelected) {
        startPaymentSeamlessLite(
            paymentSelected = paymentSelected,
            showPaymentStatus = true,
            callbackPaymentState = { state, subState ->
                when (state) {
                    "SUCCEEDED"         -> println("Success")
                    "REJECT"            -> println("Rejected")
                    "FAIL"              -> println("Failed")
                    "PROCESSING"        -> println("Processing")
                    "INTERNAL_ERROR"    -> println("Internal error")
                    "CANCELED_BY_USER"  -> println("User cancelled")
                }
            },
        )
    }
}
```

```kotlin After. Unified Transaction theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
import com.yuno.payments.sdk.api.SdkPayments
import com.yuno.payments.sdk.api.Transaction
import com.yuno.payments.sdk.api.TransactionConfig
import com.yuno.payments.sdk.api.TransactionController
import com.yuno.payments.sdk.api.models.PaymentMethodSelected
import com.yuno.payments.sdk.api.models.TransactionStatus

class CheckoutActivity : ComponentActivity(), TransactionController {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // 1. Initialize once at app startup
        SdkPayments.initialize(applicationContext, apiKey = "your-public-api-key")
    }

    // 2. Implement a minimal controller
    override fun onStatus(status: TransactionStatus) {
        when (status.status) {
            "SUCCEEDED"      -> println("Success")
            "DECLINED"       -> println("Declined")
            "REJECTED"       -> println("Rejected")
            "ERROR"          -> println("Error")
            "PENDING"        -> println("Pending")
            "INTERNAL_ERROR" -> println("Internal error")
            "USER_CANCEL"    -> println("User cancelled")
        }
    }

    // 3. Trigger the payment
    fun pay(paymentSelected: PaymentMethodSelected) {
        val config = TransactionConfig(
            checkoutSession = "session-from-backend",
            countryCode = "CO",
            language = "en",
            controller = this,
            showStatusScreen = true,
        )

        Transaction(config = config)
            .start(activity = this, paymentSelected = paymentSelected)
    }
}
```

## Qué cambia

Agrupado en el orden en que editas el código. **Renombrado**: mismo rol, nuevo nombre. **Movido**: mismo valor, nuevo propietario. **Eliminado**: nada que llamar. **Nuevo**: sin equivalente anterior. La última columna es lo único que tienes que hacer además del cambio de nombre.

### Inicialización y configuración

| Seamless | Unificado | Cambio | Qué hacer |
| - | - | - | - |
| `import com.yuno.sdk.*` | `import com.yuno.payments.sdk.api.*` | Renombrado | |
| `Yuno.initialize(context, apiKey)` | `SdkPayments.initialize(context, apiKey)` | Renombrado | |
| Argumentos `checkoutSession`, `countryCode` de `startCheckout` | Los mismos campos en `TransactionConfig` | Movido | Mismos valores; la configuración también recibe el `controller` (consulta Controlador). |
| Argumento `showPaymentStatus` de `startPaymentSeamlessLite` | `TransactionConfig.showStatusScreen` | Movido | Consulta la nota siguiente. |

> [!NOTE]
>
> **La pantalla de resultado del SDK ahora está desactivada de forma predeterminada.** Establece `showStatusScreen = true` para conservarla.

### Controlador

| Seamless | Unificado | Cambio | Qué hacer |
| - | - | - | - |
| *(sin controlador: una lambda pasada a la llamada de inicio)* | `TransactionController` | Nuevo | Incluso el caso más simple necesita una instancia de controlador: implementa `TransactionController` solo con `onStatus` y pásala como `TransactionConfig.controller`. El SDK no la retiene: mantenla viva durante toda la transacción. |
| `callbackPaymentState: (state, subState) -> Unit` | `onStatus(status: TransactionStatus)` | Movido | El resultado llega a través del controlador en lugar de una lambda pasada a la llamada de inicio. Sigue siendo el único callback de resultado, una vez por transacción, también cuando el SDK muestra su pantalla de resultado. El par sin procesar `(state, subState)` pasa a ser un objeto `TransactionStatus`: `status` y `substatus` provienen del backend, tal como los devuelve. Las cadenas heredadas `REJECT`, `FAIL` y `PROCESSING` ya no se emiten: gestiona `DECLINED`, `REJECTED`, `ERROR` y `PENDING` en su lugar. `CANCELED_BY_USER` ahora es `USER_CANCEL`. El SDK por sí mismo solo emite `INTERNAL_ERROR` y `USER_CANCEL`. Consulta [`Status`](https://docs.y.uno/es/docs/yuno-sdk/reference/objects-you-receive#status). |

### Puntos de entrada

| Seamless | Unificado | Cambio | Qué hacer |
| - | - | - | - |
| `startCheckout(…)` + `startPaymentSeamlessLite(paymentSelected, showPaymentStatus, callbackPaymentState)` | `Transaction(config).start(activity, paymentSelected)` | Renombrado | Construye la configuración y luego llama a `start`: un único punto de entrada, y el resultado llega en `onStatus`. Tú sigues eligiendo el método y pasándolo. Las funciones de extensión de `Activity` pasan a ser una sola llamada sobre una instancia normal de `Transaction`, que no necesita una `Activity` para construirse. |
| `PaymentSelected` | `PaymentMethodSelected` | Renombrado | Mismo rol: el valor que pasas a `start`. |

## Relacionado

* [Primeros pasos](https://docs.y.uno/es/docs/yuno-sdk/get-started.md). La guía de la API unificada; el nuevo "equivalente de Seamless" ahora es la ruta predeterminada.
* [`onStatus`](https://docs.y.uno/es/docs/yuno-sdk/controllers/on-status). Controlador que entrega el estado final.
* [`TransactionConfig`](https://docs.y.uno/es/docs/yuno-sdk/reference/objects-you-pass#transaction-config). Referencia completa de campos.
* [Migración / Lite](https://docs.y.uno/es/docs/yuno-sdk/migration/android/payment/lite.md). Migración casi idéntica; Seamless y Lite se unifican en la misma ruta predeterminada en la API unificada.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.