Inicio rápido

En esta guía práctica integras tu aplicación Android con la aplicación de pago de Getnet mediante Deeplink. Al final de este tutorial, habrás enviado un comando de pago y procesado la respuesta de la transacción.

Antes de comenzar

Antes de seguir los pasos, asegúrate de cumplir estos requisitos.

Debes entender qué es una llamada de Polling (getnet://payment/v1/polling). Sirve para verificar que la Getnet Payment App está conectada y lista para recibir comandos. Haz esta verificación antes de iniciar una transacción.
Conocimientos básicos de Intents de Android y onActivityResult.

Paso 1: Valida la conexión del terminal (polling)

Antes de iniciar un pago, la buena práctica es ejecutar una operación de Polling. Esta solicitud no financiera verifica que la Getnet Payment App está conectada y lista para procesar transacciones.

Para hacer esta verificación, lanza un Intent con el siguiente URI:

URI de Polling: getnet://payment/v1/polling

Este es un ejemplo de implementación:

val POLLING_REQUEST_CODE = 2001
val intent = Intent(Intent.ACTION_VIEW, Uri.parse("getnet://payment/v1/polling"))
startActivityForResult(intent, POLLING_REQUEST_CODE)

Polling no requiere parámetros. Envía el deeplink y el terminal responde con su estado actual.

La app de Getnet devuelve los siguientes parámetros:

Parámetro	Tipo	Descripción
`result`	String	Resultado de la operación: `"0"` indica éxito (terminal listo).
`resultDetails`	String	Mensaje detallado sobre el estado del terminal.

Si result es "0", puedes continuar con el pago.

Paso 2: Inicializa la transacción de pago

Te comunicas con la app mediante un Intent con un URI específico. En este tutorial, creas una transacción de pago con el siguiente URI:

URI de pago: getnet://payment/v1/payment

Para iniciar un pago, construyes un Intent con parámetros de solicitud enviados como extras. Esta tabla lista los parámetros obligatorios de la transacción de pago:

Parámetro	Tipo	Obligatorio	Descripción
`amount`	String	Sí	Monto de la transacción con dos decimales implícitos (por ejemplo, “10000” = $100.00)
`originalAmount`	String	Sí	Valor en moneda local para realizar la transacción
`receiptCode`	String	Sí	Código de identificación que se imprime en el comprobante
`callerId`	String	Sí	Identificador único para correlacionar la solicitud con la respuesta

Parámetros opcionales

Parámetro	Tipo	Descripción
`paymentMethod`	String	`"1"` para tarjeta, `"2"` para QR Code. Omite la pantalla de selección del medio de pago.
`operationMode`	String	`"1"` para modo calculado, `"0"` para manual (predeterminado)
`skipReceipt`	String	Define `"true"` para omitir la pantalla del comprobante del cliente después de la aprobación
`allowPrintCurrentTransaction`	String	Define `"true"` para que Getnet imprima el comprobante; `"false"` para recibir los datos del comprobante sin procesar

Este es un ejemplo de implementación en Android:

private val PAYMENT_REQUEST_CODE = 1001

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    // Define the payment URI
    val paymentUri = Uri.parse("getnet://payment/v1/payment")
    
    // Configure the Intent with the required parameters
    val intent = Intent(Intent.ACTION_VIEW, paymentUri)
    intent.putExtra("amount", "10000")        // $100.00
    intent.putExtra("originalAmount", "10000")
    intent.putExtra("receiptCode", "123456") 
    intent.putExtra("callerId", "payment_001")
    intent.putExtra("allowPrintCurrentTransaction", "true")
    
    // Start the activity and expect a result
    startActivityForResult(intent, PAYMENT_REQUEST_CODE)
}

Paso 3: Procesa la respuesta del pago

Cuando el proceso de pago termina, la app de Getnet devuelve un Intent con los resultados de la transacción. Extrae estos extras para verificar si el pago fue aprobado.

Parámetros de respuesta

Parámetro	Tipo	Descripción
`result`	String	Resultado de la operación: `"0"` indica éxito; cualquier otro valor indica falla o cancelación
`resultDetails`	String	Mensaje detallado sobre el resultado de la transacción
`amount`	String	Monto final cobrado con dos decimales implícitos
`receiptCode`	String	Código de identificación impreso en el comprobante
`callerId`	String	El identificador único enviado en la solicitud
`nsu`	String	Código de autorización de la transacción de Getnet (único por terminal)
`authorizationCode`	String	Código de autorización entregado por el emisor de la tarjeta
`brand`	String	Marca de tarjeta usada en la transacción (por ejemplo, “VISA”, “MASTERCARD”)
`cardLastDigits`	String	Últimos 4 dígitos de la tarjeta usada
`cardBin`	String	Primeros 8 dígitos de la tarjeta (BIN)
`inputType`	String	Método de lectura de la tarjeta: `"021"` (banda magnética), `"051"` (chip), `"071"` (contactless), `"801"` (fallback)
`installments`	String	Cantidad de cuotas (si aplica)
`planId`	String	ID del plan de cuotas usado (si aplica)
`gmtDateTime`	String	Fecha y hora de la transacción en formato GMT (MMDDhhmmss)
`automationSlip`	String	Datos del comprobante en formato JSON (si `allowPrintCurrentTransaction = "false"`)

