# Crear un pago preautorizado

La preautorización te permite verificar la validez de la tarjeta y reservar un importe específico en la cuenta del titular de la tarjeta sin capturar los fondos inmediatamente. Este es un requisito común para hoteles, alquileres de automóviles y otros proveedores de servicios donde el importe final se liquida más tarde.

## Requisitos

Antes de comenzar el flujo de preautorización, asegúrate de:
1.  El SDK está inicializado y el comercio ha iniciado sesión.
2.  El PIN pad está conectado y en estado "Listo".
3.  Tu aplicación debe persistir los campos clave (como `identifierRTS`, `order`, etc.) devueltos después de la preautorización, ya que son necesarios para la confirmación o anulación.

---

## Paso 1: Crear la preautorización

El proceso de preautorización es idéntico a una venta estándar pero con un tipo de operación diferente. El cliente debe presentar su tarjeta e ingresar su PIN si se le solicita.

```kotlin
import redcls.itpvpc.data.RedCLSOperativeWithCardData
import redcls.itpvpc.constants.RedCLSiTPVPCGeneration

// 1. Preparar los datos
val amount = "100.00"
val preAuthData = RedCLSOperativeWithCardData(amount)

// 2. Establecer el tipo de operación a PREAUTORIZACIÓN
preAuthData.setTipoPago(RedCLSiTPVPCGeneration.TIPO_OPERACION_PREAUTORIZACION)
preAuthData.setOpcionAutorizacionParcial(true) // Requerido para ciertos MCCs (actualización de junio de 2024)

// 3. Ejecutar la operación (debe estar en un hilo en segundo plano)
Thread {
    val response = pinpadManager.operativaConTarjeta(preAuthData)

    if (response.status == 0) {
        val txData = response.transactionData
        if (txData.result == "Autorizada") {
            // CRÍTICO: Persiste al menos los siguientes campos:
            // identifierRTS, order, FUC, terminal, operationDate, amount
            // Si corresponde, guarda también txData.amountPartialAuthorized
            savePreAuthFields(txData)
            Log.d("GetMini", "Preautorización aprobada: ${txData.autorizationNumber}")
        } else {
            Log.w("GetMini", "Preautorización denegada: ${txData.responseCode}")
        }
    } else {
        Log.e("GetMini", "Error del SDK: ${response.status} - ${response.msgKO}")
    }
}.start()
```

---

## Paso 2: Confirmar la preautorización

Una vez que se conoce el importe final, "confirma" la preautorización para capturar los fondos. Este paso **no** requiere que la tarjeta física esté presente.

Debes usar el `RedCLSPreautorizationManager` (proporcionado por el Get Mini Android SDK) y proporcionar el `RedCLSTransactionData` de la preautorización original.

```kotlin
import redcls.itpvpc.managers.RedCLSPreautorizationManager
import redcls.itpvpc.data.RedCLSConfirmationData

// 1. Preparar los datos de confirmación usando la información de transacción guardada
val isPartialAuth = savedTransactionData.amountPartialAuthorized != null
val confirmationData = RedCLSConfirmationData(terminalData, savedTransactionData, isPartialAuth)

// Opcional: Puedes especificar un importe diferente (menor) si es necesario
// savedTransactionData.amount = "85.50"

Thread {
    val confirmResponse = RedCLSPreautorizationManager.peticionConfirmacion(context, confirmationData)

    if (confirmResponse.status == 0) {
        Log.i("GetMini", "Fondos capturados exitosamente")
    } else {
        Log.e("GetMini", "Confirmación fallida: ${confirmResponse.msgKO}")
    }
}.start()
```

<Callout type="note">

El importe de confirmación puede ser menor o igual al importe preautorizado. Si el comercio tiene un MCC sujeto a la actualización de junio de 2024 (por ejemplo, taxis, suministros, supermercados, gasolineras, restaurantes, farmacias, entre otros) y estableció `opcionAutorizacionParcial(true)`, el importe de confirmación no debe superar `amountPartialAuthorized` en lugar del importe total preautorizado. Si confirmas por un importe menor, los fondos restantes se liberan de vuelta a la cuenta del titular de la tarjeta.

</Callout>

---

## Paso 3: Anular o reemplazar (opcional)

Si el servicio se cancela o necesitas actualizar el importe de la preautorización, puedes usar los siguientes métodos:

### Anulación
Libera los fondos reservados inmediatamente.

```kotlin
val cancelResponse = RedCLSPreautorizationManager.peticionAnulacionPreautorizacion(
    terminalData,
    savedTransactionData
)
```

### Reemplazo
Actualiza el importe reservado mientras mantiene la preautorización original.

```kotlin
val newAmount = "150.00"
val replaceResponse = RedCLSPreautorizationManager.peticionReemplazoPreautorizacion(
    newAmount,
    terminalData,
    savedTransactionData
)
```

---

## Mejores prácticas

- **Persistir Campos Clave**: No confíes en guardar el objeto completo del SDK. Persiste al menos:
    - `identifierRTS`
    - `order`
    - `FUC` / `terminal`
    - `operationDate` / `amount`
- **Expiración**: Las preautorizaciones típicamente tienen una vida útil limitada (a menudo 7 días) antes de que la reserva sea liberada automáticamente por el emisor.

## Próximos pasos

* [Crear una venta](/es/get-mini/android-sdk/guides/process-single-step-payments): Transacciones de venta estándar.
* [Devolver un pago](/es/get-mini/android-sdk/guides/refund-payment): Devolver fondos después de la captura.
* [Ciclo de vida de la transacción](/es/get-mini/android-sdk/core-concepts/transaction-lifecycle): Vista detallada de los estados de transacción.