# 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: ```kotlin 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: ```kotlin 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: ```kotlin 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](/pt/app2app/payment-guides-a2a/create-single-step-payment) - remove a interação do usuário no fluxo do terminal. * [Crie um pagamento parcelado](/pt/app2app/payment-guides-a2a/create-installments-and-plan) - ofereça planos de parcelamento no terminal. * [Referência de parâmetros de deeplink](/pt/app2app/reference-a2a/deeplink-parameters) - todos os parâmetros disponíveis por operação.