Reimpressão | Deeplink

O deeplink getnet://pagamento/v1/reprint irá reimprimir o último comprovante.

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

Response

Quando retorna?	Parâmetro	Formato	Descrição
SEMPRE	result	String	Resultado da transação, conforme a Tabela de Resultados das Funcionalidades.

Exemplo de implementação

JAVAKOTLINREACT NATIVEFLUTTER

public class MainActivity extends AppCompatActivity {
  private final int REQUEST_CODE = 1001;
  private final String ARG_RESULT = "result";

  @Override
  protected void onCreate(@Nullable Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("getnet://pagamento/v1/reprint"));
    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.getStringExtra(ARG_RESULT);
    }
  }
}

class MainActivity : AppCompatActivity() {
    private val REQUEST_CODE = 1001
    private val ARG_RESULT = "result"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val intent = Intent(Intent.ACTION_VIEW, Uri.parse("getnet://pagamento/v1/reprint"))
        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)
        }
    }
}

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 [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];

          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/reprint', 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 = 1001;
  static const String ARG_RESULT = 'RESULT';

  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];

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

  void _sendDeeplink() {
    Map<String, String> intentParams = {};
    startIntent('getnet://pagamento/v1/reprint', intentParams);
  }

  @override
  void initState() {
    super.initState();
    _sendDeeplink();
  }

  @override
  Widget build(BuildContext context) {
    return ();
  }
}