# Inicializar o TPV

A inicialização é o primeiro passo obrigatório no ciclo de vida da integração. Você deve inicializar o TPV com sucesso antes de realizar qualquer operação financeira (como pagamentos ou estornos) ou consultar dados de transações.

Durante a inicialização, a biblioteca se conecta ao Get Smart SDK Payment Service para:

1. **Verificar a Configuração**: Garante que o terminal esteja configurado corretamente no host da Getnet.
2. **Checagens de Segurança**: Valida chaves e protocolos de segurança.
3. **Atualizar Parâmetros**: Baixa a configuração mais recente (ex: recursos ativos, moeda, detalhes do estabelecimento) a partir do host.

## Realizando a Inicialização

Para inicializar o dispositivo, use o `InitializationRepository`.

O método principal é o `initTpv()`. Esta é uma função `suspend` que retorna um `RepositoryResult` contendo o objeto `TpvInfo` em caso de sucesso.

### Implementação

Chame o `initTpv()` dentro de um escopo de corrotina. Note como acessamos os dados do estabelecimento através da `virtualTerminalList`.

```kotlin
suspend fun initializeDevice() {
    // 1. Call the initialization method
    val result = initializationRepository.initTpv()

    // 2. Handle the result
    when (result) {
        is RepositoryResult.Success -> {
            // Initialization successful
            val tpvInfo: TpvInfo = result.data

            // Accessing Configuration Flags
            val isPreauthEnabled = tpvInfo.config.showPreauthorizations
            val isQrEnabled = tpvInfo.config.showQrPayment

            // Accessing Merchant Data (FUC, Terminal, Name)
            // These are stored in the virtual terminal list
            val terminalData = tpvInfo.virtualTerminalList?.firstOrNull()

            println("Initialized Merchant: ${terminalData?.merchantName}")
            println("Terminal ID: ${terminalData?.terminal}")
            println("Currency Code: ${terminalData?.currency}")

            // You can now proceed to payment screens
        }
        is RepositoryResult.ConnectionError -> {
            // Handle network/service failure
            showError("Connection failed. Check internet or Smart SDK Service.")
        }
        is RepositoryResult.ProtocolError -> {
            // Handle logical errors (e.g., TPV_NOT_INITIALIZED or MAPPING errors)
            showError("Protocol Error: ${result.type}")
        }
        is RepositoryResult.Cancelled -> {
            // Handle cancellation (unlikely for initialization, but possible)
        }
    }
}
```

## Entendendo o TpvInfo

Quando a inicialização tem sucesso, você recebe um objeto `TpvInfo`. Esta data class contém detalhes cruciais sobre a identidade e as capacidades do terminal.

### Propriedades Principais

O objeto é estruturado em três partes principais:

* **`deviceInfo`**: Dados específicos do hardware/terminal.
* **`config`** (`TpvConfig`): Flags operacionais e configurações de recursos.
    * `showPreauthorizations`: (`Boolean`) Se as Pré-autorizações estão habilitadas.
    * `noOriginal`: (`Boolean`) Se "Estornos sem Original" são permitidos.
    * `showQrPayment`: (`Boolean`) Se pagamentos via QR (Alipay/WeChat) estão habilitados.
    * `showPlazox`: (`Boolean`) Se o Plazox (pagamentos parcelados) está habilitado.
    * `isOffline`: (`Boolean`) Se o TPV está operando atualmente em modo offline.
* **`virtualTerminalList`**: Uma lista de objetos `TpvVirtualTerminal` contendo a identidade financeira.
    * `merchantName`: O nome comercial do estabelecimento.
    * `fuc`: O ID do Estabelecimento (FUC).
    * `terminal`: O Número do Terminal.
    * `currency`: O código da moeda configurada (ex: 978 para EUR).
    * `csb` / `csbType`: Códigos bancários.

## Gerenciando Informações do Terminal

O `InitializationRepository` fornece métodos adicionais para recuperar ou atualizar as informações armazenadas do terminal sem disparar uma sincronização completa com o host.

### Recuperando Informações em Cache

Se você precisar acessar a configuração do terminal mais tarde em seu app (ex: para exibir o Nome do Estabelecimento em um cabeçalho) sem fazer uma chamada de rede, use `getTpvInfoRepositoryResult()`.

```kotlin
suspend fun getCachedConfig() {
    val result = initializationRepository.getTpvInfoRepositoryResult()

    if (result is RepositoryResult.Success) {
        val cachedInfo = result.data
        // Use cached data...
    }
}
```

### Salvando Informações do Terminal

Em cenários avançados onde você precisa atualizar manualmente o contexto das informações locais do terminal, você pode usar `saveTerminalInformation()`.

```kotlin
suspend fun updateLocalConfig(newInfo: TpvInfo) {
    initializationRepository.saveTerminalInformation(newInfo)
}
```

---

## Próximos Passos

Com o TPV inicializado com sucesso, você está pronto para processar transações:

* [**Criar um Pagamento Pré-autorizado**](/pt/get-smart/get-smart-sdk/integration-guides/payment-operations/create-a-pre-authorized-payment): Saiba como processar uma transação de pré-autorização.
* [**Criar um Pagamento de Etapa Única**](): Saiba como realizar pagamentos simples.
* [**Criar um Pagamento com Parcelamento (Plazox)**](/pt/get-smart/get-smart-sdk/integration-guides/payment-operations/create-a-payment-with-installments-plazox): Saiba como realizar pagamentos parcelados.
* [**Estornar um Pagamento**](/pt/get-smart/get-smart-sdk/integration-guides/payment-operations/refund-a-payment): Fluxos específicos para devolução de fundos.