# Guia de Início Rápido

Este guia fornece o caminho mais rápido para integrar a **redsys-tpv-business-lib** em sua aplicação Android e executar sua primeira operação: a inicialização do TPV.

## Pré-requisitos

Antes de começar, certifique-se de ter o seguinte:

* **Hardware**: Um dispositivo TPV Android físico com o **Get Smart SDK Payment Service** instalado.  
* **Software**: O arquivo ZIP da `redsys-tpv-business-lib` (fornecido pela Getnet).  
* **Ambiente de Desenvolvimento**: Android Studio com suporte ao **Java 21**.

## Passo 1: Adicionar o Repositório Local

O SDK é entregue como um arquivo ZIP contendo uma estrutura de repositório Maven local. Você deve configurar seu projeto para localizar esses arquivos.

1. **Extrair o SDK**: Descompacte o arquivo fornecido em um local seguro em sua máquina de desenvolvimento (ex: `C:\\Users\\MeuUsuario\\RepositorioRedsys`).  
2. **Configurar o `settings.gradle`**: Abra o arquivo `settings.gradle` do seu projeto e adicione o caminho para o repositório local dentro do bloco `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">

Se estiver trabalhando em equipe, considere colocar o repositório em um diretório compartilhado do projeto (ex: `libs/repo`) e usar `rootDir` na URI para evitar conflitos de caminhos absolutos.

</Callout>

## Passo 2: Adicionar a Dependência

Abra o arquivo `build.gradle` do seu módulo de aplicação (geralmente `app/build.gradle`) para configurar a versão do Java e adicionar a dependência da biblioteca.

### 1. Configurar o Java 21

A biblioteca requer o **Java 21**. Certifique-se de que suas opções de compilação estejam configuradas estritamente como segue:

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

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

### 2. Adicionar a Implementação

Adicione a dependência da biblioteca ao bloco `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")
}
```

## Passo 3: Inicializar o TPV

O "Hello World" deste SDK é a **Inicialização**. Você não pode realizar pagamentos ou consultar dados até que o TPV seja inicializado com sucesso. Este processo conecta-se ao Get Smart SDK Payment Service e valida as configurações de segurança.

Para um início rápido, instanciaremos o repositório manualmente, sem Injeção de Dependência.

1. **Criar o Repositório**: Use `PsaInitializationRepository.newInstance()`.  
2. **Chamar `initTpv()`**: Execute em uma thread de segundo plano; o SDK usa funções suspend, então utilize escopos de corrotinas (como `lifecycleScope`) ao chamar a partir de sua Activity ou ViewModel.

### Exemplo de Código

Adicione o seguinte código à sua Activity principal ou ViewModel para testar a conexão:

```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}")
            }
        }
    }
}
```

### Saída Esperada

Se a integração estiver correta e o dispositivo configurado, você verá o bloco `RepositoryResult.Success` ser executado, imprimindo o Nome do Estabelecimento e o ID do Terminal a partir do host da Getnet.

## Resumo

Você concluiu com sucesso:

1. A configuração do repositório Maven local.  
2. A configuração do projeto para usar **Java 21**.  
3. A conexão com o **Get Smart SDK Payment Service** e a inicialização do TPV.

Agora você está pronto para processar pagamentos.

> **Próximo Passo**: Aprenda como configurar o [Setup de Injeção de Dependência](/pt/get-smart/get-smart-sdk/first-steps/dependency-injection-setup) para uma arquitetura pronta para produção, ou pule diretamente para [Inicializar o TPV](/pt/get-smart/get-smart-sdk/integration-guides/payment-operations/initialize-the-tpv).