Início rápido

Este guia prático mostra a integração básica entre seu aplicativo Android e o aplicativo de pagamento Getnet via Deeplink. Ao final deste tutorial, você terá disparado um comando de pagamento e processado a resposta da transação.

Antes de começar

Antes de seguir os passos abaixo, confirme que você atende a estes pré-requisitos.

Você precisa entender o que é uma chamada de Polling (getnet://payment/v1/polling). Ela verifica se o Getnet Payment App está conectado e pronto para receber comandos antes do início de uma transação.
Conhecimento básico de Intents do Android e de onActivityResult.

Passo 1: valide a conexão do terminal (polling)

Antes de iniciar um pagamento, a prática recomendada é executar uma operação de Polling. Essa requisição não financeira verifica se o Getnet Payment App está conectado e pronto para processar transações.

Para fazer essa verificação, dispare um Intent com a seguinte URI:

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

Veja um exemplo de implementação:

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

o Polling não exige nenhum parâmetro. Envie o deeplink e o terminal responde com o status atual.

O app Getnet retorna os seguintes parâmetros:

Parâmetro	Tipo	Descrição
`result`	String	Resultado da operação: `"0"` para sucesso (terminal pronto).
`resultDetails`	String	Mensagem detalhada sobre o status do terminal.

Se o result for "0", você está liberado para seguir para o pagamento.

Passo 2: inicialize a transação de pagamento

A comunicação acontece por meio de um Intent com uma URI específica. Neste tutorial, você cria uma transação de pagamento com a seguinte URI:

URI de pagamento: getnet://payment/v1/payment

Para iniciar um pagamento, monte um Intent com parâmetros de requisição específicos passados como extras. A tabela abaixo traz os parâmetros obrigatórios da transação de pagamento:

Parâmetro	Tipo	Obrigatório	Descrição
`amount`	String	Sim	Valor da transação com duas casas decimais implícitas (ex.: “10000” = $100.00)
`originalAmount`	String	Sim	Valor em moeda local para realizar a transação
`receiptCode`	String	Sim	Código de identificação a ser impresso no comprovante
`callerId`	String	Sim	Identificador único para correlacionar a requisição com a resposta

Parâmetros opcionais

Parâmetro	Tipo	Descrição
`paymentMethod`	String	`"1"` para cartão, `"2"` para QR Code. Pula a tela de seleção do meio de pagamento.
`operationMode`	String	`"1"` para modo calculado, `"0"` para manual (padrão)
`skipReceipt`	String	Defina como `"true"` para ocultar a tela de visualização do comprovante do cliente após a aprovação
`allowPrintCurrentTransaction`	String	Defina como `"true"` para a Getnet cuidar da impressão do comprovante, `"false"` para receber os dados brutos do comprovante

Veja um exemplo de implementação em 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)
}

Passo 3: processe a resposta do pagamento

Quando o processo de pagamento termina, o app Getnet retorna um Intent com os resultados da transação. Extraia esses extras para verificar se o pagamento foi aprovado.

Parâmetros de resposta

Parâmetro	Tipo	Descrição
`result`	String	Resultado da operação: `"0"` para sucesso; qualquer outro valor indica falha ou cancelamento
`resultDetails`	String	Mensagem detalhada sobre o resultado da transação
`amount`	String	Valor final cobrado com duas casas decimais implícitas
`receiptCode`	String	Código de identificação impresso no comprovante
`callerId`	String	O identificador único enviado na requisição
`nsu`	String	Código de autorização da transação Getnet (único por terminal)
`authorizationCode`	String	Código de autorização fornecido pelo emissor do cartão
`brand`	String	Bandeira do cartão usada na transação (ex.: “VISA”, “MASTERCARD”)
`cardLastDigits`	String	Últimos 4 dígitos do cartão usado
`cardBin`	String	Primeiros 8 dígitos do cartão (BIN)
`inputType`	String	Forma de leitura do cartão: `"021"` (magnético), `"051"` (chip), `"071"` (aproximação), `"801"` (fallback)
`installments`	String	Número de parcelas (se aplicável)
`planId`	String	ID do plano de parcelamento usado (se aplicável)
`gmtDateTime`	String	Data e hora da transação em formato GMT (MMDDhhmmss)
`automationSlip`	String	Dados do comprovante em formato JSON (se `allowPrintCurrentTransaction = "false"`)

Veja um exemplo de resposta de uma transação bem-sucedida:

{
  "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": ""
}

Use o método onActivityResult para extrair os parâmetros de resposta. Veja um exemplo de implementação para tratar a resposta do pagamento:

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
        }
    }
}

Exemplo completo de implementação

Veja um exemplo completo que reúne os três passos:

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

Próximos passos

Parabéns! Você concluiu a integração básica entre seu aplicativo Android e o Getnet Payment App via Deeplink.

Agora você tem uma base funcional para processar pagamentos pelo Getnet Payment App. Com esse conhecimento, você pode expandir a integração para cenários mais complexos. Você também pode implementar outras opções de pagamento e criar uma experiência de pagamento robusta para seus usuários.

Crie um pagamento em etapa única - remove a interação do usuário no fluxo do terminal.
Crie um pagamento parcelado - ofereça planos de parcelamento no terminal.
Referência de parâmetros de deeplink - todos os parâmetros disponíveis por operação.