# Guía de inicio rápido

Esta guía proporciona el camino más rápido para integrar la **redsys-tpv-business-lib** en tu aplicación Android y ejecutar tu primera operación: la inicialización del TPV.

## Prerrequisitos

Antes de comenzar, asegúrate de tener lo siguiente:

* **Hardware**: Un dispositivo TPV Android físico con el **Get Smart SDK Payment Service** instalado.  
* **Software**: El archivo ZIP de la `redsys-tpv-business-lib` (proporcionado por Getnet).  
* **Entorno de Desarrollo**: Android Studio con soporte para **Java 21**.

## Paso 1: Añadir el repositorio local

El SDK se entrega como un archivo ZIP que contiene una estructura de repositorio Maven local. Debes configurar tu proyecto para localizar estos archivos.

1. **Extraer el SDK**: Descomprime el archivo proporcionado en una ubicación segura de tu máquina de desarrollo (p. ej., `C:\\Users\\MiUsuario\\RepositorioRedsys`).  
2. **Configurar `settings.gradle`**: Abre el archivo `settings.gradle` de tu proyecto y añade la ruta al repositorio local dentro del bloque `dependencyResolutionManagement`.

```java
dependencyResolutionManagement {
    repositories {
        maven {
            // Point to the location where you unzipped the SDK
            url = uri("C:\\Users\\MyUser\\RedsysRepository")
        }
        google()
        mavenCentral()
    }
}
```

<Callout type="tip">

Si trabajas en equipo, considera colocar el repositorio en un directorio compartido del proyecto (p. ej., `libs/repo`) y usar `rootDir` en la URI para evitar conflictos de rutas absolutas.

</Callout>

## Paso 2: Añadir la dependencia

Abre el archivo `build.gradle` de tu módulo de aplicación (normalmente `app/build.gradle`) para configurar la versión de Java y añadir la dependencia de la biblioteca.

### 1. Configurar Java 21

La biblioteca requiere **Java 21**. Asegúrate de que tus opciones de compilación estén configuradas estrictamente de la siguiente manera:

```java
android {
    // ... existing config ...

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_21
        targetCompatibility = JavaVersion.VERSION_21
    }
}
```

### 2. Añadir la implementación

Añade la dependencia de la biblioteca al bloque `dependencies`. 

```java
dependencies {
    // Replace '1.3.2' with the specific version from your delivery
    implementation("es.redsys.adquirencia.tpva.service:redsys-tpv-business-lib:1.3.2")
}
```

## Paso 3: Inicializar el TPV

El "Hello World" de este SDK es la **Inicialización**. No puedes realizar pagos ni consultar datos hasta que el TPV se inicialice correctamente. Este proceso se conecta al Get Smart SDK Payment Service y valida las configuraciones de seguridad.

Para un inicio rápido, instanciaremos el repositorio manualmente, sin Inyección de Dependencias.

1. **Crear el Repositorio**: Usa `PsaInitializationRepository.newInstance()`.  
2. **Llamar a `initTpv()`**: Ejecútalo en un hilo de fondo; el SDK utiliza funciones suspend, así que usa alcances de corrutinas (como `lifecycleScope`) al llamar desde tu Activity o ViewModel.

### Ejemplo de código

Añade el siguiente código a tu Activity principal o ViewModel para probar la conexión:

```kotlin
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch
// Note: Verify the exact package for PsaInitializationRepository in the Javadoc provided with the ZIP
import es.redsys.adquirencia.tpva.service.api.PsaInitializationRepository
import es.redsys.adquirencia.tpva.service.model.RepositoryResult

// ... inside your Activity or ViewModel

fun performQuickStart() {
    lifecycleScope.launch {
        // 1. Manually instantiate the repository (Quickest way for testing)
        // Ideally, pass the Application Context
        val initializationRepository = PsaInitializationRepository.newInstance(context = this@MainActivity)

        // 2. Execute Initialization
        println("Starting TPV Initialization...")
        val result = initializationRepository.initTpv()

        // 3. Handle the Result
        when (result) {
            is RepositoryResult.Success -> {
                val tpvInfo = result.data
                println("✅ TPV Initialized Successfully!")

                // Accessing configuration flags
                println("Preauth Enabled: ${tpvInfo.config.showPreauthorizations}")

                // Accessing Merchant Data from the Virtual Terminal List
                val terminalData = tpvInfo.virtualTerminalList?.firstOrNull()
                println("Merchant Name: ${terminalData?.merchantName}")
                println("Terminal ID: ${terminalData?.terminal}")
            }
            is RepositoryResult.ConnectionError -> {
                println("❌ Connection Error: Ensure Smart SDK Payment Service is running.")
            }
            is RepositoryResult.ProtocolError -> {
                println("❌ Protocol Error: ${result.type} - ${result.description}")
            }
            is RepositoryResult.Cancelled -> {
                println("⚠️ Operation Cancelled: ${result.message}")
            }
        }
    }
}
```

### Salida esperada

Si la integración es correcta y el dispositivo está configurado, verás que se ejecuta la rama `RepositoryResult.Success`, imprimiendo el Nombre del Comercio y el ID del Terminal desde el host de Getnet.

## Resumen

Has completado con éxito:

1. La configuración del repositorio Maven local.  
2. La configuración del proyecto para usar **Java 21**.  
3. La conexión con el **Get Smart SDK Payment Service** y la inicialización del TPV.

Ahora estás listo para procesar pagos.

> **Siguiente Paso**: Aprende cómo configurar el [Ajuste de Inyección de Dependencias](/es/get-smart/get-smart-sdk/first-steps/dependency-injection-setup) para una arquitectura lista para producción, o salte directamente a [Inicializar el TPV](/es/get-smart/get-smart-sdk/integration-guides/payment-operations/initialize-the-tpv).