# Gestión de resultados de la transacción

Esta guía explica cómo capturar y procesar los resultados de una transacción de pago o devolución iniciada por tu aplicación.

Después de lanzar el intent de pago mediante `startActivityForResult`, la aplicación Get Smart procesa la transacción. Al finalizar (o cancelarse), devuelve el control a tu aplicación a través del callback estándar de Android `onActivityResult`. Debes implementar este método para determinar si la transacción ha sido exitosa y para extraer los datos financieros pertinentes.

## Comprender los códigos de resultado

El resultado de la transacción implica dos niveles de comprobación de estado:

1. **Código de resultado de Android**: Indica si la aplicación Get Smart completó su flujo  
2. **Resultado de la transacción**: Indica si el pago fue autorizado

## Paso 1: Implementar onActivityResult

Sobrescribe el método `onActivityResult` en tu Activity. Debes verificar dos aspectos:

1. Asegurarse de que el resultado coincide con el código de petición que definiste al iniciar el intent  
2. Comprobar el código de resultado estándar de Android para ver si la operación terminó o fue 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 de Android

| Código de resultado | Significado |
|------------|---------|
| `RESULT_OK` | La aplicación Get Smart completó su flujo y devolvió un resultado (que podría ser autorización o denegación) |
| `RESULT_CANCELED` | El usuario canceló la operación o el sistema la abortó |

<Callout type="warning">

`RESULT_OK` **no** significa que el pago haya sido autorizado. Solo significa que la aplicación Get Smart completó su proceso sin errores ni cancelaciones. Debes analizar los extras para verificar el estado financiero.

</Callout>

## Paso 2: Analizar la respuesta de la transacción

Si el `resultCode` es `RESULT_OK`, el objeto `Intent data` contiene "extras" con los detalles de la transacción. Debes extraer estos valores para determinar el estado final.

### Comprobar el estado de autorización

El campo más crítico es `RESULT`, que te indica si el banco autorizó la transacción:

```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 del resultado de la transacción

| Valor | Significado |
|-------|---------|
| `"AUTORIZADA"` | El pago fue autorizado con éxito |
| `"DENEGADA"` | El pago fue denegado o falló |

## Paso 3: Gestión de transacciones autorizadas

Cuando se autoriza una transacción, extrae los detalles pertinentes para tus 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 ortográfica**: El campo del número de autorización se escribe `"AUTORIZATION_NUMBER"` (sin la 'H'). Debes utilizar exactamente esta cadena como clave.

## Paso 4: Gestión de transacciones denegadas

Cuando se deniega una transacción, extrae los detalles del error para comprender el 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);
}
```

## Paso 5: Gestión de cancelaciones

Cuando el usuario cancela la transacción:

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

    // Update your business logic
    logCancelledTransaction();

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

## Ejemplo completo

Aquí tienes una implementación 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 respuesta disponibles

El Intent de respuesta contiene los siguientes extras:

| Campo | Tipo | Descripción |
|-------|------|-------------|
| `RESULT` | String | `"AUTORIZADA"` o `"DENEGADA"` |
| `AUTORIZATION_NUMBER` | String | Código de autorización para transacciones exitosas |
| `ORDER` | String | Número de pedido de la operación |
| `CARDBRAND` | String | Marca de la tarjeta utilizada (VISA, MASTERCARD, etc.) |
| `IDENTIFIER_RTS` | String | Identificador único de la transacción |
| `RESPCODE` | int | Código de respuesta para denegaciones/errores |
| `ERROR_MSG` | String | Descripción del error legible para humanos |

Para obtener detalles completos, consulta [Referencia de Parámetros de Respuesta](https://docs.globalgetnet.com/es/products/local-processor-spain/get-smart-app2app?doc=getsmart-app2app-response-api-reference).

## Impresión de boletas

No es necesario escribir código para gestionar la impresión de boletas:

* Si procede, la aplicación financiera Get Smart gestiona automáticamente la impresión de la copia del comercio  
* La aplicación Get Smart proporciona las opciones de interfaz de usuario para imprimir la boleta del cliente

Tu aplicación espera al callback `onActivityResult`, que se produce después de que todos los flujos de impresión hayan sido gestionados por la aplicación Get Smart.

## Notificaciones en el terminal

El terminal mostrará automáticamente alertas en la pantalla del dispositivo dependiendo del resultado de la transacción (autorizada, denegada, error, etc.). Tu aplicación también debe gestionar estos resultados de forma programática basándose en los datos devueltos en el `Intent` para tu propia interfaz de usuario y lógica de negocio.

## Buenas prácticas

* **Comprueba siempre los nulos**: Verifica que el Intent `data` no es nulo antes de extraer los extras  
* **Guarda los detalles de la transacción**: Almacena el número de autorización, el número de pedido y el ID de la transacción para la conciliación  
* **Gestiona todos los casos**: Implementa controladores para transacciones autorizadas, denegadas y canceladas  
* **Utiliza valores predeterminados**: Al extraer valores enteros, proporciona uno predeterminado (p. ej., `getIntExtra("RESPCODE", -1)`)  
* **Registra los logs adecuadamente**: Registra las transacciones autorizadas como INFO, las denegaciones como WARN y los errores como ERROR  
* **Información al usuario**: Informa siempre al usuario del resultado de la transacción  
* **Persiste el estado**: Guarda los resultados de la transacción en un almacenamiento persistente, no solo en memoria

## Consideraciones sobre el ciclo de vida de la Activity

Mientras la aplicación Get Smart está procesando la transacción, tu Activity puede ser pausada o incluso destruida por el sistema. Asegúrate de que tu Activity pueda gestionar la recreación:

* Guarda el estado de la transacción en `onSaveInstanceState`  
* Restaura el estado en `onCreate` o `onRestoreInstanceState`  
* Considera el uso de `ViewModel` o almacenamiento persistente para los datos críticos de la transacción

## Próximos pasos

* Revisa los códigos de respuesta en la [Referencia de códigos de resultado y errores](/es/get-smart/get-smart-app2app/reference/result-codes-and-errors)  
* Consulta todos los campos de respuesta en la [Referencia de parámetros de respuesta](https://docs.globalgetnet.com/es/products/local-processor-spain/get-smart-app2app?doc=getsmart-app2app-response-api-reference)  
* Aprende a crear un pago en [Crear un pago](/es/get-smart/get-smart-app2app/transaction-guides/transactions/create-a-single-step-payment)