> ## 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.

# Inscripción en Android

> Inscribe métodos de pago en Android con full-checkout, interfaz prediseñada y configuración de ProGuard

> [!NOTE]
>
> **Esta página documenta un SDK heredado.** ¿Vas a iniciar una nueva integración? Usa el [Yuno SDK](https://docs.y.uno/docs/yuno-sdk/get-started.md). ¿Ya usas un SDK heredado? Sigue la [guía de migración](https://docs.y.uno/docs/yuno-sdk/migration/overview.md).
>
> El nuevo **Yuno SDK** (Web v2.x, iOS v3.x, Android v3.x, React Native v2.x) reemplaza los SDK Full, Lite, Seamless, Render, Headless y Secure Fields con una sola API en todas las plataformas. Los SDK heredados siguen siendo compatibles en paralelo durante la transición y está previsto dejarlos de usar en **2027**. Contacta a tu Account Manager para planificar la migración.

El SDK de Android facilita la implementación de flujos de inscripción para guardar métodos de pago en la cuenta de un cliente.

Incluye la biblioteca en tu proyecto siguiendo los mismos pasos que en [full-checkout](https://docs.y.uno/docs/sdks/full-checkout/android-payments#include-the-library-in-your-project).

## Recursos adicionales

* Consulta [Elige la integración adecuada para ti](https://docs.y.uno/es/docs/sdks/overview/choose-integration.md) si no tienes claro qué flujo seguir.

* Accede a las [Notas de la versión](https://docs.y.uno/changelog/android.md) o al [repositorio del Yuno Android SDK](https://github.com/yuno-payments/yuno-sdk-android) para verificar la última versión disponible del SDK.

* [Inscripción con full-checkout (Android)](#full-checkout-enrollment-android): inscripción automática con componentes de interfaz prediseñados

## Requisitos

* **Versión mínima del SDK**: `minSdkVersion` 23 o superior (Android 6.0). Obligatoria desde Yuno Android SDK 2.24.0
* **Java**: Java 8 habilitado
* **AndroidX**: usa AndroidX en lugar de las bibliotecas de soporte anteriores
* **Android Gradle Plugin**: 4.0.0 o superior
* **ProGuard**: 6.2.2 o superior
* **Kotlin Gradle Plugin**: 1.4.0 o superior
* **Compatibilidad con el tamaño de página ELF**: cumple los requisitos de alineación de página ELF de 16 KB de Google (listo para Android 15 / ARMv9)

### Configuración de ProGuard / R8

Si tu proyecto tiene `minifyEnabled = true`, agrega estas reglas a tu archivo `proguard-rules.pro` para que el SDK funcione correctamente, especialmente con el **modo completo de R8 de AGP 8.x+**.

> [accordion] Reglas oficiales de ProGuard / R8 de Yuno
>
> ```proguard theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> # Preserve generic type signatures and annotations
> -keepattributes Signature
> -keepattributes *Annotation*
>
> # Yuno SDK
> -keep class com.yuno.** { *; }
> -dontwarn com.yuno.**
>
> # Gson — R8 full mode compatibility
> -keep class com.google.gson.** { *; }
> -keep,allowobfuscation,allowshrinking,allowoptimization class * extends com.google.gson.reflect.TypeToken
> -dontwarn com.google.gson.**
>
> # Retrofit — R8 full mode compatibility
> -keep,allowobfuscation,allowshrinking interface retrofit2.Call
> -keep,allowobfuscation,allowshrinking class retrofit2.Response
> -keep,allowobfuscation,allowshrinking class kotlin.coroutines.Continuation
> -dontwarn retrofit2.**
>
> # OkHttp + Okio — Suppress warnings
> -dontwarn okhttp3.**
> -dontwarn okio.**
> ```
>
> ### ¿Por qué son necesarias estas reglas?
>
> AGP 8.x+ habilita por defecto el **modo completo de R8**, que elimina de forma agresiva las firmas de tipos genéricos. Sin `-keepattributes Signature`, el `TypeToken<T>` de Gson puede fallar en tiempo de ejecución con `java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType`.

## Parámetros

Para ver la lista completa de parámetros, consulta la [Referencia común del SDK de Android](https://docs.y.uno/es/docs/sdks/resources/references/android.md).

| Parámetro | Descripción |
| - | - |
| `customerSession` | ID de la sesión de cliente de la API Create customer session. Obligatorio para `apiClientEnroll`. |
| `countryCode` | Código de país ISO. Obligatorio para `apiClientEnroll`. |
| `showEnrollmentStatus` | Muestra la pantalla de resultado de la inscripción. Opcional; por defecto es true. |
| `callbackEnrollmentState` | Callback `(state, message)`: estado de la inscripción y, en `INTERNAL_ERROR`, un [`StatusMessage?`](https://docs.y.uno/es/docs/sdks/resources/references/android#statusmessage-error-details). Opcional; requiere `initEnrollment` en onCreate. Segundo parámetro agregado en el SDK `2.22.0`. |
| `keepLoader` | Si es `true`, el indicador de carga del SDK se mantiene durante la inscripción, lo que evita parpadeos en la interfaz. |

## Inscripción con full-checkout (Android)

Yuno full-checkout para Android ofrece inscripción con interfaz prediseñada, inscripción de tarjetas, gestión de estados y manejo básico de errores. Consulta la sección anterior de [Requisitos](#requirements).

### Paso 1: crea un cliente

Crea un cliente en el sistema de Yuno con el [endpoint Create customer](https://docs.y.uno/reference/customers/create-customer.md) antes de inscribir métodos de pago. Este endpoint devuelve un `customer_id`. Luego crea una sesión de cliente con el endpoint [Create Customer Session](https://docs.y.uno/reference/customer-sessions-enrollment/create-customer-session.md); usa el `customer_session` devuelto al llamar a los métodos de inscripción.

En tu servidor, crea también un [objeto de método de pago de inscripción](https://docs.y.uno/reference/payment-methods-checkout/enroll-payment-method-checkout.md) para esa sesión de cliente, a fin de definir qué método de pago puede inscribir el cliente. Mantén tus claves de API privadas en el servidor.

### Paso 2: incluye la biblioteca en tu proyecto

Agrega la biblioteca de Yuno a tu proyecto de Android:

#### Agrega el repositorio

Agrega el repositorio Maven de Yuno a la configuración de Gradle de tu proyecto:

```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
maven { url "https://yunopayments.jfrog.io/artifactory/snapshots-libs-release" }
```

Agrega la dependencia en `build.gradle`:

```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
dependencies {
    implementation 'com.yuno.payments:android-sdk:2.27.0'
}
```

#### Permisos

El Yuno SDK incluye por defecto el permiso `INTERNET`, necesario para realizar solicitudes de red.

```xml theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
<uses-permission android:name="android.permission.INTERNET" />
```

### Paso 3: inicializa el SDK con la clave pública

Inicializa el SDK:

1. Obtén tu clave de API pública en el [Yuno Dashboard](https://dashboard.y.uno/)
2. Crea una clase de aplicación personalizada si aún no lo has hecho
3. En el método `onCreate()` de tu clase de aplicación, llama a `Yuno.initialize()` con tu clave de API:

```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
class CustomApplication : Application() {
  override fun onCreate() {
    super.onCreate()
    Yuno.initialize(
      this,
      PUBLIC_API_KEY,
      config = YunoConfig(
        keepLoader = true,
      ),
    )
  }
}
```

Usa la data class `YunoConfig` para personalizar el comportamiento del SDK. Incluye esta configuración al llamar a `Yuno.initialize()`. Las opciones disponibles son:

```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
data class YunoConfig(
    val saveCardEnabled: Boolean = false,
    val keepLoader: Boolean = false,
    val language: YunoLanguage? = null,
    val styles: YunoStyles? = null
)
```

> [!NOTE]
>
> Para una explicación detallada del parámetro `keepLoader` y del manejo obligatorio de errores, consulta la [Guía de referencia de Android](https://docs.y.uno/es/docs/sdks/resources/references/android.md#keeploader-parameter).

> [!WARNING]
>
> **cardFlow eliminado de YunoConfig**
>
> A partir de la versión **2.11.0**, `cardFlow` ya no forma parte de `YunoConfig`. La configuración del flujo de tarjeta ahora se gestiona exclusivamente a través del **CheckoutBuilder**.

### Paso 4: inscribe un nuevo método de pago

El proceso de inscripción es un flujo de dos pasos. Primero, inicializa el proceso para configurar los componentes necesarios. Luego, inicia el flujo de interfaz para que el usuario inscriba un método de pago.

#### 4.1 Inicializa el proceso de inscripción

Llama al método `initEnrollment` dentro del método `onCreate` de tu activity para preparar tu app y que pueda gestionar el flujo de inscripción. Este es un paso de configuración obligatorio que exige el sistema operativo Android para registrar el contrato que permite al SDK devolver a tu app el estado final de la inscripción.

```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
fun ComponentActivity.initEnrollment(
    callbackEnrollmentState: ((String?, StatusMessage?) -> Unit)? = null
)
```

#### 4.2 Inicia el flujo de inscripción

Llama al método `startEnrollment` para lanzar la interfaz de usuario y comenzar la inscripción de un nuevo método de pago. Puedes llamar a este método en cualquier momento después de ejecutar `initEnrollment`, por ejemplo, cuando un usuario toca un botón "Enroll New Payment Method".

```kotlin theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
fun Context.startEnrollment(
    customerSession: String,
    countryCode: String,
    showEnrollmentStatus: Boolean = true,
    callbackEnrollmentState: ((String?, StatusMessage?) -> Unit)? = null
)
```

Parámetros de `startEnrollment`:

| Parámetro | Descripción |
| - | - |
| `customerSession` | La sesión de cliente asociada al proceso de inscripción actual. |
| `countryCode` | Código del país donde se realiza el pago. Consulta [Cobertura por país](https://docs.y.uno/es/docs/sdks/resources/country-coverage.md) para ver la lista completa de países compatibles y sus códigos. |
| `showEnrollmentStatus` | Indica si se debe mostrar el estado de la inscripción. Este parámetro es opcional y por defecto es `true`. |
| `callbackEnrollmentState` | Una función `(state, message)` que devuelve el estado actual del proceso de inscripción y, en `INTERNAL_ERROR`, un [`StatusMessage?`](https://docs.y.uno/es/docs/sdks/resources/references/android#statusmessage-error-details) que describe el fallo (las inscripciones rechazadas no incluyen mensaje). Opcional, por defecto es `null`. Para registrar este callback, debes llamar a `initEnrollment` en el método `onCreate` de la activity. Revisa los posibles estados que se pueden devolver. |

## Referencia común

Para ver todos los detalles de parámetros y personalización, consulta la [Referencia común del SDK de Android](https://docs.y.uno/es/docs/sdks/resources/references/android.md).


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