@xbenjii/react-native-braintree-dropin-ui 2.0.0

package/android/src/main/java/tech/power/RNBraintreeDropIn/RNBraintreeDropInModule.java

@@ -0,0 +1,265 @@
+package com.xbenjii.RNBraintreeDropIn;
+
+import android.app.Activity;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.FragmentActivity;
+
+import com.braintreepayments.api.BraintreeClient;
+import com.braintreepayments.api.Card;
+import com.braintreepayments.api.CardClient;
+import com.braintreepayments.api.DropInClient;
+import com.braintreepayments.api.DropInListener;
+import com.braintreepayments.api.DropInPaymentMethod;
+import com.braintreepayments.api.ThreeDSecureRequest;
+import com.braintreepayments.api.UserCanceledException;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.Promise;
+import com.braintreepayments.api.DropInRequest;
+import com.braintreepayments.api.DropInResult;
+import com.braintreepayments.api.PaymentMethodNonce;
+import com.braintreepayments.api.CardNonce;
+import com.braintreepayments.api.ThreeDSecureInfo;
+import com.braintreepayments.api.GooglePayRequest;
+import com.google.android.gms.wallet.TransactionInfo;
+import com.google.android.gms.wallet.WalletConstants;
+
+import java.util.Objects;
+
+public class RNBraintreeDropInModule extends ReactContextBaseJavaModule {
+  private boolean isVerifyingThreeDSecure = false;
+  private static DropInClient dropInClient = null;
+  private static String clientToken = null;
+
+  public static void initDropInClient(FragmentActivity activity) {
+    dropInClient = new DropInClient(activity, callback -> {
+      if (clientToken != null) {
+        callback.onSuccess(clientToken);
+      } else {
+        callback.onFailure(new Exception("Client token is null"));
+      }
+    });
+  }
+
+  public RNBraintreeDropInModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @ReactMethod
+  public void show(final ReadableMap options, final Promise promise) {
+    isVerifyingThreeDSecure = false;
+
+    if (!options.hasKey("clientToken")) {
+      promise.reject("NO_CLIENT_TOKEN", "You must provide a client token");
+      return;
+    }
+
+    FragmentActivity currentActivity = (FragmentActivity) getCurrentActivity();
+    if (currentActivity == null) {
+      promise.reject("NO_ACTIVITY", "There is no current activity");
+      return;
+    }
+
+    DropInRequest dropInRequest = new DropInRequest();
+
+    if(options.hasKey("vaultManager")) {
+      dropInRequest.setVaultManagerEnabled(options.getBoolean("vaultManager"));
+    }
+
+    if(options.hasKey("googlePay") && options.getBoolean("googlePay")){
+      GooglePayRequest googlePayRequest = new GooglePayRequest();
+      googlePayRequest.setTransactionInfo(TransactionInfo.newBuilder()
+          .setTotalPrice(Objects.requireNonNull(options.getString("orderTotal")))
+          .setTotalPriceStatus(WalletConstants.TOTAL_PRICE_STATUS_FINAL)
+          .setCurrencyCode(Objects.requireNonNull(options.getString("currencyCode")))
+          .build());
+      googlePayRequest.setBillingAddressRequired(true);
+      googlePayRequest.setGoogleMerchantId(options.getString("googlePayMerchantId"));
+
+      dropInRequest.setGooglePayDisabled(false);
+      dropInRequest.setGooglePayRequest(googlePayRequest);
+    }else{
+        dropInRequest.setGooglePayDisabled(true);
+    }
+
+    if(options.hasKey("cardDisabled")) {
+      dropInRequest.setCardDisabled(options.getBoolean("cardDisabled"));
+    }
+
+    if (options.hasKey("threeDSecure")) {
+      final ReadableMap threeDSecureOptions = options.getMap("threeDSecure");
+      if (threeDSecureOptions == null || !threeDSecureOptions.hasKey("amount")) {
+        promise.reject("NO_3DS_AMOUNT", "You must provide an amount for 3D Secure");
+        return;
+      }
+
+      isVerifyingThreeDSecure = true;
+
+      ThreeDSecureRequest threeDSecureRequest = new ThreeDSecureRequest();
+      threeDSecureRequest.setAmount(threeDSecureOptions.getString("amount"));
+
+      dropInRequest.setThreeDSecureRequest(threeDSecureRequest);
+    }
+
+    dropInRequest.setPayPalDisabled(!options.hasKey("payPal") || !options.getBoolean("payPal"));
+
+    clientToken = options.getString("clientToken");
+
+    if (dropInClient == null) {
+      promise.reject(
+        "DROP_IN_CLIENT_UNINITIALIZED",
+        "Did you forget to call RNBraintreeDropInModule.initDropInClient(this) in MainActivity.onCreate?"
+      );
+      return;
+    }
+    dropInClient.setListener(new DropInListener() {
+      @Override
+      public void onDropInSuccess(@NonNull DropInResult dropInResult) {
+        PaymentMethodNonce paymentMethodNonce = dropInResult.getPaymentMethodNonce();
+
+        if (isVerifyingThreeDSecure && paymentMethodNonce instanceof CardNonce) {
+          CardNonce cardNonce = (CardNonce) paymentMethodNonce;
+          ThreeDSecureInfo threeDSecureInfo = cardNonce.getThreeDSecureInfo();
+          if (!threeDSecureInfo.isLiabilityShiftPossible()) {
+            promise.reject("3DSECURE_NOT_ABLE_TO_SHIFT_LIABILITY", "3D Secure liability cannot be shifted");
+          } else if (!threeDSecureInfo.isLiabilityShifted()) {
+            promise.reject("3DSECURE_LIABILITY_NOT_SHIFTED", "3D Secure liability was not shifted");
+          } else {
+            resolvePayment(dropInResult, promise);
+          }
+        } else {
+          resolvePayment(dropInResult, promise);
+        }
+      }
+
+      @Override
+      public void onDropInFailure(@NonNull Exception exception) {
+        if (exception instanceof UserCanceledException) {
+          promise.reject("USER_CANCELLATION", "The user cancelled");
+        } else {
+          promise.reject(exception.getMessage(), exception.getMessage());
+        }
+      }
+    });
+    dropInClient.launchDropIn(dropInRequest);
+  }
+
+  @ReactMethod
+  public void fetchMostRecentPaymentMethod(final String clientToken, final Promise promise) {
+    FragmentActivity currentActivity = (FragmentActivity) getCurrentActivity();
+
+    if (currentActivity == null) {
+      promise.reject("NO_ACTIVITY", "There is no current activity");
+      return;
+    }
+
+    if (dropInClient == null) {
+      promise.reject(
+        "DROP_IN_CLIENT_UNINITIALIZED",
+        "Did you forget to call RNBraintreeDropInModule.initDropInClient(this) in MainActivity.onCreate?"
+      );
+      return;
+    }
+
+    RNBraintreeDropInModule.clientToken = clientToken;
+
+    dropInClient.fetchMostRecentPaymentMethod(currentActivity, (dropInResult, error) -> {
+      if (error != null) {
+        promise.reject(error.getMessage(), error.getMessage());
+      } else if (dropInResult == null) {
+        promise.reject("NO_DROP_IN_RESULT", "dropInResult is null");
+      } else {
+        resolvePayment(dropInResult, promise);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void tokenizeCard(final String clientToken, final ReadableMap cardInfo, final Promise promise) {
+    if (clientToken == null) {
+      promise.reject("NO_CLIENT_TOKEN", "You must provide a client token");
+      return;
+    }
+
+    if (
+      !cardInfo.hasKey("number") ||
+      !cardInfo.hasKey("expirationMonth") ||
+      !cardInfo.hasKey("expirationYear") ||
+      !cardInfo.hasKey("cvv") ||
+      !cardInfo.hasKey("postalCode")
+    ) {
+      promise.reject("INVALID_CARD_INFO", "Invalid card info");
+      return;
+    }
+
+    Activity currentActivity = getCurrentActivity();
+
+    if (currentActivity == null) {
+      promise.reject("NO_ACTIVITY", "There is no current activity");
+      return;
+    }
+
+    BraintreeClient braintreeClient = new BraintreeClient(getCurrentActivity(), clientToken);
+    CardClient cardClient = new CardClient(braintreeClient);
+
+    Card card = new Card();
+    card.setNumber(cardInfo.getString("number"));
+    card.setExpirationMonth(cardInfo.getString("expirationMonth"));
+    card.setExpirationYear(cardInfo.getString("expirationYear"));
+    card.setCvv(cardInfo.getString("cvv"));
+    card.setPostalCode(cardInfo.getString("postalCode"));
+
+    cardClient.tokenize(card, (cardNonce, error) -> {
+      if (error != null) {
+        promise.reject(error.getMessage(), error.getMessage());
+      } else if (cardNonce == null) {
+        promise.reject("NO_CARD_NONCE", "Card nonce is null");
+      } else {
+        promise.resolve(cardNonce.getString());
+      }
+    });
+  }
+
+  private void resolvePayment(DropInResult dropInResult, Promise promise) {
+    String deviceData = dropInResult.getDeviceData();
+    PaymentMethodNonce paymentMethodNonce = dropInResult.getPaymentMethodNonce();
+
+    WritableMap jsResult = Arguments.createMap();
+
+    if (paymentMethodNonce == null) {
+      promise.resolve(null);
+      return;
+    }
+
+    Activity currentActivity = getCurrentActivity();
+    if (currentActivity == null) {
+      promise.reject("NO_ACTIVITY", "There is no current activity");
+      return;
+    }
+
+    DropInPaymentMethod dropInPaymentMethod = dropInResult.getPaymentMethodType();
+    if (dropInPaymentMethod == null) {
+      promise.reject("NO_PAYMENT_METHOD", "There is no payment method");
+      return;
+    }
+
+    jsResult.putString("nonce", paymentMethodNonce.getString());
+    jsResult.putString("type", currentActivity.getString(dropInPaymentMethod.getLocalizedName()));
+    jsResult.putString("description", dropInResult.getPaymentDescription());
+    jsResult.putBoolean("isDefault", paymentMethodNonce.isDefault());
+    jsResult.putString("deviceData", deviceData);
+
+    promise.resolve(jsResult);
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return "RNBraintreeDropIn";
+  }
+}

package/android/src/main/java/tech/power/RNBraintreeDropIn/RNBraintreeDropInPackage.java

@@ -0,0 +1,27 @@
+package com.xbenjii.RNBraintreeDropIn;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.bridge.JavaScriptModule;
+public class RNBraintreeDropInPackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+      return Arrays.<NativeModule>asList(new RNBraintreeDropInModule(reactContext));
+    }
+
+    // Deprecated from RN 0.47
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+      return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+      return Collections.emptyList();
+    }
+}

package/index.js

@@ -0,0 +1,5 @@
+import { NativeModules } from 'react-native';
+
+const { RNBraintreeDropIn } = NativeModules;
+
+export default RNBraintreeDropIn;

package/index.js.flow

@@ -0,0 +1,42 @@
+type ShowOptions = {|
+  clientToken: string,
+  threeDSecure?: {|
+    amount: number,
+  |},
+  vaultManager?: boolean,
+  cardDisabled?: boolean,
+  googlePay?: boolean,
+  orderTotal?: string,
+  currencyCode?: string,
+  googlePayMerchantId?: string,
+  payPal?: boolean,
+  applePay?: boolean,
+  merchantIdentifier?: string,
+  countryCode?: string,
+  merchantName?: string,
+  darkTheme?: boolean,
+  fontFamily?: string,
+  boldFontFamily?: string,
+|};
+
+type CardInfo = {|
+  number: string,
+  expirationMonth: string,
+  expirationYear: string,
+  cvv: string,
+  postalCode: string,
+|};
+
+type ShowResult = {|
+  nonce: string,
+  description: string,
+  type: string,
+  isDefault: boolean,
+  deviceData: string,
+|};
+
+declare module.exports: {
+  show: (options: ShowOptions) => Promise<ShowResult>,
+  fetchMostRecentPaymentMethod: (clientToken: string) => Promise<ShowResult>,
+  tokenizeCard: (clientToken: string, cardInfo: CardInfo) => Promise<string>,
+};

package/ios/RNBraintreeDropIn.h

@@ -0,0 +1,40 @@
+@import UIKit;
+@import PassKit;
+
+#if __has_include("RCTBridgeModule.h")
+#import "RCTBridgeModule.h"
+#else
+#import <React/RCTBridgeModule.h>
+#endif
+
+#import "BraintreeCore.h"
+#import "BraintreeDropIn.h"
+#import "BTCardNonce.h"
+#import "BTDataCollector.h"
+
+#import "BraintreeApplePay.h"
+
+@interface RNBraintreeDropIn : NSObject <RCTBridgeModule, PKPaymentAuthorizationViewControllerDelegate>
+
+@property (nonatomic, strong) UIViewController *_Nonnull reactRoot;
+
+// Retain your `BTDataCollector` instance for your entire application lifecycle.
+@property (nonatomic, strong) BTDataCollector *_Nonnull dataCollector;
+
+@property (nonatomic, strong) BTAPIClient *_Nonnull braintreeClient;
+
+@property (nonatomic, strong) PKPaymentRequest *_Nonnull paymentRequest;
+
+@property (nonatomic, strong) PKPaymentAuthorizationViewController *_Nonnull viewController;
+
+@property (nonatomic, strong) NSString * _Nonnull deviceDataCollector;
+
+@property (nonatomic) RCTPromiseResolveBlock _Nonnull resolve;
+
+@property (nonatomic) RCTPromiseRejectBlock _Nonnull reject;
+
+@property (nonatomic, assign) BOOL applePayAuthorized;
+
++ (void)resolvePayment:(BTDropInResult* _Nullable)result deviceData:(NSString * _Nonnull)deviceDataCollector resolver:(RCTPromiseResolveBlock _Nonnull)resolve;
+
+@end

package/ios/RNBraintreeDropIn.m

@@ -0,0 +1,280 @@
+#import "RNBraintreeDropIn.h"
+#import <React/RCTUtils.h>
+#import "BTThreeDSecureRequest.h"
+
+@implementation RNBraintreeDropIn
+
+- (dispatch_queue_t)methodQueue
+{
+    return dispatch_get_main_queue();
+}
+RCT_EXPORT_MODULE(RNBraintreeDropIn)
+
+RCT_EXPORT_METHOD(show:(NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    BTDropInColorScheme colorScheme;
+  
+    if([options[@"darkTheme"] boolValue]){
+        if (@available(iOS 13.0, *)) {
+            colorScheme = BTDropInColorSchemeDynamic;
+        } else {
+            colorScheme = BTDropInColorSchemeDark;
+        }
+    } else {
+        colorScheme = BTDropInColorSchemeLight;
+    }
+
+    BTDropInUICustomization *uiCustomization = [[BTDropInUICustomization alloc] initWithColorScheme:colorScheme];
+
+    if(options[@"fontFamily"]){
+        uiCustomization.fontFamily = options[@"fontFamily"];
+    }
+    if(options[@"boldFontFamily"]){
+        uiCustomization.boldFontFamily = options[@"boldFontFamily"];
+    }
+
+    self.resolve = resolve;
+    self.reject = reject;
+    self.applePayAuthorized = NO;
+
+    NSString* clientToken = options[@"clientToken"];
+    if (!clientToken) {
+        reject(@"NO_CLIENT_TOKEN", @"You must provide a client token", nil);
+        return;
+    }
+
+    BTDropInRequest *request = [[BTDropInRequest alloc] init];
+    request.uiCustomization = uiCustomization;
+
+    NSDictionary* threeDSecureOptions = options[@"threeDSecure"];
+    if (threeDSecureOptions) {
+        NSNumber* threeDSecureAmount = threeDSecureOptions[@"amount"];
+        if (!threeDSecureAmount) {
+            reject(@"NO_3DS_AMOUNT", @"You must provide an amount for 3D Secure", nil);
+            return;
+        }
+
+        BTThreeDSecureRequest *threeDSecureRequest = [[BTThreeDSecureRequest alloc] init];
+        threeDSecureRequest.amount = [NSDecimalNumber decimalNumberWithString:threeDSecureAmount.stringValue];
+        request.threeDSecureRequest = threeDSecureRequest;
+
+    }
+
+    BTAPIClient *apiClient = [[BTAPIClient alloc] initWithAuthorization:clientToken];
+    self.dataCollector = [[BTDataCollector alloc] initWithAPIClient:apiClient];
+    [self.dataCollector collectDeviceData:^(NSString * _Nonnull deviceDataCollector) {
+        // Save deviceData
+        self.deviceDataCollector = deviceDataCollector;
+    }];
+
+    if([options[@"vaultManager"] boolValue]){
+        request.vaultManager = YES;
+    }
+
+    if([options[@"cardDisabled"] boolValue]){
+        request.cardDisabled = YES;
+    }
+
+    if([options[@"applePay"] boolValue]){
+        NSString* merchantIdentifier = options[@"merchantIdentifier"];
+        NSString* countryCode = options[@"countryCode"];
+        NSString* currencyCode = options[@"currencyCode"];
+        NSString* merchantName = options[@"merchantName"];
+        NSDecimalNumber* orderTotal = [NSDecimalNumber decimalNumberWithDecimal:[options[@"orderTotal"] decimalValue]];
+        if(!merchantIdentifier || !countryCode || !currencyCode || !merchantName || !orderTotal){
+            reject(@"MISSING_OPTIONS", @"Not all required Apple Pay options were provided", nil);
+            return;
+        }
+        self.braintreeClient = [[BTAPIClient alloc] initWithAuthorization:clientToken];
+
+        self.paymentRequest = [[PKPaymentRequest alloc] init];
+        self.paymentRequest.merchantIdentifier = merchantIdentifier;
+        self.paymentRequest.merchantCapabilities = PKMerchantCapability3DS;
+        self.paymentRequest.countryCode = countryCode;
+        self.paymentRequest.currencyCode = currencyCode;
+        self.paymentRequest.supportedNetworks = @[PKPaymentNetworkAmex, PKPaymentNetworkVisa, PKPaymentNetworkMasterCard, PKPaymentNetworkDiscover, PKPaymentNetworkChinaUnionPay];
+        self.paymentRequest.paymentSummaryItems =
+            @[
+                [PKPaymentSummaryItem summaryItemWithLabel:merchantName amount:orderTotal]
+            ];
+
+        self.viewController = [[PKPaymentAuthorizationViewController alloc] initWithPaymentRequest: self.paymentRequest];
+        self.viewController.delegate = self;
+    }else{
+        request.applePayDisabled = YES;
+    }
+    
+    if(![options[@"payPal"] boolValue]){ //disable paypal
+        request.paypalDisabled = YES;
+    }
+
+    BTDropInController *dropIn = [[BTDropInController alloc] initWithAuthorization:clientToken request:request handler:^(BTDropInController * _Nonnull controller, BTDropInResult * _Nullable result, NSError * _Nullable error) {
+            [self.reactRoot dismissViewControllerAnimated:YES completion:nil];
+
+            //result.paymentOptionType == .ApplePay
+            //NSLog(@"paymentOptionType = %ld", result.paymentOptionType);
+
+            if (error != nil) {
+                reject(error.localizedDescription, error.localizedDescription, error);
+            } else if (result.canceled) {
+                reject(@"USER_CANCELLATION", @"The user cancelled", nil);
+            } else {
+                if (threeDSecureOptions && [result.paymentMethod isKindOfClass:[BTCardNonce class]]) {
+                    BTCardNonce *cardNonce = (BTCardNonce *)result.paymentMethod;
+                    if (!cardNonce.threeDSecureInfo.liabilityShiftPossible && cardNonce.threeDSecureInfo.wasVerified) {
+                        reject(@"3DSECURE_NOT_ABLE_TO_SHIFT_LIABILITY", @"3D Secure liability cannot be shifted", nil);
+                    } else if (!cardNonce.threeDSecureInfo.liabilityShifted && cardNonce.threeDSecureInfo.wasVerified) {
+                        reject(@"3DSECURE_LIABILITY_NOT_SHIFTED", @"3D Secure liability was not shifted", nil);
+                    } else{
+                        [[self class] resolvePayment:result deviceData:self.deviceDataCollector resolver:resolve];
+                    }
+                } else if(result.paymentMethod == nil && (result.paymentMethodType == 16 || result.paymentMethodType == 17 || result.paymentMethodType == 18)){ //Apple Pay
+                    // UIViewController *ctrl = [[[[UIApplication sharedApplication] delegate] window] rootViewController];
+                    // [ctrl presentViewController:self.viewController animated:YES completion:nil];
+                    UIViewController *rootViewController = RCTPresentedViewController();
+                    [rootViewController presentViewController:self.viewController animated:YES completion:nil];
+                } else{
+                    [[self class] resolvePayment:result deviceData:self.deviceDataCollector resolver:resolve];
+                }
+            }
+        }];
+
+    if (dropIn != nil) {
+        [self.reactRoot presentViewController:dropIn animated:YES completion:nil];
+    } else {
+        reject(@"INVALID_CLIENT_TOKEN", @"The client token seems invalid", nil);
+    }
+}
+
+RCT_EXPORT_METHOD(fetchMostRecentPaymentMethod:(NSString*)clientToken
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  [BTDropInResult mostRecentPaymentMethodForClientToken:clientToken completion:^(BTDropInResult * _Nullable result, NSError * _Nullable error) {
+    if (error != nil) {
+        reject(error.localizedDescription, error.localizedDescription, error);
+    } else if (result.canceled) {
+        reject(@"USER_CANCELLATION", @"The user cancelled", nil);
+    } else {
+      [[self class] resolvePayment:result deviceData:result.deviceData resolver:resolve];
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(tokenizeCard:(NSString*)clientToken
+                          info:(NSDictionary*)cardInfo
+                      resolver:(RCTPromiseResolveBlock)resolve
+                      rejecter:(RCTPromiseRejectBlock)reject)
+{
+    NSString *number = cardInfo[@"number"];
+    NSString *expirationMonth = cardInfo[@"expirationMonth"];
+    NSString *expirationYear = cardInfo[@"expirationYear"];
+    NSString *cvv = cardInfo[@"cvv"];
+    NSString *postalCode = cardInfo[@"postalCode"];
+
+    if (!number || !expirationMonth || !expirationYear || !cvv || !postalCode) {
+        reject(@"INVALID_CARD_INFO", @"Invalid card info", nil);
+        return;
+    }
+    
+    BTAPIClient *braintreeClient = [[BTAPIClient alloc] initWithAuthorization:clientToken];
+    BTCardClient *cardClient = [[BTCardClient alloc] initWithAPIClient:braintreeClient];
+    BTCard *card = [[BTCard alloc] init];
+    card.number = number;
+    card.expirationMonth = expirationMonth;
+    card.expirationYear = expirationYear;
+    card.cvv = cvv;
+    card.postalCode = postalCode;
+
+    [cardClient tokenizeCard:card
+                  completion:^(BTCardNonce *tokenizedCard, NSError *error) {
+        if (error == nil) {
+            resolve(tokenizedCard.nonce);
+        } else {
+            reject(@"TOKENIZE_ERROR", @"Error tokenizing card.", error);
+        }
+    }];
+}
+
+- (void)paymentAuthorizationViewController:(PKPaymentAuthorizationViewController *)controller
+                       didAuthorizePayment:(PKPayment *)payment
+                                handler:(nonnull void (^)(PKPaymentAuthorizationResult * _Nonnull))completion
+{
+
+    // Example: Tokenize the Apple Pay payment
+    BTApplePayClient *applePayClient = [[BTApplePayClient alloc]
+                                        initWithAPIClient:self.braintreeClient];
+    [applePayClient tokenizeApplePayPayment:payment
+                                 completion:^(BTApplePayCardNonce *tokenizedApplePayPayment,
+                                              NSError *error) {
+        if (tokenizedApplePayPayment) {
+            // On success, send nonce to your server for processing.
+            // If applicable, address information is accessible in `payment`.
+            // NSLog(@"description = %@", tokenizedApplePayPayment.localizedDescription);
+
+            completion([[PKPaymentAuthorizationResult alloc] initWithStatus:PKPaymentAuthorizationStatusSuccess errors:nil]);
+            self.applePayAuthorized = YES;
+
+
+            NSMutableDictionary* result = [NSMutableDictionary new];
+            [result setObject:tokenizedApplePayPayment.nonce forKey:@"nonce"];
+            [result setObject:@"Apple Pay" forKey:@"type"];
+            [result setObject:[NSString stringWithFormat: @"%@ %@", @"", tokenizedApplePayPayment.type] forKey:@"description"];
+            [result setObject:[NSNumber numberWithBool:false] forKey:@"isDefault"];
+            [result setObject:self.deviceDataCollector forKey:@"deviceData"];
+
+            self.resolve(result);
+
+        } else {
+            // Tokenization failed. Check `error` for the cause of the failure.
+
+            // Indicate failure via the completion callback:
+            completion([[PKPaymentAuthorizationResult alloc] initWithStatus:PKPaymentAuthorizationStatusFailure errors:nil]);
+        }
+    }];
+}
+
+// Be sure to implement -paymentAuthorizationViewControllerDidFinish:
+- (void)paymentAuthorizationViewControllerDidFinish:(PKPaymentAuthorizationViewController *)controller{
+    [self.reactRoot dismissViewControllerAnimated:YES completion:nil];
+    if(self.applePayAuthorized == NO){
+        self.reject(@"USER_CANCELLATION", @"The user cancelled", nil);
+    }
+}
+
++ (void)resolvePayment:(BTDropInResult* _Nullable)result deviceData:(NSString * _Nonnull)deviceDataCollector resolver:(RCTPromiseResolveBlock _Nonnull)resolve {
+    //NSLog(@"result = %@", result);
+
+    if (!result) {
+        resolve(nil);
+        return;
+    }
+
+    NSMutableDictionary* jsResult = [NSMutableDictionary new];
+
+    //NSLog(@"paymentMethod = %@", result.paymentMethod);
+    //NSLog(@"paymentIcon = %@", result.paymentIcon);
+
+    [jsResult setObject:result.paymentMethod.nonce forKey:@"nonce"];
+    [jsResult setObject:result.paymentMethod.type forKey:@"type"];
+    [jsResult setObject:result.paymentDescription forKey:@"description"];
+    [jsResult setObject:[NSNumber numberWithBool:result.paymentMethod.isDefault] forKey:@"isDefault"];
+    [jsResult setObject:deviceDataCollector forKey:@"deviceData"];
+
+    resolve(jsResult);
+}
+
+- (UIViewController*)reactRoot {
+    UIViewController *root  = [UIApplication sharedApplication].keyWindow.rootViewController;
+    UIViewController *maybeModal = root.presentedViewController;
+
+    UIViewController *modalRoot = root;
+
+    if (maybeModal != nil) {
+        modalRoot = maybeModal;
+    }
+
+    return modalRoot;
+}
+
+@end