naxam / braintree-android-binding Goto Github PK

             initializeTcs = new TaskCompletionSource <bool> ();
             mBraintreeFragment = BraintreeFragment.NewInstance (CrossCurrentActivity.Current.Activity, clientToken);
          
         
         }
         catch (InvalidArgumentException e)
         {
             initializeTcs.TrySetException (e);
         }
         return await initializeTcs.Task;
     }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Android.App;
using Android.Content;
using Android.OS;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Com.Braintreepayments.Api;
using Com.Braintreepayments.Api.Exceptions;
using Com.Braintreepayments.Api.Interfaces;
using Com.Braintreepayments.Api.Models;
using Plugin.CurrentActivity;
using UISend.Services;
using Xamarin.Forms;

 [assembly: Dependency(typeof(UISend.Droid.Services.AndroidPayService))]
namespace UISend.Droid.Services
{
  public class AndroidPayService : Java.Lang.Object, IPayService, IBraintreeResponseListener, IBraintreeErrorListener, 
  IPaymentMethodNonceCreatedListener, IBraintreeCancelListener, IConfigurationListener
   {
      TaskCompletionSource<bool> initializeTcs;
      TaskCompletionSource<string> payTcs;

    BraintreeFragment mBraintreeFragment;
    bool isReady = false;
    bool venmoReady = false;

    string nonce = null;
    public bool CanPay { get => isReady; }
    public bool VenmoReady { get => venmoReady; }

    public event EventHandler<MyEventArgs> OnTokenizationSuccessful;
    public event EventHandler<string> OnTokenizationError;



    public void OnCancel(int requestCode)
    {
        payTcs.SetCanceled();
        //mBraintreeFragment.RemoveListener(this);
    }




    public void OnResponse(Java.Lang.Object parameter)
    {
        if (parameter is Java.Lang.Boolean)
        {
            var res = parameter.JavaCast<Java.Lang.Boolean>();
            isReady = res.BooleanValue();
            initializeTcs?.TrySetResult(res.BooleanValue());
            //DataCollector.CollectDeviceData(mBraintreeFragment, this);
        }
        else if (parameter is Java.Lang.String)
        {
            var res = parameter.JavaCast<Java.Lang.String>();
            string deviceData = res.ToString();
            string nonce2 = payTcs.Task.Result;
            OnTokenizationSuccessful?.Invoke(this, new MyEventArgs(nonce2, deviceData));
            nonce = null;

        }
    }

    public void OnPaymentMethodNonceCreated(PaymentMethodNonce paymentMethodNonce)
    {
        // Send this nonce to your server
        string nonce = paymentMethodNonce.Nonce;
        //mBraintreeFragment.RemoveListener(this);
        payTcs?.TrySetResult(nonce);
        DataCollector.CollectDeviceData(mBraintreeFragment, this);
        //OnTokenizationSuccessful?.Invoke(this, nonce);
    }

    public void OnError(Java.Lang.Exception error)
    {
        if (error is ErrorWithResponse)
        {
            ErrorWithResponse errorWithResponse = (ErrorWithResponse)error;
            BraintreeError cardErrors = errorWithResponse.ErrorFor("creditCard");
            if (cardErrors != null)
            {
                BraintreeError expirationMonthError = cardErrors.ErrorFor("expirationMonth");
                if (expirationMonthError != null)
                {
                    OnTokenizationError?.Invoke(this, expirationMonthError.Message);
                    payTcs?.TrySetException(new System.Exception(expirationMonthError.Message));

                }
                else
                {
                    OnTokenizationError?.Invoke(this, cardErrors.Message);
                    payTcs?.TrySetException(new System.Exception(cardErrors.Message));

                }
            }
        }
        //mBraintreeFragment.RemoveListener(this);
    }



    public async Task<string> TokenizePayPal()
    {
        payTcs = new TaskCompletionSource<string>();
        if (isReady)
        {
            //mBraintreeFragment.AddListener(this);
            PayPal.AuthorizeAccount(mBraintreeFragment);
        }
        else
        {
            OnTokenizationError?.Invoke(this, "Platform is not ready to accept payments");
            payTcs.TrySetException(new System.Exception("Platform is not ready to accept payments"));

        }
        return await payTcs.Task;
    }

    public async Task<string> TokenizeVenmo()
    {
        //mBraintreeFragment.AddListener(this);
        payTcs = new TaskCompletionSource<string>();
        if (venmoReady)
        {
            Venmo.AuthorizeAccount(mBraintreeFragment, false);
        }
        else
        {
            OnTokenizationError?.Invoke(this, "Platform is not ready to accept payments");
            payTcs.TrySetException(new System.Exception("Platform is not ready to accept payments"));

        }
        return await payTcs.Task;
    }

    public async Task<string> TokenizeCard(string panNumber, string expirationMonth, string expirationYear , string cvv)
    {
        if (isReady)
        {
            payTcs = new TaskCompletionSource<string>();
            CardBuilder cardBuilder = new CardBuilder()
                .CardNumber(panNumber).JavaCast<CardBuilder>()
                .ExpirationMonth(expirationMonth).JavaCast<CardBuilder>()
                .ExpirationYear(expirationYear).JavaCast<CardBuilder>()
                .Cvv(cvv).JavaCast<CardBuilder>();

            mBraintreeFragment.AddListener(this);

            Card.Tokenize(mBraintreeFragment, cardBuilder);
        }
        else
        {
            OnTokenizationError?.Invoke(this, "Platform is not ready to accept payments");
            payTcs.TrySetException(new System.Exception("Platform is not ready to accept payments"));

        }
        return await payTcs.Task;
    }

    public async Task<bool> InitializeAsync(string clientToken)
    {
        try
        {
            initializeTcs = new TaskCompletionSource<bool>();
            mBraintreeFragment = BraintreeFragment.NewInstance(CrossCurrentActivity.Current.Activity, clientToken);
            GooglePayment.IsReadyToPay(mBraintreeFragment, this);
            mBraintreeFragment.AddListener(this);
            //isReady = true;
            //initializeTcs.TrySetResult(isReady);
        }
        catch (InvalidArgumentException e)
        {
            initializeTcs.TrySetException(e);
        }
        return await initializeTcs.Task;
    }

    public void OnConfigurationFetched(Configuration p0)
    {
        venmoReady = p0.PayWithVenmo.IsEnabled(CrossCurrentActivity.Current.Activity);
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing)
            mBraintreeFragment.RemoveListener(this);
        base.Dispose(disposing);
    }
   }
  }

                          Result<Transaction> result = null;
                         try
                        {
                           Trace.WriteLine("Attempting Braintree Payment...");
                           var braintreePayInfo = JsonConvert.DeserializeObject<Dictionary<string, string>>(paymentInfoJson);
                           bool rememberPayMethod = braintreePayInfo.ContainsKey("Remember") ? 
                           bool.Parse(braintreePayInfo["Remember"]) : false;

                        var gateway = new BraintreeGateway
                        {
                            Environment = Braintree.Environment.SANDBOX,
                            MerchantId = BraintreeConfig.MerchantId,
                            PublicKey = BraintreeConfig.PublicKey,
                            PrivateKey = BraintreeConfig.PrivateKey
                        };



                        var request = new TransactionRequest
                        {
                            Amount = decimal.Parse(braintreePayInfo["Amount"]),
                            Options = new TransactionOptionsRequest
                            {
                                SubmitForSettlement = true,
                            }
                        };
                        if(braintreePayInfo.ContainsKey("Token") && !string.IsNullOrEmpty(braintreePayInfo["Token"]))
                        {
                            // Pago con tarjeta existente
                            request.PaymentMethodToken = braintreePayInfo["Token"];
                        }
                        else if (braintreePayInfo.ContainsKey("Nonce") && !string.IsNullOrEmpty(braintreePayInfo["Nonce"]))
                        {
                            // Pago con cuenta paypal/venmo o nueva tarjeta
                            request.PaymentMethodNonce = braintreePayInfo["Nonce"];
                            // Guardar tarjeta en el vault?
                            if(order.PaymentMethod == "-BTCARD")
                            {
                                Trace.WriteLine($"Assigning value {rememberPayMethod} to StoreInVaultOnSuccess...");
                                request.Options.StoreInVaultOnSuccess = rememberPayMethod;
                                Trace.WriteLine($"Value {request.Options.StoreInVaultOnSuccess} assigned.");
                            }
                                
                        } else
                        {
                            throw new Exception("Payment method not found");
                        }



                        if (order.PaymentMethod == "--VENMO" || order.PaymentMethod == "-BTCARD" && 
                     braintreePayInfo.ContainsKey("DeviceData"))
                        {
                            request.DeviceData = braintreePayInfo["DeviceData"];
                        }



                        if(rememberPayMethod)
                        {
                            string braintreeId = order.UserId.ToString().ToUpper();
                            try
                            {
                                Customer customer = gateway.Customer.Find(braintreeId);
                                Trace.WriteLine("Adding existing Customer to transaction with ID " + customer.Id + "...");
                                request.CustomerId = customer.Id;
                            }
                            catch
                            {
                                Trace.WriteLine("Adding new Customer to transaction with ID " + braintreeId + "...");
                                request.Customer = new CustomerRequest { Id = braintreeId };
                            }
                        }
                        
                        result = gateway.Transaction.Sale(request);
                        var resultJson = JsonConvert.SerializeObject(result);
                        //Se le responde al user
                        Clients.Caller.ProcessPayment(name, orderJson, resultJson);
                    } catch(Exception ex)
                    {
                        var key8 = providerLocks.GetOrAdd(order.ProviderId.ToString(), new object());
                        lock (key8)
                        {
                            try
                            {
                                OrderHelper.RollbackOrder(order);
                            }
                            finally
                            {
                                providerLocks.TryRemove(order.ProviderId.ToString(), out _);
                            }
                        }



                        Trace.WriteLine("Error during Braintree Payment: " + ex.Message);
                        ExceptionHelper.DisplayExceptionInfo(ex);



                        throw ex;
                    }

DropInRequest dropInRequest = new DropInRequest()
       .ClientToken(clientToken);

TransactionInfo transactionInfo = TransactionInfo.NewBuilder()
                .SetTotalPrice("1.00")
                .SetTotalPriceStatus(WalletConstants.TotalPriceStatusFinal)
                .SetCurrencyCode("USD")
                .Build();

GooglePaymentRequest googlePaymentRequest = new GooglePaymentRequest().InvokeTransactionInfo(transactionInfo);

dropInRequest.InvokeGooglePaymentRequest(googlePaymentRequest);
          
StartActivityForResult(dropInRequest.GetIntent(this), LOAD_PAYMENT_DATA_REQUEST_CODE);