Como realizar integração

A integração com a API de pagamento se dará através de deeplinks parametrizados, por exemplo:

JAVAKOTLINREACT NATIVEFLUTTER

public class MainActivity extends AppCompatActivity {
  private final int REQUEST_CODE = 10001;

  private void startIntent(Bundle bundle, String deeplink){
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(deeplink));
    if(bundle != null){
      intent.putExtras(bundle);
    }
    startActivityForResult(intent, REQUEST_CODE);
  }
  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent data){
    super.onActivityResult(requestCode, resultCode, data);
    if(RESULT_OK == resultCode && RESQUEST_CODE == requestCode){
      foo();
    }
  }
}

class MainActivity : AppCompatActivity() {
  private val REQUEST_CODE = 10001

  private fun startIntent(bundle: Bundle?, deeplink: String) {
    val intent = Intent(Intent.ACTION_VIEW, Uri.parse(deeplink))
    bundle?.let {
        intent.putExtras(it)
    }
    startActivityForResult(intent, REQUEST_CODE)
  }

  override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (resultCode == RESULT_OK && requestCode == REQUEST_CODE) {
        foo()
    }
  }
}

import React, { useState, useLayoutEffect } from 'react';
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 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) {
        foo();
      }
    } catch (error) {
      console.error(error);
    }
  };

  useLayoutEffect(() => {
    //Dispara o Deeplink assim que a tela termina de ser carregada
    launchIntent(DEEPLINK, BUNDLE);
  }, []);
}

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;
  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) {
          //Tratar retorno do result aqui
        }
      } catch (e) {
        log('Error launching intent: $e');
      }
    }

  @override
  void initState() {
    super.initState();
    Map<String, String> intentParams = {};
    startIntent('DEEPLINK', intentParams);
  }
  @override
  Widget build(BuildContext context) {

    return ();
  }
}

Deeplinks disponíveis

Todos os parâmetros deverão ser enviados através do Bundle do Intent e como String:

URL	Função
getnet://pagamento/v1/payment	Pagamento v1 (Deprecated)
getnet://pagamento/v2/payment	Pagamento v2
getnet://pagamento/v3/payment	Pagamento v3
getnet://pagamento/v1/pre-authorization	Pré-autorização v1
getnet://pagamento/v2/pre-authorization	Pré-autorização v2
getnet://pagamento/v1/refund	Reembolso
getnet://pagamento/v2/refund	Reembolso com Sub-Adquirentes
getnet://pagamento/v1/reprint	Reimpressão do último comprovante
getnet://pagamento/v1/getinfos	Retorna informações do terminal
getnet://pagamento/v1/checksubsellers	Consulta Subseller
getnet://pagamento/v1/checkstatus	Consulta Status