@stripe/stripe-react-native 0.30.0 → 0.31.1

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+## 0.31.0 - 2023-09-08
+
+**Features**
+
+- **[BETA]** Added [CustomerSheet](https://stripe.com/docs/elements/customer-sheet?platform=react-native) API, a prebuilt UI component that lets your customers manage their saved payment methods. [#1491](https://github.com/stripe/stripe-react-native/pull/1491)
+- [PaymentSheet] Added support for AmazonPay (private beta), BLIK (iOS only), GrabPay, and FPX with PaymentIntents. [#1491](https://github.com/stripe/stripe-react-native/pull/1491)
+
+**Fixes**
+
+- Fixed font scaling on Android PaymentSheet not respecting floating-point number values. [#1469](https://github.com/stripe/stripe-react-native/pull/1469)
+
 ## 0.30.0 - 2023-08-04
 
 **Features**

package/android/gradle.properties

@@ -1,3 +1,3 @@
 StripeSdk_kotlinVersion=1.8.0
 # Keep StripeSdk_stripeVersion in sync with https://github.com/stripe/stripe-identity-react-native/blob/main/android/gradle.properties
-StripeSdk_stripeVersion=20.28.+
+StripeSdk_stripeVersion=20.29.+

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

@@ -22,9 +22,11 @@ fun buildPaymentSheetAppearance(userParams: Bundle?, context: Context): PaymentS
 }
 
 private fun buildTypography(fontParams: Bundle?, context: Context): PaymentSheet.Typography {
+  val scale = getDoubleOrNull(fontParams, PaymentSheetAppearanceKeys.SCALE)
+  val resId = getFontResId(fontParams, PaymentSheetAppearanceKeys.FAMILY, PaymentSheet.Typography.default.fontResId, context)
   return PaymentSheet.Typography.default.copy(
-    sizeScaleFactor = getFloatOr(fontParams, PaymentSheetAppearanceKeys.SCALE, PaymentSheet.Typography.default.sizeScaleFactor),
-    fontResId = getFontResId(fontParams, PaymentSheetAppearanceKeys.FAMILY, PaymentSheet.Typography.default.fontResId, context)
+    sizeScaleFactor = scale?.toFloat() ?: PaymentSheet.Typography.default.sizeScaleFactor,
+    fontResId = resId
   )
 }
 
@@ -105,20 +107,49 @@ private fun buildPrimaryButtonColors(colorParams: Bundle, default: PaymentSheet.
   )
 }
 
+private fun getDoubleOrNull(bundle: Bundle?, key: String): Double? {
+  if (bundle?.containsKey(key) == true) {
+    val valueOfUnknownType = bundle.get(key)
+    if (valueOfUnknownType is Double) {
+      return valueOfUnknownType
+    } else if (valueOfUnknownType is Int) {
+      return valueOfUnknownType.toDouble()
+    } else if (valueOfUnknownType is Float) {
+      return valueOfUnknownType.toDouble()
+    }
+  }
+
+  return null
+}
+
 private fun getFloatOr(bundle: Bundle?, key: String, defaultValue: Float): Float {
-  return if (bundle?.containsKey(key) == true) {
-    bundle.getFloat(key, bundle.getInt(key).toFloat())
-  } else {
-    defaultValue
+  if (bundle?.containsKey(key) == true) {
+    val valueOfUnknownType = bundle.get(key)
+    if (valueOfUnknownType is Float) {
+      return valueOfUnknownType
+    } else if (valueOfUnknownType is Int) {
+      return valueOfUnknownType.toFloat()
+    } else if (valueOfUnknownType is Double) {
+      return valueOfUnknownType.toFloat()
+    }
   }
+
+  return defaultValue
 }
 
 private fun getFloatOrNull(bundle: Bundle?, key: String): Float? {
-  return if (bundle?.containsKey(key) == true) {
-    bundle.getFloat(key, bundle.getInt(key).toFloat())
-  } else {
-    null
+  if (bundle?.containsKey(key) == true) {
+    val valueOfUnknownType = bundle.get(key)
+    if (valueOfUnknownType is Float) {
+      return valueOfUnknownType
+    } else if (valueOfUnknownType is Int) {
+      return valueOfUnknownType.toFloat()
+    } else if (valueOfUnknownType is Double) {
+      return valueOfUnknownType.toFloat()
+    }
   }
+
+  return null
 }
 
 @Throws(PaymentSheetAppearanceException::class)

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

@@ -6,6 +6,7 @@ import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.Canvas
 import android.graphics.Color
+import android.graphics.drawable.Drawable
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
@@ -399,10 +400,16 @@ class PaymentSheetFragment(
 }
 
 fun getBitmapFromVectorDrawable(context: Context?, drawableId: Int): Bitmap? {
-  var drawable = AppCompatResources.getDrawable(context!!, drawableId) ?: return null
+  val drawable = AppCompatResources.getDrawable(context!!, drawableId) ?: return null
+  return getBitmapFromDrawable(drawable)
+}
 
-  drawable = DrawableCompat.wrap(drawable).mutate()
-  val bitmap = Bitmap.createBitmap(drawable.intrinsicWidth, drawable.intrinsicHeight, Bitmap.Config.ARGB_8888)
+fun getBitmapFromDrawable(drawable: Drawable): Bitmap? {
+  val drawableCompat = DrawableCompat.wrap(drawable).mutate()
+  if (drawableCompat.intrinsicWidth <= 0 || drawableCompat.intrinsicHeight <= 0) {
+    return null
+  }
+  val bitmap = Bitmap.createBitmap(drawableCompat.intrinsicWidth, drawableCompat.intrinsicHeight, Bitmap.Config.ARGB_8888)
   bitmap.eraseColor(Color.WHITE)
   val canvas = Canvas(bitmap)
   drawable.setBounds(0, 0, canvas.width, canvas.height)

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

@@ -22,6 +22,7 @@ import com.stripe.android.view.AddPaymentMethodActivityStarter
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import org.json.JSONObject
 
 
 @ReactModule(name = StripeSdkModule.NAME)
@@ -44,10 +45,11 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   private var platformPayUsesDeprecatedTokenFlow = false
 
   private var paymentSheetFragment: PaymentSheetFragment? = null
-  private var googlePayFragment: GooglePayFragment? = null
   private var paymentLauncherFragment: PaymentLauncherFragment? = null
   private var collectBankAccountLauncherFragment: CollectBankAccountLauncherFragment? = null
 
+  private var customerSheetFragment: CustomerSheetFragment? = null
+
   internal var eventListenerCount = 0
 
   // If you create a new Fragment, you must put the tag here, otherwise result callbacks for that
@@ -55,12 +57,12 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   private val allStripeFragmentTags: List<String>
     get() = listOf(
       PaymentSheetFragment.TAG,
-      GooglePayFragment.TAG,
       PaymentLauncherFragment.TAG,
       CollectBankAccountLauncherFragment.TAG,
       FinancialConnectionsSheetFragment.TAG,
       AddressLauncherFragment.TAG,
-      GooglePayLauncherFragment.TAG
+      GooglePayLauncherFragment.TAG,
+      CustomerSheetFragment.TAG
     )
 
   private val mActivityEventListener = object : BaseActivityEventListener() {
@@ -503,11 +505,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   fun retrievePaymentIntent(clientSecret: String, promise: Promise) {
     CoroutineScope(Dispatchers.IO).launch {
       val paymentIntent = stripe.retrievePaymentIntentSynchronous(clientSecret)
-      paymentIntent?.let {
-        promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(it)))
-      } ?: run {
-        promise.resolve(createError(RetrievePaymentIntentErrorType.Unknown.toString(), "Failed to retrieve the PaymentIntent"))
-      }
+      promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(paymentIntent)))
     }
   }
 
@@ -515,11 +513,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
   fun retrieveSetupIntent(clientSecret: String, promise: Promise) {
     CoroutineScope(Dispatchers.IO).launch {
       val setupIntent = stripe.retrieveSetupIntentSynchronous(clientSecret)
-      setupIntent?.let {
-        promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(it)))
-      } ?: run {
-        promise.resolve(createError(RetrieveSetupIntentErrorType.Unknown.toString(), "Failed to retrieve the SetupIntent"))
-      }
+      promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(setupIntent)))
     }
   }
 
