@stripe/stripe-react-native 0.16.0 → 0.18.1

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+yarn lint && yarn typescript

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 ## Unreleased
 
+## 0.18.1 - 2022-08-19
+
+### Breaking changes
+
+### New features
+
+## Fixes
+
+- Fixed an issue where some promises on Android would never resolve when using React Native 0.65.x or under. [#1089](https://github.com/stripe/stripe-react-native/pull/1089).
+
+## 0.18.0 - 2022-08-17
+
+### Breaking changes
+
+- Your `compileSdkVersion` (in `android/build.gradle`) now must be at least `32`. Changing your `compileSdkVersion` does not change runtime behavior.
+
+### New features
+
+- `confirmPayment` can now be called with _just_ a client secret (e.g. `await confirmPayment("payment-intent-id")`), in other words the payment method can be excluded. If the payment method is excluded, it is assumed by the SDK that you have attached the payment method on the server-side during payment intent creation. [#1084](https://github.com/stripe/stripe-react-native/pull/1084)
+- Payment Sheet now supports Link on iOS. [#1086](https://github.com/stripe/stripe-react-native/pull/1086).
+
+### Fixes
+
+- Fixed a bug on Android where `collectBankAccountForPayment`, `collectBankAccountForSetup`, `collectBankAccountToken`, and `collectFinancialConnectionsAccounts` wouldn't work with Stripe Connect accounts. [#1086](https://github.com/stripe/stripe-react-native/pull/1086).
+- Upgraded `stripe-ios` to 22.7.+ and `stripe-android` to 20.9.+.
+
+## 0.17.0 - 2022-08-11
+
+### Breaking changes
+
+### New features
+
+- Added the [`collectBankAccountToken`](https://stripe.com/docs/financial-connections/connect-payouts?platform=react-native) & [`collectFinancialConnectionsAccounts`](https://stripe.com/docs/financial-connections/other-data-powered-products?platform=react-native) functions.
+
+### Fixes
+
+- Fixed an issue where `collectBankAccountForPayment` and `collectBankAccountForSetup` would fail on Android when using React Native 0.65.x or under. [#1059](https://github.com/stripe/stripe-react-native/pull/1059)
+- Fixed an issue where Android apps could crash with the error `IllegalStateException: Cannot remove Fragment attached to a different FragmentManager`. [#1054](https://github.com/stripe/stripe-react-native/pull/1054)
+- Bumped Gradle from 4.2.2 to 7.1.1. [#1058](https://github.com/stripe/stripe-react-native/pull/1058)
+
 ## 0.16.0 - 2022-07-22
 
 ### Breaking changes

package/README.md

@@ -73,7 +73,7 @@ to your `app.json` file, where `merchantIdentifier` is the Apple merchant ID obt
 #### Android
 
 - Android 5.0 (API level 21) and above
-  - Your `compileSdkVersion` must be `31`. See [this issue](https://github.com/stripe/stripe-react-native/issues/812) for potential workarounds.
+  - Your `compileSdkVersion` must be `32`. See [this issue](https://github.com/stripe/stripe-react-native/issues/812) for potential workarounds.
 - Android gradle plugin 4.x and above
 
 _Components_

package/android/build.gradle

@@ -8,7 +8,7 @@ buildscript {
   }
 
   dependencies {
-    classpath 'com.android.tools.build:gradle:4.2.2'
+    classpath 'com.android.tools.build:gradle:7.1.1'
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }

package/android/gradle.properties

@@ -1,2 +1,2 @@
-StripeSdk_kotlinVersion=1.6.10
-StripeSdk_stripeVersion=20.5.+
+StripeSdk_kotlinVersion=1.6.21
+StripeSdk_stripeVersion=20.9.+

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

@@ -209,7 +209,7 @@ class CardFieldView(context: ThemedReactContext) : FrameLayout(context) {
    */
   fun setCountryCode(countryString: String?) {
     if (mCardWidget.postalCodeEnabled) {
-      val countryCode = CountryCode.create(value = countryString ?: LocaleListCompat.getAdjustedDefault()[0].country)
+      val countryCode = CountryCode.create(value = countryString ?: LocaleListCompat.getAdjustedDefault()[0]?.country ?: "US")
       mCardWidget.postalCodeRequired = CountryUtils.doesCountryUsePostalCode(countryCode)
       setPostalCodeFilter(countryCode)
     }

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

@@ -24,6 +24,7 @@ import com.stripe.android.payments.bankaccount.navigation.CollectBankAccountResu
 class CollectBankAccountLauncherFragment(
   private val context: ReactApplicationContext,
   private val publishableKey: String,
+  private val stripeAccountId: String?,
   private val clientSecret: String,
   private val isPaymentIntent: Boolean,
   private val collectParams:  CollectBankAccountConfiguration.USBankAccount,
@@ -48,12 +49,14 @@ class CollectBankAccountLauncherFragment(
     if (isPaymentIntent) {
       collectBankAccountLauncher.presentWithPaymentIntent(
         publishableKey,
+        stripeAccountId,
         clientSecret,
         collectParams
       )
     } else {
       collectBankAccountLauncher.presentWithSetupIntent(
         publishableKey,
+        stripeAccountId,
         clientSecret,
         collectParams
       )
@@ -83,7 +86,11 @@ class CollectBankAccountLauncherFragment(
           promise.resolve(createError(ErrorType.Failed.toString(), result.error))
         }
       }
-      (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+      removeFragment(context)
     }
   }
+
+  companion object {
+    const val TAG = "collect_bank_account_launcher_fragment"
+  }
 }

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

@@ -0,0 +1,278 @@
+package com.reactnativestripesdk
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.appcompat.app.AppCompatActivity
+import androidx.fragment.app.Fragment
+import com.facebook.react.bridge.*
+import com.reactnativestripesdk.utils.*
+import com.reactnativestripesdk.utils.createError
+import com.reactnativestripesdk.utils.createMissingActivityError
+import com.reactnativestripesdk.utils.mapFromToken
+import com.stripe.android.financialconnections.FinancialConnectionsSheet
+import com.stripe.android.financialconnections.FinancialConnectionsSheetForTokenResult
+import com.stripe.android.financialconnections.FinancialConnectionsSheetResult
+import com.stripe.android.financialconnections.model.*
+
+class FinancialConnectionsSheetFragment : Fragment() {
+  enum class Mode {
+    ForToken, ForSession
+  }
+
+  private lateinit var promise: Promise
+  private lateinit var context: ReactApplicationContext
+  private lateinit var configuration: FinancialConnectionsSheet.Configuration
+  private lateinit var mode: Mode
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
+                            savedInstanceState: Bundle?): View {
+    return FrameLayout(requireActivity()).also {
+      it.visibility = View.GONE
+    }
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    when (mode) {
+      Mode.ForToken -> {
+        FinancialConnectionsSheet.createForBankAccountToken(
+          this,
+          ::onFinancialConnectionsSheetForTokenResult
+        ).present(
+          configuration = configuration
+        )
+      }
+      Mode.ForSession -> {
+        FinancialConnectionsSheet.create(
+          this,
+          ::onFinancialConnectionsSheetForDataResult
+        ).present(
+          configuration = configuration
+        )
+      }
+    }
+  }
+
+  private fun onFinancialConnectionsSheetForTokenResult(result: FinancialConnectionsSheetForTokenResult) {
+    when(result) {
+      is FinancialConnectionsSheetForTokenResult.Canceled -> {
+        promise.resolve(
+          createError(ErrorType.Canceled.toString(), "The flow has been canceled")
+        )
+      }
+      is FinancialConnectionsSheetForTokenResult.Failed -> {
+        promise.resolve(
+          createError(ErrorType.Failed.toString(), result.error)
+        )
+      }
+      is FinancialConnectionsSheetForTokenResult.Completed -> {
+        promise.resolve(createTokenResult(result))
+        (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+      }
+    }
+  }
+
+  private fun onFinancialConnectionsSheetForDataResult(result: FinancialConnectionsSheetResult) {
+    when(result) {
+      is FinancialConnectionsSheetResult.Canceled -> {
+        promise.resolve(
+          createError(ErrorType.Canceled.toString(), "The flow has been canceled")
+        )
+      }
+      is FinancialConnectionsSheetResult.Failed -> {
+        promise.resolve(
+          createError(ErrorType.Failed.toString(), result.error)
+        )
+      }
+      is FinancialConnectionsSheetResult.Completed -> {
+        promise.resolve(
+            WritableNativeMap().also {
+              it.putMap("session", mapFromSession(result.financialConnectionsSession))
+            }
+        )
+        (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+      }
+    }
+  }
+
+  fun presentFinancialConnectionsSheet(clientSecret: String, mode: Mode, publishableKey: String, stripeAccountId: String?, promise: Promise, context: ReactApplicationContext) {
+    this.promise = promise
+    this.context = context
+    this.mode = mode
+    this.configuration = FinancialConnectionsSheet.Configuration(
+      financialConnectionsSessionClientSecret = clientSecret,
+      publishableKey = publishableKey,
+      stripeAccountId = stripeAccountId,
+    )
+
+    (context.currentActivity as? AppCompatActivity)?.let {
+      attemptToCleanupPreviousFragment(it)
+      commitFragmentAndStartFlow(it)
+    } ?: run {
+      promise.resolve(createMissingActivityError())
+      return
+    }
+  }
+
+  private fun attemptToCleanupPreviousFragment(currentActivity: AppCompatActivity) {
+    currentActivity.supportFragmentManager.beginTransaction()
+      .remove(this)
+      .commitAllowingStateLoss()
+  }
+
+  private fun commitFragmentAndStartFlow(currentActivity: AppCompatActivity) {
+    try {
+      currentActivity.supportFragmentManager.beginTransaction()
+        .add(this, "financial_connections_sheet_launch_fragment")
+        .commit()
+    } catch (error: IllegalStateException) {
+      promise.resolve(createError(ErrorType.Failed.toString(), error.message))
+    }
+  }
+
+  companion object {
+    private fun createTokenResult(result: FinancialConnectionsSheetForTokenResult.Completed): WritableMap {
+      return WritableNativeMap().also {
+        it.putMap("session", mapFromSession(result.financialConnectionsSession))
+        it.putMap("token", mapFromToken(result.token))
+      }
+    }
+
+    private fun mapFromSession(financialConnectionsSession: FinancialConnectionsSession): WritableMap {
+      val session = WritableNativeMap()
+      session.putString("id", financialConnectionsSession.id)
+      session.putString("clientSecret", financialConnectionsSession.clientSecret)
+      session.putBoolean("livemode", financialConnectionsSession.livemode)
+      session.putArray("accounts", mapFromAccountsList(financialConnectionsSession.accounts))
+      return session
+    }
+
+    private fun mapFromAccountsList(accounts: FinancialConnectionsAccountList): ReadableArray {
+      val results: WritableArray = Arguments.createArray()
+      for (account in accounts.data) {
+        val map = WritableNativeMap()
+        map.putString("id", account.id)
+        map.putBoolean("livemode", account.livemode)
+        map.putString("displayName", account.displayName)
+        map.putString("status", mapFromStatus(account.status))
+        map.putString("institutionName", account.institutionName)
+        map.putString("last4", account.last4)
+        map.putDouble("created", account.created * 1000.0)
+        map.putMap("balance", mapFromAccountBalance(account.balance))
+        map.putMap("balanceRefresh", mapFromAccountBalanceRefresh(account.balanceRefresh))
+        map.putString("category", mapFromCategory(account.category))
+        map.putString("subcategory", mapFromSubcategory(account.subcategory))
+        map.putArray("permissions", (account.permissions?.map { permission -> mapFromPermission(permission) })?.toReadableArray())
+        map.putArray("supportedPaymentMethodTypes", (account.supportedPaymentMethodTypes.map { type -> mapFromSupportedPaymentMethodTypes(type) }).toReadableArray())
+        results.pushMap(map)
+      }
+      return results
+    }
+
+    private fun mapFromAccountBalance(balance: Balance?): WritableMap? {
+      if (balance == null) {
+        return null
+      }
+      val map = WritableNativeMap()
+      map.putDouble("asOf", balance.asOf * 1000.0)
+      map.putString("type", mapFromBalanceType(balance.type))
+      map.putMap("current", balance.current as ReadableMap)
+      WritableNativeMap().also {
+        it.putMap("available", balance.cash?.available as ReadableMap)
+        map.putMap("cash", it)
+      }
+      WritableNativeMap().also {
+        it.putMap("used", balance.credit?.used as ReadableMap)
+        map.putMap("credit", it)
+      }
+      return map
+    }
+
+    private fun mapFromAccountBalanceRefresh(balanceRefresh: BalanceRefresh?): WritableMap? {
+      if (balanceRefresh == null) {
+        return null
+      }
+      val map = WritableNativeMap()
+      map.putString("status", mapFromBalanceRefreshStatus(balanceRefresh.status))
+      map.putDouble("lastAttemptedAt", balanceRefresh.lastAttemptedAt * 1000.0)
+      return map
+    }
+
+    private fun mapFromStatus(status: FinancialConnectionsAccount.Status): String {
+      return when (status) {
+        FinancialConnectionsAccount.Status.ACTIVE -> "active"
+        FinancialConnectionsAccount.Status.DISCONNECTED -> "disconnected"
+        FinancialConnectionsAccount.Status.INACTIVE -> "inactive"
+        FinancialConnectionsAccount.Status.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromCategory(category: FinancialConnectionsAccount.Category): String {
+      return when (category) {
+        FinancialConnectionsAccount.Category.CASH -> "cash"
+        FinancialConnectionsAccount.Category.CREDIT -> "credit"
+        FinancialConnectionsAccount.Category.INVESTMENT -> "investment"
+        FinancialConnectionsAccount.Category.OTHER -> "other"
+        FinancialConnectionsAccount.Category.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromSubcategory(subcategory: FinancialConnectionsAccount.Subcategory): String {
+      return when (subcategory) {
+        FinancialConnectionsAccount.Subcategory.CHECKING -> "checking"
+        FinancialConnectionsAccount.Subcategory.CREDIT_CARD -> "creditCard"
+        FinancialConnectionsAccount.Subcategory.LINE_OF_CREDIT -> "lineOfCredit"
+        FinancialConnectionsAccount.Subcategory.MORTGAGE -> "mortgage"
+        FinancialConnectionsAccount.Subcategory.OTHER -> "other"
+        FinancialConnectionsAccount.Subcategory.SAVINGS -> "savings"
+        FinancialConnectionsAccount.Subcategory.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromPermission(permission: FinancialConnectionsAccount.Permissions): String {
+      return when (permission) {
+        FinancialConnectionsAccount.Permissions.PAYMENT_METHOD -> "paymentMethod"
+        FinancialConnectionsAccount.Permissions.BALANCES -> "balances"
+        FinancialConnectionsAccount.Permissions.OWNERSHIP -> "ownership"
+        FinancialConnectionsAccount.Permissions.TRANSACTIONS -> "transactions"
+        FinancialConnectionsAccount.Permissions.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromSupportedPaymentMethodTypes(type: FinancialConnectionsAccount.SupportedPaymentMethodTypes): String {
+      return when (type) {
+        FinancialConnectionsAccount.SupportedPaymentMethodTypes.US_BANK_ACCOUNT -> "usBankAccount"
+        FinancialConnectionsAccount.SupportedPaymentMethodTypes.LINK -> "link"
+        FinancialConnectionsAccount.SupportedPaymentMethodTypes.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromBalanceType(type: Balance.Type): String {
+      return when (type) {
+        Balance.Type.CASH -> "cash"
+        Balance.Type.CREDIT -> "credit"
+        Balance.Type.UNKNOWN -> "unparsable"
+      }
+    }
+
+    private fun mapFromBalanceRefreshStatus(status: BalanceRefresh.BalanceRefreshStatus?): String {
+      return when (status) {
+        BalanceRefresh.BalanceRefreshStatus.SUCCEEDED -> "succeeded"
+        BalanceRefresh.BalanceRefreshStatus.FAILED -> "failed"
+        BalanceRefresh.BalanceRefreshStatus.PENDING -> "pending"
+        BalanceRefresh.BalanceRefreshStatus.UNKNOWN -> "unparsable"
+        null -> "null"
+      }
+    }
+  }
+}
+
+fun List<String>.toReadableArray(): ReadableArray {
+  val results: WritableArray = Arguments.createArray()
+  for (s in this) {
+    results.pushString(s)
+  }
+  return results
+}

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

@@ -204,4 +204,8 @@ class GooglePayFragment(private val initPromise: Promise) : Fragment() {
       isPhoneNumberRequired = isPhoneNumberRequired
     )
   }
+
+  companion object {
+    const val TAG = "google_pay_launch_fragment"
+  }
 }

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

@@ -5,10 +5,10 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.FrameLayout
-import androidx.appcompat.app.AppCompatActivity
 import androidx.fragment.app.Fragment
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.reactnativestripesdk.utils.removeFragment
 import com.stripe.android.googlepaylauncher.GooglePayEnvironment
 import com.stripe.android.googlepaylauncher.GooglePayPaymentMethodLauncher
 
@@ -37,9 +37,13 @@ class GooglePayPaymentMethodLauncherFragment(
       ),
       readyCallback = {
         promise.resolve(it)
-        (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+        removeFragment(context)
       },
       resultCallback = {}
     )
   }
+
+  companion object {
+    const val TAG = "google_pay_support_fragment"
+  }
 }

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

@@ -110,7 +110,7 @@ class PaymentLauncherFragment(
       (context.currentActivity as? AppCompatActivity)?.let {
         try {
           it.supportFragmentManager.beginTransaction()
-            .add(fragment, "payment_launcher_fragment")
+            .add(fragment, TAG)
             .commit()
         } catch (error: IllegalStateException) {
           promise.resolve(createError(ErrorType.Failed.toString(), error.message))
@@ -119,6 +119,8 @@ class PaymentLauncherFragment(
         promise.resolve(createMissingActivityError())
       }
     }
+
+    const val TAG = "payment_launcher_fragment"
   }
 
   override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
@@ -154,25 +156,21 @@ class PaymentLauncherFragment(
         }
         is PaymentResult.Canceled -> {
           promise.resolve(createError(ConfirmPaymentErrorType.Canceled.toString(), message = null))
-          cleanup()
+          removeFragment(context)
         }
         is PaymentResult.Failed -> {
           promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), paymentResult.throwable))
-          cleanup()
+          removeFragment(context)
         }
       }
     }
   }
 
-  private fun cleanup() {
-    (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
-  }
-
   private fun retrieveSetupIntent(clientSecret: String, stripeAccountId: String?) {
     stripe.retrieveSetupIntent(clientSecret, stripeAccountId, object : ApiResultCallback<SetupIntent> {
       override fun onError(e: Exception) {
         promise.resolve(createError(ConfirmSetupIntentErrorType.Failed.toString(), e))
-        cleanup()
+        removeFragment(context)
       }
 
       override fun onSuccess(result: SetupIntent) {
@@ -204,7 +202,7 @@ class PaymentLauncherFragment(
             promise.resolve(createError(ConfirmSetupIntentErrorType.Unknown.toString(), "unhandled error: ${result.status}"))
           }
         }
-        cleanup()
+        removeFragment(context)
       }
     })
   }
@@ -213,7 +211,7 @@ class PaymentLauncherFragment(
     stripe.retrievePaymentIntent(clientSecret, stripeAccountId, object : ApiResultCallback<PaymentIntent> {
       override fun onError(e: Exception) {
         promise.resolve(createError(ConfirmPaymentErrorType.Failed.toString(), e))
-        cleanup()
+        removeFragment(context)
       }
 
       override fun onSuccess(result: PaymentIntent) {
@@ -245,7 +243,7 @@ class PaymentLauncherFragment(
             promise.resolve(createError(ConfirmPaymentErrorType.Unknown.toString(), "unhandled error: ${result.status}"))
           }
         }
-        cleanup()
+        removeFragment(context)
       }
     })
   }

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

@@ -203,14 +203,13 @@ class PaymentMethodCreateParamsFactory(
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
-  fun createParams(clientSecret: String, paymentMethodType: PaymentMethod.Type, isPaymentIntent: Boolean): ConfirmStripeIntentParams {
+  fun createParams(clientSecret: String, paymentMethodType: PaymentMethod.Type?, isPaymentIntent: Boolean): ConfirmStripeIntentParams {
     try {
       return when (paymentMethodType) {
         PaymentMethod.Type.Card -> createCardStripeIntentParams(clientSecret, isPaymentIntent)
         PaymentMethod.Type.USBankAccount -> createUSBankAccountStripeIntentParams(clientSecret, isPaymentIntent)
         PaymentMethod.Type.PayPal -> createPayPalStripeIntentParams(clientSecret, isPaymentIntent)
         PaymentMethod.Type.Affirm -> createAffirmStripeIntentParams(clientSecret, isPaymentIntent)
-
         PaymentMethod.Type.Ideal,
         PaymentMethod.Type.Alipay,
         PaymentMethod.Type.Sofort,
@@ -241,6 +240,7 @@ class PaymentMethodCreateParamsFactory(
             )
           }
         }
+        null -> ConfirmPaymentIntentParams.create(clientSecret)
         else -> {
           throw Exception("This paymentMethodType is not supported yet")
         }

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

@@ -95,7 +95,7 @@ class PaymentSheetFragment(
         is PaymentSheetResult.Completed -> {
           resolvePaymentResult(WritableNativeMap())
           // Remove the fragment now, we can be sure it won't be needed again if an intent is successful
-          (context.currentActivity as? AppCompatActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+          removeFragment(context)
         }
       }
     }
@@ -196,6 +196,8 @@ class PaymentSheetFragment(
   }
 
   companion object {
+    const val TAG = "payment_sheet_launch_fragment"
+
     internal fun buildGooglePayConfig(params: Bundle?): PaymentSheet.GooglePayConfiguration? {
       if (params == null) {
         return null