@stripe/stripe-react-native 0.2.1 → 0.3.0

package/android/src/main/java/com/reactnativestripesdk/StripeSdkModule.kt

@@ -6,12 +6,12 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.os.AsyncTask
-import android.os.Bundle
 import android.os.Parcelable
 import android.util.Log
 import androidx.activity.ComponentActivity
 import androidx.appcompat.app.AppCompatActivity
 import androidx.lifecycle.lifecycleScope
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
 import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
 import com.stripe.android.*
@@ -20,13 +20,14 @@ import com.stripe.android.googlepaylauncher.GooglePayPaymentMethodLauncher
 import com.stripe.android.model.*
 import com.stripe.android.paymentsheet.PaymentSheetResult
 import com.stripe.android.view.AddPaymentMethodActivityStarter
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.*
+
 
 @ReactModule(name = StripeSdkModule.NAME)
-class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+class StripeSdkModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
   var cardFieldView: StripeSdkCardView? = null
   var cardFormView: CardFormView? = null
+  private lateinit var localBroadcastManager: LocalBroadcastManager
 
   override fun getName(): String {
     return "StripeSdk"
@@ -221,9 +222,6 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
   private val mPaymentSheetReceiver: BroadcastReceiver = object : BroadcastReceiver() {
     override fun onReceive(context: Context?, intent: Intent) {
-      if (intent.action == ON_FRAGMENT_CREATED) {
-        paymentSheetFragment = (currentActivity as AppCompatActivity).supportFragmentManager.findFragmentByTag("payment_sheet_launch_fragment") as PaymentSheetFragment
-      }
       if (intent.action == ON_PAYMENT_RESULT_ACTION) {
         when (val result = intent.extras?.getParcelable<PaymentSheetResult>("paymentResult")) {
           is PaymentSheetResult.Canceled -> {
@@ -297,16 +295,16 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
     PaymentConfiguration.init(reactApplicationContext, publishableKey, stripeAccountId)
 
-    this.currentActivity?.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_PAYMENT_RESULT_ACTION));
-    this.currentActivity?.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_PAYMENT_OPTION_ACTION));
-    this.currentActivity?.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_CONFIGURE_FLOW_CONTROLLER));
-    this.currentActivity?.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_FRAGMENT_CREATED));
-    this.currentActivity?.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_INIT_PAYMENT_SHEET));
+    val localBroadcastManager = LocalBroadcastManager.getInstance(reactApplicationContext)
+    localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_PAYMENT_RESULT_ACTION));
+    localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_PAYMENT_OPTION_ACTION));
+    localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_CONFIGURE_FLOW_CONTROLLER));
+    localBroadcastManager.registerReceiver(mPaymentSheetReceiver, IntentFilter(ON_INIT_PAYMENT_SHEET));
 
-    this.currentActivity?.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAY_FRAGMENT_CREATED))
-    this.currentActivity?.registerReceiver(googlePayReceiver, IntentFilter(ON_INIT_GOOGLE_PAY))
-    this.currentActivity?.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAY_RESULT))
-    this.currentActivity?.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAYMENT_METHOD_RESULT))
+    localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAY_FRAGMENT_CREATED))
+    localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_INIT_GOOGLE_PAY))
+    localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAY_RESULT))
+    localBroadcastManager.registerReceiver(googlePayReceiver, IntentFilter(ON_GOOGLE_PAYMENT_METHOD_RESULT))
 
     promise.resolve(null)
   }
@@ -322,12 +320,12 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
     this.initPaymentSheetPromise = promise
 
-    val fragment = PaymentSheetFragment().also {
+    paymentSheetFragment = PaymentSheetFragment().also {
       val bundle = toBundleObject(params)
       it.arguments = bundle
     }
     activity.supportFragmentManager.beginTransaction()
-      .add(fragment, "payment_sheet_launch_fragment")
+      .add(paymentSheetFragment!!, "payment_sheet_launch_fragment")
       .commit()
   }
 
