Infos | Deeplink

O deeplink getnet://pagamento/v1/getinfos irá retornar os dados do terminal via activityResult.

Abaixo segue a tabela de resposta e seus respectivos parâmetros:

Quando retorna?	Parâmetro	Formato	Descrição
SEMPRE	result	String	Resultado da transação, conforme a Tabela de Resultados das Funcionalidades.
SEMPRE	ec	String	Número do estabelecimento comercial vinculado.
SEMPRE	numserie	String	Número de série do equipamento
SEMPRE	numlogic	String	Número lógico do equipamento vinculado
SEMPRE	version	String	Versão da API
SEMPRE	cnpjEC	String	CNPJ do estabelecimento vinculado à Getnet
SEMPRE	razaoSocialEC	String	Razão social do estabelecimento vinculado
SEMPRE	cidadeEC	String	Cidade do estabelecimento, onde foi credenciado

Exemplo de implementação

JAVAKOTLINREACT NATIVEFLUTTER

public class MainActivity extends AppCompatActivity {
  private final int REQUEST_CODE = 1001;
  private final String ARG_RESULT = "result";
  private final String ARG_EC = "ec";
  private final String ARG_NUM_SERIE = "numserie";
  private final String ARG_NUM_LOGIC = "numlogic";
  private final String ARG_VERSION = "version";
  private final String ARG_CNPJ = "cnpjEC";
  private final String ARG_NAME = "nomeEC";
  private final String ARG_RAZAO_SOCIAL = "razaoSocialEC";
  private final String ARG_CIDADE = "cidadeEC";

  @Override
  protected void onCreate(@Nullable Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("getnet://pagamento/v1/getinfos"));
    startActivityForResult(intent, REQUEST_CODE);
  }

  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent data){
    super.onActivityResult(requestCode, resultCode, data);
    if(REQUEST_CODE == requestCode && RESULT_OK == resultCode){
      String result = data.getString(ARG_RESULT);
      String ec = data.getString(ARG_EC);
      String numSerie = data.getString(ARG_NUM_SERIE);
      String numLogic = data.getString(ARG_NUM_LOGIC);
      String apiVersion = data.getString(ARG_VERSION);
      String cnpj = data.getString(ARG_CNPJ);
      String name = data.getString(ARG_NAME);
      String razaoSocial = data.getString(ARG_RAZAO_SOCIAL);
      String cidade = data.getString(ARG_CIDADE);
    }
  }
}

class MainActivity : AppCompatActivity() {
    private val REQUEST_CODE = 1001
    private val ARG_RESULT = "result"
    private val ARG_EC = "ec"
    private val ARG_NUM_SERIE = "numserie"
    private val ARG_NUM_LOGIC = "numlogic"
    private val ARG_VERSION = "version"
    private val ARG_CNPJ = "cnpjEC"
    private val ARG_NAME = "nomeEC"
    private val ARG_RAZAO_SOCIAL = "razaoSocialEC"
    private val ARG_CIDADE = "cidadeEC"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val intent = Intent(Intent.ACTION_VIEW, Uri.parse("getnet://pagamento/v1/getinfos"))
        startActivityForResult(intent, REQUEST_CODE)
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (REQUEST_CODE == requestCode && resultCode == RESULT_OK) {
            val result = data?.getStringExtra(ARG_RESULT)
            val ec = data?.getStringExtra(ARG_EC)
            val numSerie = data?.getStringExtra(ARG_NUM_SERIE)
            val numLogic = data?.getStringExtra(ARG_NUM_LOGIC)
            val apiVersion = data?.getStringExtra(ARG_VERSION)
            val cnpj = data?.getStringExtra(ARG_CNPJ)
            val name = data?.getStringExtra(ARG_NAME)
            val razaoSocial = data?.getStringExtra(ARG_RAZAO_SOCIAL)
            val cidade = data?.getStringExtra(ARG_CIDADE)
        }
    }
}

import React, { useState, useLayoutEffect } from 'react';
import { View, Text } from 'react-native';
import * as IntentLauncher from 'expo-intent-launcher';

const RESULT_OK = -1;
const RESULT_CANCELED = 0;

const ACTION_VIEW = 'android.intent.action.VIEW';

export default function MainComponent() {

  const ARG_RESULT = "result";
  const ARG_EC = "ec";
  const ARG_NUM_SERIE = "numserie";
  const ARG_NUM_LOGIC = "numlogic";
  const ARG_VERSION = "version";
  const ARG_CNPJ = "cnpjEC";
  const ARG_NAME = "nomeEC";
  const ARG_RAZAO_SOCIAL = "razaoSocialEC";
  const ARG_CIDADE = "cidadeEC";

  const [resultCode, setResultCode] = useState<number>();
  const [resultData, setResultData] = useState({});

  const launchIntent = async(deeplink: string, bundle: {}) =>  {

    const intentParams = { ...bundle, data: deeplink }; //Unindo URI Deeplink com o bundle no intentParams

    try {
      const activityResult = await IntentLauncher.startActivityAsync(ACTION_VIEW, intentParams);
      if (activityResult.data && activityResult.resultCode == RESULT_OK) {
        if(activityResult.extra) {
          const JSON_obj = JSON.parse(JSON.stringify(activityResult.extra))

          const result = JSON_obj[ARG_RESULT];
          const ec = JSON_obj[ARG_EC];
          const numSerie = JSON_obj[ARG_NUM_SERIE];
          const numLogic = JSON_obj[ARG_NUM_LOGIC];
          const apiVersion = JSON_obj[ARG_VERSION];
          const cnpj = JSON_obj[ARG_CNPJ];
          const name = JSON_obj[ARG_NAME];
          const razaoSocial = JSON_obj[ARG_RAZAO_SOCIAL];
          const cidade = JSON_obj[ARG_CIDADE];

          setResultData(JSON_obj);
          setResultCode(activityResult.resultCode);
        }
      }
    } catch (error) {
      console.error(error);
    }
  };

  useLayoutEffect(() => {
    const intentParams = {};

    //Dispara o Deeplink assim que a tela termina de ser carregada
    launchIntent('getnet://pagamento/v1/getinfos', intentParams);
  }, []);

  return (
    <View>
      <Text>Result Code: {resultCode}</Text>
      <Text>Result Data: {JSON.stringify(resultData)}</Text>
    </View>
  );
}

