TerminalModule.java

package com.ruptiva_payment;

import android.content.Context;
import android.util.Log;

import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.zoop.api.ZoopAPI;
import com.zoop.api.terminal.ApplicationDisplayListener;
import com.zoop.api.terminal.DeviceSelectionListener;
import com.zoop.api.terminal.ExtraCardInformationListener;
import com.zoop.api.terminal.TerminalListManager;
import com.zoop.api.terminal.TerminalMessageType;
import com.zoop.api.terminal.TerminalPayment;
import com.zoop.api.terminal.TerminalPaymentListener;
import com.zoop.api.terminal.ZoopTerminalPayment;

import org.json.JSONException;
import org.json.JSONObject;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Vector;


/**
 * Created by Kauê da Maia ([email protected]) on 24/11/17.
 */

public class TerminalModule extends ReactContextBaseJavaModule implements TerminalPaymentListener, ApplicationDisplayListener, ExtraCardInformationListener {

    JSONObject actualTransaction = null;
    TerminalListManager terminalListManager;
    ZoopTerminalPayment zoopTerminalPayment;

    boolean discoveryTerminals = false;

      ArrayList<HashMap<String, Object>> devices;



    /**
     * Dados do marketplace
     */
    String MarketplaceId = "000000";
    String PublishableKey = "000000";

    /**
     * Variáveis para transacionar o estado do app entre o Java e o Javascript.
     */
    boolean isPaymentSuccessful = false;
    boolean isPaymentFailed = false;
    boolean isPaymentAbortedByUser = false;

    boolean isSignatureRequested = false;
    boolean isSignatureCaptured = false;

    boolean isCVCRequested = false;
    boolean isLast4Requested = false;
    boolean isExpirationDateRequested = false;

    String transactionMessage = null;
    String transactionMessageType = null;
    String transactionMessageDescription = null;

    Context context;

    //Constructor
    public TerminalModule(ReactApplicationContext reactContext) {
        super(reactContext);

        Log.d("test___", "TerminalModule Constructor");

        context = reactContext.getCurrentActivity().getApplicationContext();

        try {
            if (!discoveryTerminals) {
                Log.d("test___", "discoveryTerminals is FALSE.");
                terminalListManager = new TerminalListManager(new DeviceSelectionListener() {

                    @Override
                    public void showDeviceListForUserSelection(final Vector<JSONObject> devicesVector) {

                        try {
                            Log.d("test___", "showDeviceListForUserSelection()");
                            Log.d("test___", "Devices Vector: " + devicesVector);
                            devices = new ArrayList<HashMap<String, Object>>();

                            for (JSONObject devicesObject : devicesVector) {
                                HashMap<String, Object> hashMapDevices = new HashMap<String, Object>();

                                hashMapDevices.put("name", devicesObject.getString("name"));
                                hashMapDevices.put("address", devicesObject.getString("address"));
                                hashMapDevices.put("dateTimeDetected", devicesObject.getString("dateTimeDetected"));
                                hashMapDevices.put("selected", devicesObject.getBoolean("selected"));

                                devices.add(hashMapDevices);

                                Log.d("test___", "Device List: " + devices);
                            }


                        } catch (Exception e) {
                        }

                    }

                    @Override
                    public void updateDeviceListForUserSelecion(JSONObject devicesObject) {

                        try {
                            Log.d("test___", "updateDeviceListForUserSelecion()");
                            Log.d("test___", "devices object: " + devicesObject);
                            HashMap<String, Object> hashMapDevices = new HashMap<String, Object>();

                            hashMapDevices.put("name", devicesObject.getString("name"));
                            hashMapDevices.put("address", devicesObject.getString("address"));
                            hashMapDevices.put("dateTimeDetected", devicesObject.getString("dateTimeDetected"));
                            hashMapDevices.put("selected", devicesObject.getBoolean("selected"));

                            devices.add(hashMapDevices);
                            Log.d("test___", "Updated Device List: " + devices);


                        } catch (Exception e) {
                        }

                    }

                }, context);
                Log.d("test___", "Breaking point above");
                terminalListManager.startTerminalsDiscovery();
                Log.d("test___", "Looking for terminals...");
                discoveryTerminals = true;

            } else {
                terminalListManager.finishTerminalDiscovery();
                Log.d("test___", "Not looking for terminals...");
                discoveryTerminals = false;
            }

        } catch (Exception e) {
            Log.e("test___", "Error discovering devices: " + e);
            e.printStackTrace();
        }

    }

    //Module Name
    @Override
    public String getName() {
        return "TerminalModule";
    }

    /**
     * Zoop required methods
     */

    //Payment status
    @Override
    public void paymentSuccessful(final JSONObject jsonObject) { // ~> Pra que serve esse json ?
        isPaymentSuccessful = true;
    }

    @Override
    public void paymentFailed(JSONObject jsonObject) { // ~> Pra que serve esse json ?
        isPaymentFailed = true;
    }

    @Override
    public void paymentAborted() {
        isPaymentAbortedByUser = true;
    }

    //Signature

    //Deprecated method. Will be replaced in future updates
    @Override
    public void currentChargeCanBeAbortedByUser(final boolean canBeAborted) {
    }

    @Override
    public void cardholderSignatureRequested() { //ver com o Rodrigo que dado isso usa: Imagem, base64, etc
        isSignatureRequested = true;
    }