@@ -399,21 +397,61 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
   @ReactMethod
   fun createToken(params: ReadableMap, promise: Promise) {
-    val type = getValOr(params, "type", null)?.let {
-      if (it != "Card") {
-        promise.resolve(createError(CreateTokenErrorType.Failed.toString(), "$it type is not supported yet"))
-        return
+    val type = getValOr(params, "type", null)
+    if (type == null) {
+      promise.resolve(createError(CreateTokenErrorType.Failed.toString(), "type parameter is required"))
+      return
+    }
+
+    when (type) {
+      "BankAccount" -> {
+        createTokenFromBankAccount(params, promise)
+      }
+      "Card" -> {
+        createTokenFromCard(params, promise)
+      }
+      else -> {
+        promise.resolve(createError(CreateTokenErrorType.Failed.toString(), "$type type is not supported yet"))
       }
     }
-    val address = getMapOrNull(params, "address")
+  }
 
-    val cardParamsMap = (cardFieldView?.cardParams ?: cardFormView?.cardParams)?.toParamMap() ?: run {
-      promise.resolve(createError(CreateTokenErrorType.Failed.toString(), "Card details not complete"))
-      return
+  private fun createTokenFromBankAccount(params: ReadableMap, promise: Promise) {
+    val accountHolderName = getValOr(params, "accountHolderName", null)
+    val accountHolderType = getValOr(params, "accountHolderType", null)
+    val accountNumber = getValOr(params, "accountNumber", null)
+    val country = getValOr(params, "country", null)
+    val currency = getValOr(params, "currency", null)
+    val routingNumber = getValOr(params, "routingNumber", null)
+
+    val bankAccountParams = BankAccountTokenParams(
+      country = country!!,
+      currency = currency!!,
+      accountNumber = accountNumber!!,
+      accountHolderName = accountHolderName,
+      routingNumber = routingNumber,
+      accountHolderType = mapToBankAccountType(accountHolderType)
+    )
+    CoroutineScope(Dispatchers.IO).launch {
+      runCatching {
+        val token = stripe.createBankAccountToken(bankAccountParams, null, stripeAccountId)
+        promise.resolve(createResult("token", mapFromToken(token)))
+      }.onFailure {
+        promise.resolve(createError(CreateTokenErrorType.Failed.toString(), it.message))
+      }
     }
 
-    val cardAddress = cardFieldView?.cardAddress ?: cardFormView?.cardAddress
+  }
 
+  private fun createTokenFromCard(params: ReadableMap, promise: Promise) {
+    val cardParamsMap = (cardFieldView?.cardParams ?: cardFormView?.cardParams)?.toParamMap()
+      ?: run {
+        promise.resolve(createError(CreateTokenErrorType.Failed.toString(), "Card details not complete"))
+        return
+      }
+
+    val cardAddress = cardFieldView?.cardAddress ?: cardFormView?.cardAddress
+    val address = getMapOrNull(params, "address")
     val cardParams = CardParams(
       number = cardParamsMap["number"] as String,
       expMonth = cardParamsMap["exp_month"] as Int,
@@ -422,7 +460,8 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
       address = mapToAddress(address, cardAddress),
       name = getValOr(params, "name", null)
     )
-    runBlocking {
+
+    CoroutineScope(Dispatchers.IO).launch {
       try {
         val token = stripe.createCardToken(
           cardParams = cardParams,
@@ -564,6 +603,20 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
   }
 
+  @ReactMethod
+  fun isGooglePaySupported(params: ReadableMap?, promise: Promise) {
+    val fragment = GooglePayPaymentMethodLauncherFragment(
+      currentActivity as AppCompatActivity,
+      getBooleanOrFalse(params, "testEnv"),
+      getBooleanOrFalse(params, "existingPaymentMethodRequired"),
+      promise
+    )
+
+    (currentActivity as AppCompatActivity).supportFragmentManager.beginTransaction()
+      .add(fragment, "google_pay_support_fragment")
+      .commit()
+  }
+
   @ReactMethod
   fun initGooglePay(params: ReadableMap, promise: Promise) {
     val activity = currentActivity as AppCompatActivity

package/ios/CardFieldView.swift

@@ -127,12 +127,18 @@ class CardFieldView: UIView, STPPaymentCardTextFieldDelegate {
     func paymentCardTextFieldDidChange(_ textField: STPPaymentCardTextField) {
         if onCardChange != nil {
             let brand = STPCardValidator.brand(forNumber: textField.cardParams.number ?? "")
+            let validExpiryDate = STPCardValidator.validationState(forExpirationYear: textField.cardParams.expYear?.stringValue ?? "", inMonth: textField.cardParams.expMonth?.stringValue ?? "")
+            let validCVC = STPCardValidator.validationState(forCVC: textField.cardParams.cvc ?? "", cardBrand: brand)
+            let validNumber = STPCardValidator.validationState(forNumber: textField.cardParams.number ?? "", validatingCardBrand: true)
             var cardData: [String: Any?] = [
                 "expiryMonth": textField.cardParams.expMonth ?? NSNull(),
                 "expiryYear": textField.cardParams.expYear ?? NSNull(),
                 "complete": textField.isValid,
                 "brand": Mappers.mapCardBrand(brand) ?? NSNull(),
-                "last4": textField.cardParams.last4 ?? ""
+                "last4": textField.cardParams.last4 ?? "",
+                "validExpiryDate": Mappers.mapFromCardValidationState(state: validExpiryDate),
+                "validCVC": Mappers.mapFromCardValidationState(state: validCVC),
+                "validNumber": Mappers.mapFromCardValidationState(state: validNumber)
             ]
             if (cardField.postalCodeEntryEnabled) {
                 cardData["postalCode"] = textField.postalCode ?? ""