Para utilizar o deeplink, será necessário fazer uso do código nativo:

package com.example.deeplink_test

import androidx.annotation.NonNull
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodCall
import io.flutter.plugin.common.MethodChannel
import io.flutter.plugin.common.MethodChannel.MethodCallHandler
import io.flutter.plugin.common.MethodChannel.Result

import android.app.Activity
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.util.Log

class MainActivity: FlutterActivity(), MethodCallHandler {
    private val CHANNEL = "sample.android/deeplink"
    private lateinit var channel: MethodChannel
    private var callback: Result? = null

    private var requestCode: Int = -1

    override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
        channel = MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).apply {
            setMethodCallHandler(this@MainActivity)
        }
    }

    override fun onMethodCall(call: MethodCall, result: Result) {
        var action = ""
        var deeplink = ""
        var bundle = Bundle()

        when(call.method) {
            "startActivityForResult" -> {
                callback = result
                val params = call.arguments as? Map<String, Any>
                params?.run {
                    for ((key, value) in params) {
                        when(key.toString()) {
                            "action" -> action = value.toString()
                            "data" -> deeplink = value.toString()
                            "requestCode" -> requestCode = value.toString().toInt()
                            "arguments" -> {
                                bundle.apply{
                                    for((argKey, argValue) in (value as Map<String, Any>)) {
                                        when(argValue) {
                                            is String -> putString(argKey, argValue as String)
                                            is Int -> putInt(argKey, argValue as Int)
                                            is Boolean -> putBoolean(argKey, argValue as Boolean)
                                        }
                                    }
                                }
                            }
                        }
                    }
                    val intent = Intent(action, Uri.parse(deeplink)).apply {
                        putExtras(bundle)
                    }
                    startActivityForResult(intent, requestCode)
                }
            }
            else -> result.notImplemented()
        }
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        when(requestCode) {
            this.requestCode -> {
                when(resultCode) {
                    Activity.RESULT_OK -> {
                        data?.getExtras()?.let { extras ->
                            val resultMap = hashMapOf<String, Any?>()
                            for(key in extras.keySet()) {
                                resultMap[key] = extras.get(key)
                            }
                            callback?.success(resultMap)
                        }
                    } else -> callback?.error("ERROR", "No valid return from DeepLink", null)
                }
            } else -> callback?.error("ERROR", "Activity result was not OK", null)
        }
    }
}

E com o código nativo criado, podemos chamar ele através do startIntent abaixo:

import 'dart:developer';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatefulWidget {
  const MyApp({super.key,});

  @override
  State<MyApp> createState() {
    return _MyAppState();
  }
}

class _MyAppState extends State<MyApp> {

  static const int REQUEST_CODE = 10001;
  static const String ARG_RESULT = "result";
  static const String ARG_EC = "ec";
  static const String ARG_NUM_SERIE = "numserie";
  static const String ARG_NUM_LOGIC = "numlogic";
  static const String ARG_VERSION = "version";
  static const String ARG_CNPJ = "cnpjEC";
  static const String ARG_NAME = "nomeEC";
  static const String ARG_RAZAO_SOCIAL = "razaoSocialEC";
  static const String ARG_CIDADE = "cidadeEC";

  int? resultCode;
  var deeplinkResult = '';

  static const platform = MethodChannel('sample.android/deeplink');

  void startIntent(String deeplink, Map<String, String> bundle) async {
      try {
        final intent = {
          'requestCode': REQUEST_CODE,
          'action': 'android.intent.action.VIEW',
          'data': deeplink,
          'arguments': bundle,
        };
        var result = await platform.invokeMethod('startActivityForResult', intent);
        if (result != null) {
          var resultMap = Map<String, dynamic>.from(result);

          String resultValue = resultMap[ARG_RESULT];
          String ec = resultMap[ARG_EC];
          String numSerie = resultMap[ARG_NUM_SERIE];
          String numLogic = resultMap[ARG_NUM_LOGIC];
          String apiVersion = resultMap[ARG_VERSION];
          String cnpj = resultMap[ARG_CNPJ];
          String name = resultMap[ARG_NAME];
          String name = resultMap[ARG_RAZAO_SOCIAL];
          String name = resultMap[ARG_CIDADE];

          setState(() {
            resultCode = 1;
          });
        }
      } catch (e) {
        log('Error launching intent: $e');
      }
    }

  void _sendDeeplink() {
    Map<String, String> intentParams = {};
    startIntent('', intentParams);
  }

  @override
  void initState() {
    super.initState();
    _sendDeeplink();
  }
  @override
  Widget build(BuildContext context) {

    return ();
  }
}