# Tratar Resultados de Transação

Este guia explica como capturar e processar os resultados de uma transação de pagamento ou estorno iniciada pela sua aplicação.

Após lançar o intent de pagamento usando `startActivityForResult`, a aplicação Get Smart processa a transação. Após a conclusão (ou cancelamento), ela devolve o controle à sua aplicação através do callback padrão do Android `onActivityResult`. Você deve implementar este método para determinar se a transação foi bem-sucedida e para extrair os dados financeiros relevantes.

## Entendendo os Códigos de Resultado

O resultado da transação envolve dois níveis de verificação de status:

1. **Código de Resultado Android**: Indica se o app Get Smart concluiu seu fluxo  
2. **Resultado da Transação**: Indica se o pagamento foi autorizado

## Passo 1: Implementar onActivityResult

Sobrescreva o método `onActivityResult` em sua Activity. Você precisa verificar duas coisas:

1. Garantir que o resultado corresponda ao código de requisição que você definiu ao iniciar o intent  
2. Verificar o código de resultado padrão do Android para ver se a operação foi concluída ou cancelada

```java
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    if (requestCode == REQUEST_CODE_PAYMENT) {
        if (resultCode == RESULT_OK) {
            // The flow completed. Check if the payment was authorized.
            processTransactionResponse(data);
        } else if (resultCode == RESULT_CANCELED) {
            // The user canceled the operation
            handleCancellation();
        }
    }
}
```

### Códigos de Resultado Android

| Código de Resultado | Significado |
|------------|---------|
| `RESULT_OK` | O app Get Smart concluiu seu fluxo e retornou um resultado (que pode ser autorização ou denegação) |
| `RESULT_CANCELED` | O usuário cancelou a operação ou o sistema a abortou |

<Callout type="warning">

`RESULT_OK` **não** significa que o pagamento foi autorizado. Significa apenas que o app Get Smart concluiu seu processo sem erros ou cancelamentos. Você deve analisar os extras para verificar o status financeiro.

</Callout>

## Passo 2: Analisar a Resposta da Transação

Se o `resultCode` for `RESULT_OK`, o objeto `Intent data` contém "extras" com os detalhes da transação. Você precisa extrair esses valores para determinar o status final.

### Verificar Status de Autorização

O campo mais crítico é `RESULT`, que informa se o banco autorizou a transação:

```java
private void processTransactionResponse(Intent data) {
    if (data == null) {
        Log.e("Payment", "No data returned from payment app");
        return;
    }

    // Extract the main status
    String operationResult = data.getStringExtra("RESULT");

    if ("AUTORIZADA".equals(operationResult)) {
        // Payment was authorized
        handleAuthorizedTransaction(data);
    } else if ("DENEGADA".equals(operationResult)) {
        // Payment was denied
        handleDeniedTransaction(data);
    } else {
        // Unexpected result
        Log.e("Payment", "Unexpected result: " + operationResult);
    }
}
```

### Valores de Resultado da Transação

| Valor | Significado |
|-------|---------|
| `"AUTORIZADA"` | O pagamento foi autorizado com sucesso |
| `"DENEGADA"` | O pagamento foi negado ou falhou |

## Passo 3: Tratar Transações Autorizadas

Quando uma transação é autorizada, extraia os detalhes relevantes para seus registros:

```java
private void handleAuthorizedTransaction(Intent data) {
    // Extract authorization details
    String authNumber = data.getStringExtra("AUTORIZATION_NUMBER");
    String orderNumber = data.getStringExtra("ORDER");
    String cardBrand = data.getStringExtra("CARDBRAND");
    String transactionId = data.getStringExtra("IDENTIFIER_RTS");

    // Log success
    Log.i("Payment", "Payment authorized!");
    Log.i("Payment", "Authorization: " + authNumber);
    Log.i("Payment", "Order: " + orderNumber);
    Log.i("Payment", "Card: " + cardBrand);

    // Update your business logic
    saveSuccessfulTransaction(orderNumber, authNumber, transactionId);
    updateOrderStatus(orderNumber, "PAID");

    // Notify the user
    showSuccessMessage("Payment successful! Authorization: " + authNumber);
}
```

> **Nota de Grafia**: O campo do número de autorização é grafado como `"AUTORIZATION_NUMBER"` (sem o 'H'). Você deve usar esta string exata como chave.

## Passo 4: Tratar Transações Negadas

Quando uma transação é negada, extraia os detalhes do erro para entender o motivo:

```java
private void handleDeniedTransaction(Intent data) {
    // Extract denial details
    int respCode = data.getIntExtra("RESPCODE", -1);
    String errorMsg = data.getStringExtra("ERROR_MSG");

    // Log the denial
    Log.w("Payment", "Payment denied");
    Log.w("Payment", "Response code: " + respCode);
    Log.w("Payment", "Error: " + errorMsg);

    // Update your business logic
    logFailedTransaction(respCode, errorMsg);

    // Notify the user
    showErrorMessage("Payment declined: " + errorMsg);
}
```

## Passo 5: Tratar Cancelamentos

Quando o usuário cancela a transação:

```java
private void handleCancellation() {
    Log.i("Payment", "Transaction cancelled by user");

    // Update your business logic
    logCancelledTransaction();

    // Notify the user
    showInfoMessage("Transaction cancelled");
}
```