Este es un ejemplo de respuesta de una transacción aprobada:

{
  "result": "0",
  "resultDetails": "APPROVED",
  "amount": "10000",
  "tip": "0",
  "receiptCode": "123456",
  "callerId": "payment_001",
  "nsu": "57003",
  "nsuLastSuccesfullMessage": "750057003",
  "paymentType": "credit",
  "brand": "VISA",
  "inputType": "051",
  "installments": "1",
  "planId": "",
  "Interest": "false",
  "gmtDateTime": "0612211725",
  "authorizationCode": "004433",
  "cardBin": "51559030",
  "cardLastDigits": "8015",
  "automationSlip": ""
}

Usa el método onActivityResult para extraer los parámetros de respuesta. Este es un ejemplo de cómo manejar la respuesta del pago:

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)

    if (requestCode == PAYMENT_REQUEST_CODE && resultCode == RESULT_OK) {
        val extras = data?.extras ?: return

        // Transaction Status
        val result = extras.getString("result")
        val resultDetails = extras.getString("resultDetails")

        if (result == "0") {
            // Payment successful
            val nsu = extras.getString("nsu")
            val authCode = extras.getString("authorizationCode")
            val amount = extras.getString("amount")
            val brand = extras.getString("brand")
            val cardLastDigits = extras.getString("cardLastDigits")
            
            // Log or display success
            Log.d("Payment", "Success! NSU: $nsu, Auth: $authCode")
            
        } else {
            // Payment failed or cancelled
            Log.e("Payment", "Failed: $resultDetails")
            // Handle error appropriately
        }
    }
}

Ejemplo de implementación completo

Este es un ejemplo completo que reúne los tres pasos:

class PaymentActivity : AppCompatActivity() {

    private val POLLING_REQUEST_CODE = 2001
    private val PAYMENT_REQUEST_CODE = 1001

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // Step 1: Verify terminal is ready
        val pollingIntent = Intent(Intent.ACTION_VIEW, Uri.parse("getnet://payment/v1/polling"))
        startActivityForResult(pollingIntent, POLLING_REQUEST_CODE)
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        
        if (resultCode == RESULT_OK && data != null) {
            val result = data.extras?.getString("result")
            
            when (requestCode) {
                POLLING_REQUEST_CODE -> {
                    // If terminal is ready, proceed to payment
                    if (result == "0") {
                        // Step 2: Initiate payment
                        val paymentIntent = Intent(Intent.ACTION_VIEW, Uri.parse("getnet://payment/v1/payment"))
                        paymentIntent.putExtra("amount", "10000")
                        paymentIntent.putExtra("originalAmount", "10000")
                        paymentIntent.putExtra("receiptCode", "123456")
                        paymentIntent.putExtra("callerId", "payment_001")
                        paymentIntent.putExtra("allowPrintCurrentTransaction", "true")
                        startActivityForResult(paymentIntent, PAYMENT_REQUEST_CODE)
                    } else {
                        // Terminal not ready
                        val resultDetails = data.extras?.getString("resultDetails")
                        Log.e("Polling", "Terminal not ready: $resultDetails")
                    }
                }
                
                PAYMENT_REQUEST_CODE -> {
                    // Step 3: Handle payment response
                    if (result == "0") {
                        val nsu = data.extras?.getString("nsu")
                        val authCode = data.extras?.getString("authorizationCode")
                        val amount = data.extras?.getString("amount")
                        // Payment successful
                        Log.d("Payment", "Success! NSU: $nsu")
                    } else {
                        val resultDetails = data.extras?.getString("resultDetails")
                        // Payment failed or cancelled
                        Log.e("Payment", "Failed: $resultDetails")
                    }
                }
            }
        }
    }
}

Siguientes pasos

¡Felicitaciones! Completaste la integración básica entre tu aplicación Android y la Getnet Payment App mediante Deeplink.

Ya tienes una base funcional para procesar pagos con la Getnet Payment App. Con esta base puedes cubrir escenarios más complejos y agregar más opciones de pago. Así construyes una experiencia de pago robusta para tus usuarios.

Crea un pago en un solo paso - elimina la interacción del usuario en el flujo del terminal.
Crea un pago en cuotas - ofrece planes de cuotas en el terminal.
Referencia de parámetros de Deeplink - todos los parámetros disponibles por operación.