@stripe/stripe-react-native 0.67.0 → 0.69.0

package/android/build.gradle

@@ -164,11 +164,11 @@ dependencies {
   implementation("com.stripe:stripe-android:$stripeVersion")
   implementation("com.stripe:financial-connections:$stripeVersion")
   implementation("com.stripe:payment-method-messaging:$stripeVersion")
-  
+
   if (isOnrampIncluded()) {
     implementation("com.stripe:crypto-onramp:$stripeVersion")
   }
-  
+
   implementation "com.google.android.material:material:1.3.0"
   implementation "androidx.appcompat:appcompat:1.4.1"
   implementation "androidx.legacy:legacy-support-v4:1.0.0"
@@ -179,7 +179,7 @@ dependencies {
   compileOnly "com.google.android.gms:play-services-wallet:19.3.0"
 
   // Users need to declare this dependency on their own, otherwise all methods are a no-op
-  compileOnly "com.stripe:stripe-android-issuing-push-provisioning:1.1.0"
+  compileOnly "com.stripe:stripe-android-issuing-push-provisioning:1.3.0"
 
   testImplementation "junit:junit:4.13"
   testImplementation "org.mockito:mockito-core:3.+"

package/android/gradle.properties

@@ -3,4 +3,4 @@ StripeSdk_compileSdkVersion=36
 StripeSdk_targetSdkVersion=36
 StripeSdk_minSdkVersion=23
 # Keep StripeSdk_stripeVersion in sync with https://github.com/stripe/stripe-identity-react-native/blob/main/android/gradle.properties
-StripeSdk_stripeVersion=23.10.+
+StripeSdk_stripeVersion=23.12.0

package/android/proguard-rules.txt

@@ -5,3 +5,7 @@
 -keepclassmembers class com.stripe.android.pushProvisioning.** {
   public *;
 }
+
+# play-services-tapandpay is a private Google SDK that must be provided by the app.
+# Suppress R8 warnings when it is absent (e.g. in the example app build).
+-dontwarn com.google.android.gms.tapandpay.**

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

@@ -0,0 +1,229 @@
+package com.reactnativestripesdk
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.Configuration
+import androidx.compose.ui.graphics.Color
+import androidx.core.graphics.toColorInt
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.reactnativestripesdk.utils.PaymentSheetAppearanceException
+import com.stripe.android.checkout.Checkout
+import com.stripe.android.paymentelement.CheckoutSessionPreview
+
+@OptIn(CheckoutSessionPreview::class)
+@SuppressLint("RestrictedApi")
+fun buildCurrencySelectorAppearance(
+  params: ReadableMap?,
+  context: Context,
+): Checkout.CurrencySelectorContentAppearance {
+  val appearance = Checkout.CurrencySelectorContentAppearance()
+
+  params ?: return appearance
+
+  applyCurrencySelectorColors(appearance, params, context)
+  applyCurrencySelectorDimensions(appearance, params)
+  applyCurrencySelectorFont(appearance, params, context)
+  applyCurrencySelectorLabelContent(appearance, params)
+
+  return appearance
+}
+
+@OptIn(CheckoutSessionPreview::class)
+@SuppressLint("RestrictedApi")
+private fun applyCurrencySelectorColors(
+  appearance: Checkout.CurrencySelectorContentAppearance,
+  params: ReadableMap,
+  context: Context,
+) {
+  dynamicColorFromParams(context, params, CurrencySelectorAppearanceKeys.BACKGROUND)?.let {
+    appearance.background(it)
+  }
+  dynamicColorFromParams(context, params, CurrencySelectorAppearanceKeys.SELECTED_BACKGROUND)?.let {
+    appearance.selectedBackground(it)
+  }
+  dynamicColorFromParams(context, params, CurrencySelectorAppearanceKeys.BORDER_COLOR)?.let {
+    appearance.borderColor(it)
+  }
+  dynamicColorFromParams(context, params, CurrencySelectorAppearanceKeys.TEXT_COLOR)?.let {
+    appearance.textColor(it)
+  }
+  dynamicColorFromParams(context, params, CurrencySelectorAppearanceKeys.SELECTED_TEXT_COLOR)?.let {
+    appearance.selectedTextColor(it)
+  }
+  dynamicColorFromParams(context, params, CurrencySelectorAppearanceKeys.TEXT_SECONDARY_COLOR)?.let {
+    appearance.textSecondaryColor(it)
+  }
+  dynamicColorFromParams(context, params, CurrencySelectorAppearanceKeys.DANGER_COLOR)?.let {
+    appearance.dangerColor(it)
+  }
+}
+
+@OptIn(CheckoutSessionPreview::class)
+@SuppressLint("RestrictedApi")
+private fun applyCurrencySelectorDimensions(
+  appearance: Checkout.CurrencySelectorContentAppearance,
+  params: ReadableMap,
+) {
+  getFloatOrNull(params, CurrencySelectorAppearanceKeys.CORNER_RADIUS)?.let {
+    appearance.cornerRadiusDp(it)
+  }
+  getFloatOrNull(params, CurrencySelectorAppearanceKeys.BORDER_WIDTH)?.let {
+    appearance.borderWidthDp(it)
+  }
+  getFloatOrNull(params, CurrencySelectorAppearanceKeys.CONTENT_VERTICAL_PADDING)?.let {
+    appearance.contentVerticalPaddingDp(it)
+  }
+}
+
+@OptIn(CheckoutSessionPreview::class)
+@SuppressLint("RestrictedApi")
+private fun applyCurrencySelectorFont(
+  appearance: Checkout.CurrencySelectorContentAppearance,
+  params: ReadableMap,
+  context: Context,
+) {
+  params.getMap(CurrencySelectorAppearanceKeys.FONT)?.let { font ->
+    getCurrencySelectorFontResId(font, CurrencySelectorAppearanceKeys.FAMILY, context)?.let {
+      appearance.fontResId(it)
+    }
+    getFloatOrNull(font, CurrencySelectorAppearanceKeys.SCALE)?.let {
+      appearance.sizeScaleFactor(it)
+    }
+  }
+}
+
+@OptIn(CheckoutSessionPreview::class)
+@SuppressLint("RestrictedApi")
+private fun applyCurrencySelectorLabelContent(
+  appearance: Checkout.CurrencySelectorContentAppearance,
+  params: ReadableMap,
+) {
+  when (params.getString(CurrencySelectorAppearanceKeys.LABEL_CONTENT)) {
+    CurrencySelectorAppearanceKeys.AMOUNT -> {
+      appearance.labelContent(Checkout.CurrencySelectorContentAppearance.LabelContent.AMOUNT)
+    }
+    CurrencySelectorAppearanceKeys.CURRENCY_CODE -> {
+      appearance.labelContent(Checkout.CurrencySelectorContentAppearance.LabelContent.CURRENCY_CODE)
+    }
+    CurrencySelectorAppearanceKeys.AUTOMATIC -> {
+      appearance.labelContent(Checkout.CurrencySelectorContentAppearance.LabelContent.AUTOMATIC)
+    }
+  }
+}
+
+private fun dynamicColorFromParams(
+  context: Context,
+  params: ReadableMap?,
+  key: String,
+): Color? {
+  if (params == null) {
+    return null
+  }
+
+  if (params.hasKey(key) && params.getType(key) == ReadableType.Map) {
+    val colorMap = params.getMap(key)
+    val isDark =
+      (
+        context.resources.configuration.uiMode
+          and Configuration.UI_MODE_NIGHT_MASK
+      ) == Configuration.UI_MODE_NIGHT_YES
+
+    val hex =
+      if (isDark) {
+        colorMap?.getString(CurrencySelectorAppearanceKeys.DARK)
+      } else {
+        colorMap?.getString(CurrencySelectorAppearanceKeys.LIGHT)
+      }
+
+    return colorFromHex(hex)?.let { Color(it) }
+  }
+
+  return colorFromHex(params.getString(key))?.let { Color(it) }
+}
+
+private fun colorFromHex(hexString: String?): Int? =
+  hexString?.trim()?.replace("#", "")?.let {
+    if (it.length == HEX_COLOR_LENGTH_RGB || it.length == HEX_COLOR_LENGTH_ARGB) {
+      "#$it".toColorInt()
+    } else {
+      android.util.Log.w(
+        "StripeCurrencySelector",
+        "Invalid hex color: expected length 6 or 8, but received: $it",
+      )
+      null
+    }
+  }
+
+private fun getFloatOrNull(
+  map: ReadableMap?,
+  key: String,
+): Float? =
+  if (map?.hasKey(key) == true && map.getType(key) == ReadableType.Number) {
+    map.getDouble(key).toFloat()
+  } else {
+    null
+  }
+
+@SuppressLint("DiscouragedApi")
+private fun getCurrencySelectorFontResId(
+  map: ReadableMap?,
+  key: String,
+  context: Context,
+): Int? {
+  val fontErrorPrefix = "Encountered an error when setting a custom font:"
+  if (map?.hasKey(key) != true) {
+    return null
+  }
+
+  val fontFileName = map.getString(key)
+  val validationError =
+    when {
+      fontFileName == null ->
+        "$fontErrorPrefix expected String for font.$key, but received null."
+      Regex("[^a-z0-9_]").containsMatchIn(fontFileName) ->
+        "$fontErrorPrefix appearance.font.$key should only contain " +
+          "lowercase alphanumeric characters and underscores on Android, " +
+          "but received '$fontFileName'. " +
+          "This value must match the filename in android/app/src/main/res/font"
+      else -> null
+    }
+  if (validationError != null) {
+    throw PaymentSheetAppearanceException(validationError)
+  }
+
+  val id = context.resources.getIdentifier(fontFileName, "font", context.packageName)
+  if (id == 0) {
+    throw PaymentSheetAppearanceException("$fontErrorPrefix Failed to find font: $fontFileName")
+  }
+  return id
+}
+
+private object CurrencySelectorAppearanceKeys {
+  const val LIGHT = "light"
+  const val DARK = "dark"
+
+  const val BACKGROUND = "background"
+  const val SELECTED_BACKGROUND = "selectedBackground"
+  const val BORDER_COLOR = "borderColor"
+  const val TEXT_COLOR = "textColor"
+  const val SELECTED_TEXT_COLOR = "selectedTextColor"
+  const val TEXT_SECONDARY_COLOR = "textSecondaryColor"
+  const val DANGER_COLOR = "dangerColor"
+
+  const val CORNER_RADIUS = "cornerRadius"
+  const val BORDER_WIDTH = "borderWidth"
+  const val CONTENT_VERTICAL_PADDING = "contentVerticalPadding"
+
+  const val FONT = "font"
+  const val FAMILY = "family"
+  const val SCALE = "scale"
+
+  const val LABEL_CONTENT = "labelContent"
+  const val AUTOMATIC = "automatic"
+  const val CURRENCY_CODE = "currencyCode"
+  const val AMOUNT = "amount"
+}
+
+private const val HEX_COLOR_LENGTH_RGB = 6
+private const val HEX_COLOR_LENGTH_ARGB = 8

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

@@ -20,6 +20,7 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.UIManagerHelper
+import com.stripe.android.checkout.Checkout
 import com.stripe.android.paymentelement.CheckoutSessionPreview
 
 @OptIn(CheckoutSessionPreview::class)
@@ -31,6 +32,7 @@ class CurrencySelectorElementView(
   // Backing state for props. mutableStateOf so Compose recomposes on changes.
   private var sessionKeyState = mutableStateOf<String?>(null)
   private var disabledState = mutableStateOf(false)
+  private var appearanceState = mutableStateOf(Checkout.CurrencySelectorContentAppearance())
 
   fun setSessionKey(value: String?) {
     sessionKeyState.value = value?.takeIf { it.isNotEmpty() }
@@ -40,11 +42,16 @@ class CurrencySelectorElementView(
     disabledState.value = value
   }
 
+  fun setAppearance(value: Checkout.CurrencySelectorContentAppearance) {
+    appearanceState.value = value
+  }
+
   @SuppressLint("RestrictedApi")
   @Composable
   override fun Content() {
     val sessionKey by remember { sessionKeyState }
     val disabled by remember { disabledState }
+    val appearance by remember { appearanceState }
 
     val checkout = remember(sessionKey) {
       sessionKey?.let { key ->
@@ -63,7 +70,7 @@ class CurrencySelectorElementView(
         reportHeightChange = { reportHeightChange(it) },
       ) {
         Box {
-          checkout.CurrencySelectorContent()
+          checkout.CurrencySelectorContent(appearance = appearance)
           if (disabled) {
             // The Stripe Android composable doesn't yet expose an `isEnabled`
             // parameter, so swallow taps with a transparent pointer-input

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

@@ -1,5 +1,7 @@
 package com.reactnativestripesdk
 
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableType
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
@@ -56,4 +58,13 @@ class CurrencySelectorElementViewManager :
   ) {
     view.setDisabled(value)
   }
+
+  @ReactProp(name = "appearance")
+  override fun setAppearance(
+    view: CurrencySelectorElementView,
+    value: Dynamic?,
+  ) {
+    val appearanceParams = if (value?.type == ReadableType.Map) value.asMap() else null
+    view.setAppearance(buildCurrencySelectorAppearance(appearanceParams, view.context))
+  }
 }

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

@@ -64,10 +64,6 @@ class EmbeddedPaymentElementView(
       val intentConfiguration: PaymentSheet.IntentConfiguration,
     ) : Event
 
-    data class UpdateWithCheckout(
-      val checkout: Checkout,
-    ) : Event
-
     data object Confirm : Event
 
     data object ClearPaymentOption : Event
@@ -347,20 +343,6 @@ class EmbeddedPaymentElementView(
             latestIntentConfig = ev.intentConfiguration
           }
 
-          is Event.UpdateWithCheckout -> {
-            val elemConfig = latestElementConfig ?: return@collect emitUpdateMissingConfiguration()
-
-            val result =
-              embedded.configure(
-                checkout = ev.checkout,
-                configuration = elemConfig,
-              )
-
-            handleUpdateResult(result)
-
-            latestCheckout = ev.checkout
-          }
-
           is Event.Confirm -> {
             embedded.confirm()
           }
@@ -506,10 +488,6 @@ class EmbeddedPaymentElementView(
     events.trySend(Event.Update(intentConfig))
   }
 
-  fun updateWithCheckout(checkout: Checkout) {
-    events.trySend(Event.UpdateWithCheckout(checkout))
-  }
-
   fun confirm() {
     events.trySend(Event.Confirm)
   }

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

@@ -244,28 +244,6 @@ class EmbeddedPaymentElementViewManager :
     }
   }
 
-  override fun updateWithCheckout(
-    view: EmbeddedPaymentElementView,
-    sessionKey: String?,
-  ) {
-    if (sessionKey == null) return
-
-    val stripeSdkModule =
-      (view.context as ThemedReactContext).getNativeModule(StripeSdkModule::class.java)
-    val checkout = stripeSdkModule?.checkoutInstances?.get(sessionKey)
-    if (checkout == null) {
-      val payload =
-        Arguments.createMap().apply {
-          putString("message", "Checkout session not found.")
-        }
-      stripeSdkModule?.eventEmitter?.emitEmbeddedPaymentElementLoadingFailed(payload)
-      stripeSdkModule?.eventEmitter?.emitEmbeddedPaymentElementUpdateComplete(null)
-      return
-    }
-
-    view.updateWithCheckout(checkout)
-  }
-
   private fun jsonToWritableMap(json: JSONObject): WritableMap {
     val map = Arguments.createMap()
     val keys = json.keys()

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

@@ -0,0 +1,175 @@
+package com.reactnativestripesdk
+
+import androidx.activity.ComponentActivity
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.lifecycleScope
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.reactnativestripesdk.utils.ErrorType
+import com.reactnativestripesdk.utils.createError
+import com.reactnativestripesdk.utils.mapFromPaymentMethod
+import com.stripe.android.link.LinkController
+import com.stripe.android.link.LinkControllerPreview
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+internal const val LINK_CONTROLLER_NOT_INITIALIZED_ERROR =
+    "LinkController has not been initialized. Call initLinkController first."
+
+/**
+ * Manages [LinkController] initialization and presentation for the React Native bridge.
+ *
+ * @PrivatePreview
+ */
+@OptIn(LinkControllerPreview::class)
+internal class LinkControllerManager(
+    private val context: ReactApplicationContext,
+    private val publishableKey: String,
+    private val stripeAccountId: String?,
+) {
+    private var linkController: LinkController? = null
+    private var linkPresenter: LinkController.Presenter? = null
+    private var presentPromise: Promise? = null
+
+    fun configure(params: ReadableMap, promise: Promise) {
+        val email = params.getString("email")
+        val merchantDisplayName = params.getString("merchantDisplayName")
+        if (merchantDisplayName == null) {
+            promise.resolve(createError(ErrorType.Failed.toString(), "merchantDisplayName is required."))
+            return
+        }
+
+        val activity = context.currentActivity as? ComponentActivity
+        if (activity == null) {
+            promise.resolve(createError(ErrorType.Failed.toString(), "Activity is not available. Retry this method."))
+            return
+        }
+
+        val phoneNumber = params.getString("phoneNumber")
+        val allowLogout = if (params.hasKey("allowLogout")) params.getBoolean("allowLogout") else true
+        val setupIntentClientSecret = params.getString("setupIntentClientSecret")
+
+        val supportedTypes = parseSupportedPaymentMethodTypes(params)
+
+        val config = LinkController.Configuration(
+            merchantDisplayName = merchantDisplayName,
+            publishableKey = publishableKey,
+            stripeAccountId = stripeAccountId
+        )
+            .also { if (email != null) it.email(email) }
+            .phoneNumber(phoneNumber)
+            .supportedPaymentMethodTypes(supportedTypes)
+            .allowLogout(allowLogout)
+            .setupIntentClientSecret(setupIntentClientSecret)
+
+        // Build a new controller if this is the first call or after a reset.
+        // SavedStateHandle() is empty — state will not survive process death, which is
+        // the same trade-off made by other Stripe RN SDK APIs.
+        if (linkController == null) {
+            linkController = LinkController.Builder(
+                application = activity.application,
+                savedStateHandle = SavedStateHandle()
+            ).build()
+        }
+
+        val controller = linkController!!
+
+        activity.lifecycleScope.launch {
+            val result = controller.configure(config)
+            if (result.isSuccess) {
+                // Create once: presenter may register ActivityResultLaunchers, which must happen before onStart().
+                if (linkPresenter == null) {
+                    linkPresenter = controller.createPresenter(
+                        activity = activity,
+                        presentCallback = { presentResult -> handlePresentResult(presentResult) }
+                    )
+                }
+                promise.resolve(Arguments.createMap())
+            } else {
+                promise.resolve(
+                    createError(
+                        ErrorType.Failed.toString(),
+                        result.exceptionOrNull()?.message ?: "LinkController configuration failed."
+                    )
+                )
+            }
+        }
+    }
+
+    fun present(promise: Promise) {
+        val presenter = linkPresenter
+        if (presenter == null) {
+            promise.resolve(createError(ErrorType.Failed.toString(), LINK_CONTROLLER_NOT_INITIALIZED_ERROR))
+            return
+        }
+
+        presentPromise = promise
+        presenter.present()
+    }
+
+    fun destroy() {
+        linkController = null
+        linkPresenter = null
+        presentPromise = null
+    }
+
+    private fun parseSupportedPaymentMethodTypes(params: ReadableMap): List<LinkController.PaymentMethodType>? =
+        params.getArray("supportedPaymentMethodTypes")?.let { arr ->
+            (0 until arr.size()).mapNotNull { i ->
+                when (arr.getString(i)) {
+                    "card" -> LinkController.PaymentMethodType.Card
+                    "bankAccount" -> LinkController.PaymentMethodType.BankAccount
+                    else -> null
+                }
+            }.ifEmpty { null }
+        }
+
+    private fun handlePresentResult(result: LinkController.PresentResult) {
+        val promise = presentPromise ?: return
+        val controller = linkController ?: return
+        when (result) {
+            is LinkController.PresentResult.Completed -> {
+                val response = Arguments.createMap()
+                response.putMap("paymentMethod", mapFromPaymentMethod(result.paymentMethod))
+
+                val preview = controller.paymentMethodPreview.value
+                val currentScope = (context.currentActivity as? ComponentActivity)?.lifecycleScope
+                if (preview != null && currentScope != null) {
+                    currentScope.launch {
+                        val iconBase64 = withContext(Dispatchers.IO) {
+                            try {
+                                convertDrawableToBase64(preview.icon)
+                            } catch (_: Exception) {
+                                null
+                            }
+                        }
+                        val previewMap = Arguments.createMap()
+                        previewMap.putString("label", preview.label)
+                        preview.sublabel?.let { previewMap.putString("sublabel", it) }
+                        if (iconBase64 != null) {
+                            previewMap.putString("icon", "data:image/png;base64,$iconBase64")
+                        }
+                        response.putMap("paymentMethodPreview", previewMap)
+                        promise.resolve(response)
+                    }
+                } else {
+                    promise.resolve(response)
+                }
+            }
+            is LinkController.PresentResult.Canceled -> {
+                promise.resolve(
+                    createError(
+                        ErrorType.Canceled.toString(),
+                        "The customer canceled the Link flow."
+                    )
+                )
+            }
+            is LinkController.PresentResult.Failed -> {
+                promise.resolve(createError(ErrorType.Failed.toString(), result.error))
+            }
+        }
+    }
+}

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

@@ -239,6 +239,16 @@ class PaymentSheetManager(
       return
     }
 
+    if (checkoutSessionKey != null) {
+      promise.resolve(
+        createError(
+          ErrorType.Failed.toString(),
+          "PaymentSheet with checkout is not supported. Use customFlow: true instead.",
+        ),
+      )
+      return
+    }
+
     lastConfigureWasCustomFlow = false
     if (paymentSheet == null) {
       initPaymentSheet(args, promise)
@@ -437,10 +447,7 @@ class PaymentSheetManager(
   override fun onPresent() {
     keepJsAwake = KeepJsAwakeTask(context).apply { start() }
     if (lastConfigureWasCustomFlow == false) {
-      val checkout = getCheckoutInstanceOrResolveError(promise)
-      if (checkout != null) {
-        paymentSheet?.presentWithCheckout(checkout, paymentSheetConfiguration)
-      } else if (!paymentIntentClientSecret.isNullOrEmpty()) {
+      if (!paymentIntentClientSecret.isNullOrEmpty()) {
         paymentSheet?.presentWithPaymentIntent(
           paymentIntentClientSecret!!,
           paymentSheetConfiguration,