## Exemplo Completo

Aqui está uma implementação completa:

```java
public class PaymentActivity extends AppCompatActivity {
    private static final int REQUEST_CODE_PAYMENT = 1001;

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if (requestCode == REQUEST_CODE_PAYMENT) {
            if (resultCode == RESULT_OK) {
                processTransactionResponse(data);
            } else if (resultCode == RESULT_CANCELED) {
                handleCancellation();
            }
        }
    }

    private void processTransactionResponse(Intent data) {
        if (data == null) return;

        String result = data.getStringExtra("RESULT");

        if ("AUTORIZADA".equals(result)) {
            // Success
            String authNumber = data.getStringExtra("AUTORIZATION_NUMBER");
            String orderNumber = data.getStringExtra("ORDER");
            String cardBrand = data.getStringExtra("CARDBRAND");
            String transactionId = data.getStringExtra("IDENTIFIER_RTS");

            Toast.makeText(this,
                "Payment approved! Auth: " + authNumber,
                Toast.LENGTH_LONG).show();

            // Save to your system
            saveTransaction(orderNumber, authNumber, transactionId, cardBrand);

        } else {
            // Denied
            int respCode = data.getIntExtra("RESPCODE", -1);
            String errorMsg = data.getStringExtra("ERROR_MSG");

            Toast.makeText(this,
                "Payment denied: " + errorMsg,
                Toast.LENGTH_LONG).show();

            // Log the failure
            logFailure(respCode, errorMsg);
        }
    }

    private void handleCancellation() {
        Toast.makeText(this,
            "Transaction cancelled",
            Toast.LENGTH_SHORT).show();
    }
}
```

## Campos de Resposta Disponíveis

O Intent de resposta contém os seguintes extras:

| Campo | Tipo | Descrição |
|-------|------|-------------|
| `RESULT` | String | `"AUTORIZADA"` ou `"DENEGADA"` |
| `AUTORIZATION_NUMBER` | String | Código de autorização para transações bem-sucedidas |
| `ORDER` | String | Número do pedido para a transação |
| `CARDBRAND` | String | Bandeira do cartão utilizado (VISA, MASTERCARD, etc.) |
| `IDENTIFIER_RTS` | String | Identificador exclusivo da transação |
| `RESPCODE` | int | Código de resposta para denegações/erros |
| `ERROR_MSG` | String | Descrição do erro legível para humanos |

Para detalhes completos, consulte [Referência de Parâmetros de Resposta](https://docs.globalgetnet.com/pt/products/local-processor-spain/get-smart-app2app?doc=getsmart-app2app-response-api-reference).

## Impressão de Comprovante

Você não precisa escrever código para lidar com a impressão de comprovantes:

* Se aplicável, a aplicação financeira Get Smart lida automaticamente com a impressão da via do estabelecimento  
* A aplicação Get Smart fornece as opções de interface de usuário para imprimir a via do cliente

Sua aplicação simplesmente aguarda o callback `onActivityResult`, que ocorre após todos os fluxos de impressão terem sido processados pelo app Get Smart.

## Notificações no Terminal

O terminal exibirá automaticamente alertas na tela do dispositivo dependendo do resultado da transação (autorizada, negada, erro, etc.). Sua aplicação também deve tratar esses desfechos programaticamente com base nos dados retornados no `Intent` para sua própria interface e lógica de negócio.

## Melhores Práticas

* **Sempre Verifique Nulidade**: Verifique se o Intent `data` não é nulo antes de extrair os extras  
* **Salve os Detalhes da Transação**: Armazene o número de autorização, número do pedido e ID da transação para conciliação  
* **Trate Todos os Casos**: Implemente manipuladores para transações autorizadas, negadas e canceladas  
* **Use Valores Padrão**: Ao extrair valores inteiros, forneça um padrão (ex: `getIntExtra("RESPCODE", -1)`)  
* **Registre Logs Apropriadamente**: Registre transações autorizadas como INFO, denegações como WARN e erros como ERROR  
* **Feedback ao Usuário**: Sempre informe o usuário sobre o desfecho da transação  
* **Persista o Estado**: Salve os resultados da transação em armazenamento persistente, não apenas na memória

## Considerações sobre o Ciclo de Vida da Activity

Enquanto o app Get Smart está processando a transação, sua Activity pode ser pausada ou até mesmo destruída pelo sistema. Certifique-se de que sua Activity possa lidar com a recriação:

* Salve o estado da transação em `onSaveInstanceState`  
* Restaure o estado em `onCreate` ou `onRestoreInstanceState`  
* Considere usar `ViewModel` ou armazenamento persistente para dados críticos da transação

## Próximos Passos

* Revise os códigos de resposta em [Referência de Códigos de Resultado e Erros](/pt/get-smart/get-smart-app2app/reference/result-codes-and-errors)  
* Veja todos os campos de resposta em [Referência de Parâmetros de Resposta](https://docs.globalgetnet.com/pt/products/local-processor-spain/get-smart-app2app?doc=getsmart-app2app-response-api-reference)  
* Saiba como criar um pagamento de etapa única em [Criar um Pagamento de Etapa Única](/pt/get-smart/get-smart-app2app/transaction-guides/transactions/create-a-single-step-payment)