@@ -572,62 +566,6 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
   }
 
-  @ReactMethod
-  fun isGooglePaySupported(params: ReadableMap?, promise: Promise) {
-    val fragment = GooglePayPaymentMethodLauncherFragment(
-      reactApplicationContext,
-      getBooleanOrFalse(params, "testEnv"),
-      getBooleanOrFalse(params, "existingPaymentMethodRequired"),
-      promise
-    )
-
-    getCurrentActivityOrResolveWithError(promise)?.let {
-      try {
-        it.supportFragmentManager.beginTransaction()
-          .add(fragment, GooglePayPaymentMethodLauncherFragment.TAG)
-          .commit()
-      } catch (error: IllegalStateException) {
-        promise.resolve(createError(ErrorType.Failed.toString(), error.message))
-      }
-    }
-  }
-
-  @ReactMethod
-  fun initGooglePay(params: ReadableMap, promise: Promise) {
-    googlePayFragment = GooglePayFragment(promise).also {
-      val bundle = toBundleObject(params)
-      it.arguments = bundle
-    }
-
-    getCurrentActivityOrResolveWithError(promise)?.let {
-      try {
-        it.supportFragmentManager.beginTransaction()
-          .add(googlePayFragment!!, GooglePayFragment.TAG)
-          .commit()
-      } catch (error: IllegalStateException) {
-        promise.resolve(createError(ErrorType.Failed.toString(), error.message))
-      }
-    }
-  }
-
-  @ReactMethod
-  fun presentGooglePay(params: ReadableMap, promise: Promise) {
-    val clientSecret = getValOr(params, "clientSecret") ?: run {
-      promise.resolve(createError(GooglePayErrorType.Failed.toString(), "you must provide clientSecret"))
-      return
-    }
-
-    if (getBooleanOrFalse(params, "forSetupIntent")) {
-      val currencyCode = getValOr(params, "currencyCode") ?: run {
-        promise.resolve(createError(GooglePayErrorType.Failed.toString(), "you must provide currencyCode"))
-        return
-      }
-      googlePayFragment?.presentForSetupIntent(clientSecret, currencyCode, promise)
-    } else {
-      googlePayFragment?.presentForPaymentIntent(clientSecret, promise)
-    }
-  }
-
   @ReactMethod
   fun confirmPlatformPay(clientSecret: String, params: ReadableMap, isPaymentIntent: Boolean, promise: Promise) {
     if (!::stripe.isInitialized) {
@@ -684,19 +622,6 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
   }
 
-  @ReactMethod
-  fun createGooglePayPaymentMethod(params: ReadableMap, promise: Promise) {
-    val currencyCode = getValOr(params, "currencyCode", null) ?: run {
-      promise.resolve(createError(GooglePayErrorType.Failed.toString(), "you must provide currencyCode"))
-      return
-    }
-    val amount = getIntOrNull(params, "amount") ?: run {
-      promise.resolve(createError(GooglePayErrorType.Failed.toString(), "you must provide amount"))
-      return
-    }
-    googlePayFragment?.createPaymentMethod(currencyCode, amount, promise)
-  }
-
   @ReactMethod
   fun createPlatformPayPaymentMethod(params: ReadableMap, usesDeprecatedTokenFlow: Boolean, promise: Promise) {
     val googlePayParams: ReadableMap = params.getMap("googlePay") ?: run {
@@ -891,6 +816,128 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
   }
 
+  @ReactMethod
+  fun initCustomerSheet(params: ReadableMap, customerAdapterOverrides: ReadableMap, promise: Promise) {
+    if (!::stripe.isInitialized) {
+      promise.resolve(createMissingInitError())
+      return
+    }
+
+    getCurrentActivityOrResolveWithError(promise)?.let { activity ->
+      customerSheetFragment?.removeFragment(reactApplicationContext)
+      customerSheetFragment = CustomerSheetFragment().also {
+        it.context = reactApplicationContext
+        it.initPromise = promise
+        val bundle = toBundleObject(params)
+        bundle.putBundle("customerAdapter", toBundleObject(customerAdapterOverrides))
+        it.arguments = bundle
+      }
+      try {
+        activity.supportFragmentManager.beginTransaction()
+          .add(customerSheetFragment!!, CustomerSheetFragment.TAG)
+          .commit()
+      } catch (error: IllegalStateException) {
+        promise.resolve(createError(ErrorType.Failed.toString(), error.message))
+      }
+    }
+  }
+
+  @ReactMethod
+  fun presentCustomerSheet(params: ReadableMap, promise: Promise) {
+    var timeout: Long? = null
+    if (params.hasKey("timeout")) {
+      timeout = params.getInt("timeout").toLong()
+    }
+    customerSheetFragment?.present(timeout, promise) ?: run {
+      promise.resolve(CustomerSheetFragment.createMissingInitError())
+    }
+  }
+
+  @ReactMethod
+  fun retrieveCustomerSheetPaymentOptionSelection(promise: Promise) {
+    customerSheetFragment?.retrievePaymentOptionSelection(promise) ?: run {
+      promise.resolve(CustomerSheetFragment.createMissingInitError())
+    }
+  }
+
+  @ReactMethod
+  fun customerAdapterFetchPaymentMethodsCallback(paymentMethodJsonObjects: ReadableArray, promise: Promise) {
+    customerSheetFragment?.let { fragment ->
+      val paymentMethods = mutableListOf<PaymentMethod>()
+      for (paymentMethodJson in paymentMethodJsonObjects.toArrayList()) {
+        PaymentMethod.fromJson(JSONObject((paymentMethodJson as HashMap<*, *>)))?.let {
+          paymentMethods.add(it)
+        } ?: run {
+          Log.e("StripeReactNative", "There was an error converting Payment Method JSON to a Stripe Payment Method")
+        }
+      }
+      fragment.customerAdapter?.fetchPaymentMethodsCallback?.complete(paymentMethods)
+    } ?: run {
+      promise.resolve(CustomerSheetFragment.createMissingInitError())
+      return
+    }
+  }
+
+  @ReactMethod
+  fun customerAdapterAttachPaymentMethodCallback(paymentMethodJson: ReadableMap, promise: Promise) {
+    customerSheetFragment?.let {
+      val paymentMethod = PaymentMethod.fromJson(JSONObject(paymentMethodJson.toHashMap()))
+      if (paymentMethod == null) {
+        Log.e("StripeReactNative", "There was an error converting Payment Method JSON to a Stripe Payment Method")
+        return
+      }
+      it.customerAdapter?.attachPaymentMethodCallback?.complete(paymentMethod)
+    } ?: run {
+      promise.resolve(CustomerSheetFragment.createMissingInitError())
+      return
+    }
+  }
+
+  @ReactMethod
+  fun customerAdapterDetachPaymentMethodCallback(paymentMethodJson: ReadableMap, promise: Promise) {
+    customerSheetFragment?.let {
+      val paymentMethod = PaymentMethod.fromJson(JSONObject(paymentMethodJson.toHashMap()))
+      if (paymentMethod == null) {
+        Log.e("StripeReactNative", "There was an error converting Payment Method JSON to a Stripe Payment Method")
+        return
+      }
+      it.customerAdapter?.detachPaymentMethodCallback?.complete(paymentMethod)
+    } ?: run {
+      promise.resolve(CustomerSheetFragment.createMissingInitError())
+      return
+    }
+  }
+
+  @ReactMethod
+  fun customerAdapterSetSelectedPaymentOptionCallback(promise: Promise) {
+    customerSheetFragment?.let {
+      it.customerAdapter?.setSelectedPaymentOptionCallback?.complete(Unit)
+    } ?: run {
+      promise.resolve(CustomerSheetFragment.createMissingInitError())
+      return
+    }
+  }
+
+  @ReactMethod
+  fun customerAdapterFetchSelectedPaymentOptionCallback(paymentOption: String?, promise: Promise) {
+    customerSheetFragment?.let {
+      it.customerAdapter?.fetchSelectedPaymentOptionCallback?.complete(paymentOption)
+    } ?: run {
+      promise.resolve(CustomerSheetFragment.createMissingInitError())
+      return
+    }
+  }
+
+  @ReactMethod
+  fun customerAdapterSetupIntentClientSecretForCustomerAttachCallback(clientSecret: String, promise: Promise) {
+    customerSheetFragment?.let {
+      it.customerAdapter?.setupIntentClientSecretForCustomerAttachCallback?.complete(clientSecret)
+    } ?: run {
+      promise.resolve(CustomerSheetFragment.createMissingInitError())
+      return
+    }
+  }
+
   @ReactMethod
   fun addListener(eventName: String) {
     eventListenerCount++