    @Override
    public void signatureResult(int result) {
        if (TerminalPayment.RESULT_OK_SIGNATURE_ADDED_OK == result) {
            //Valida que a assinatura foi capturada
        }
    }

    //Transaction messages

    @Override
    public void showMessage(final String message, TerminalMessageType type) {
        transactionMessage = message;
        transactionMessageType = type.toString();
    }

    @Override
    public void showMessage(final String message, TerminalMessageType type, final String messageDescription) {
        transactionMessage = message;
        transactionMessageType = type.toString();
        transactionMessageDescription = messageDescription;
    }

    //CVV

    @Override
    public void cardCVCRequested() {
        isCVCRequested = true;
    }

    //Last 4 digits

    @Override
    public void cardLast4DigitsRequested() {
        isLast4Requested = true;
    }

    //Expiration date

    @Override
    public void cardExpirationDateRequested() {
        isExpirationDateRequested = true;
    }

    /**
     * Exposed Methods - React Native Bridge
     */

    /**
     * Método para gerar uma nova cobrança
     *
     * @param sellerID    identificador do usuário a receber
     * @param value       valor a ser cobrado
     * @param paymentType tipo da operação, se é crédito ou débito
     * @param promise     Javascript Promise
     */

//    @ReactMethod
//    public void pay(String sellerID, String value, String paymentType, Promise promise) {
//
//        TerminalActivity terminalActivity = new TerminalActivity();
//
//        try {
//            ZoopAPI.getInstance().initialize(terminalActivity.getApplication(), MarketplaceId, sellerID, PublishableKey);
//
//            zoopTerminalPayment = new ZoopTerminalPayment();
//            zoopTerminalPayment.setTerminalPaymentListener(TerminalModule.this);
//
//            if (paymentType == "credito") {
//                zoopTerminalPayment.charge(new BigDecimal(value), ZoopTerminalPayment.CHARGE_TYPE_CREDIT);
//                promise.resolve("Cobrança realizada - Crédito");
//            }
//
//            if (paymentType == "debito") {
//                zoopTerminalPayment.charge(new BigDecimal(value), ZoopTerminalPayment.CHARGE_TYPE_DEBIT);
//                promise.resolve("Cobrança realizada - Débito");
//            }
//
//        } catch (Exception e) {
//            promise.reject("Erro ao efetuar cobrança", e);
//        }
//
//    }

    /**
     * Método para abortar a operação
     *
     * @param promise
     */

    @ReactMethod
    public void abortCharge(Promise promise) {
        zoopTerminalPayment.requestAbortCharge();
    }

    /**
     * Métodos que verificam o resultado da operação, retornando um booleano de acordo com a solicitação
     *
     * @param promise
     */

    @ReactMethod
    public void isPaymentSuccessful(Promise promise) {
        promise.resolve(isPaymentSuccessful);
    }

    @ReactMethod
    public void isPaymentFailed(Promise promise) {
        promise.resolve(isPaymentFailed);
    }

    @ReactMethod
    public void isPaymentAborted(Promise promise) {
        promise.resolve(isPaymentAbortedByUser);
    }

    /**
     * Métodos responsáveis por tratar a assinatura do titular do cartão.
     * Essa prática é incomum no Brasil, mas é requisito na implementação da SDK da Zoop.
     *
     * @param promise
     */

    @ReactMethod
    public void isSignatureRequested(Promise promise) {
        promise.resolve(isSignatureRequested);
    }

    @ReactMethod
    public void isSignatureCaptured(Promise promise) {
        promise.resolve(isSignatureCaptured);
    }

    /**
     * Métodos responsáveis por gerenciar as mensagens da transação
     * O resultado da promise deve receber parse no Javascript, pois é enviado como string
     *
     * @param promise
     */

    @ReactMethod
    public void getMessage(Promise promise) throws JSONException {

        if (transactionMessage != null) {
            JSONObject message = new JSONObject();

            message.put("message", transactionMessage);
            message.put("messageType", transactionMessageType);
            message.put("messageDescription", transactionMessageDescription);

            promise.resolve(message.toString());
        } else {
            promise.reject("Nenhuma mensagem");
        }
    }

    /**
     * Métodos para monitorar a solicitação de outras informações ao titular do cartão
     *
     * @param promise
     */

    @ReactMethod
    public void isCVCRequested(Promise promise) {
        promise.resolve(isCVCRequested);
    }

    @ReactMethod
    public void isLast4Requested(Promise promise) {
        promise.resolve(isLast4Requested);
    }

    @ReactMethod
    public void isExpirationDateRequested(Promise promise) {
        promise.resolve(isExpirationDateRequested);
    }

    /**
     * Métodos de configuração
     */

    @ReactMethod
    public void getDevicesList(Promise promise) {
        Log.d("test___", "getDevicesList()");

        if (devices == null) {
            promise.reject("nenhum device");
        } else {
            Log.d("test___", "devices: " + devices.toString());
            promise.resolve("...");
        }

//        if (!discoveryTerminals) {
//            Log.d("test___", "Looking for terminals...");
//            terminalListManager.startTerminalsDiscovery();
//            discoveryTerminals = true;
//            promise.resolve("[discovery on] Terminals: " + devices.toString());
//        } else {
//            terminalListManager.finishTerminalDiscovery();
//            discoveryTerminals = true;
//            promise.resolve("[discovery off] Terminals: " + devices.toString());
//        }

    }

}