@stripe/stripe-react-native 0.57.0 → 0.57.1

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

@@ -0,0 +1,31 @@
+package com.reactnativestripesdk
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+@ReactModule(name = NavigationBarManager.REACT_CLASS)
+class NavigationBarManager : SimpleViewManager<NavigationBarView>() {
+  override fun getName() = REACT_CLASS
+
+  override fun getExportedCustomDirectEventTypeConstants() =
+    mutableMapOf(
+      EVENT_ON_CLOSE_BUTTON_PRESS to mutableMapOf("registrationName" to EVENT_ON_CLOSE_BUTTON_PRESS),
+    )
+
+  @ReactProp(name = "title")
+  fun setTitle(
+    view: NavigationBarView,
+    title: String?,
+  ) {
+    view.setTitle(title)
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): NavigationBarView = NavigationBarView(reactContext)
+
+  companion object {
+    const val REACT_CLASS = "NavigationBar"
+    private const val EVENT_ON_CLOSE_BUTTON_PRESS = "onCloseButtonPress"
+  }
+}

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

@@ -0,0 +1,120 @@
+package com.reactnativestripesdk
+
+import android.annotation.SuppressLint
+import android.graphics.Color
+import android.view.Gravity
+import android.widget.FrameLayout
+import android.widget.ImageButton
+import android.widget.TextView
+import androidx.appcompat.widget.Toolbar
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+@SuppressLint("ViewConstructor")
+class NavigationBarView(
+  context: ThemedReactContext,
+) : FrameLayout(context) {
+  private val toolbar: Toolbar
+  private val titleTextView: TextView
+  private var titleText: String? = null
+
+  init {
+    // Create Toolbar
+    toolbar =
+      Toolbar(context).apply {
+        layoutParams =
+          LayoutParams(
+            LayoutParams.MATCH_PARENT,
+            LayoutParams.WRAP_CONTENT,
+          )
+        setBackgroundColor(Color.WHITE)
+        elevation = 4f
+      }
+
+    // Create title TextView
+    titleTextView =
+      TextView(context).apply {
+        textSize = 17f
+        setTextColor(Color.BLACK)
+        gravity = Gravity.CENTER
+      }
+
+    // Add title to toolbar
+    val titleParams =
+      Toolbar
+        .LayoutParams(
+          Toolbar.LayoutParams.WRAP_CONTENT,
+          Toolbar.LayoutParams.WRAP_CONTENT,
+        ).apply {
+          gravity = Gravity.CENTER
+        }
+    toolbar.addView(titleTextView, titleParams)
+
+    // Create close button
+    val closeButton =
+      ImageButton(context).apply {
+        setImageDrawable(
+          context.resources.getDrawable(
+            android.R.drawable.ic_menu_close_clear_cancel,
+            null,
+          ),
+        )
+        setBackgroundColor(Color.TRANSPARENT)
+        setOnClickListener {
+          dispatchCloseButtonPress()
+        }
+      }
+
+    // Add close button to toolbar
+    val buttonParams =
+      Toolbar
+        .LayoutParams(
+          Toolbar.LayoutParams.WRAP_CONTENT,
+          Toolbar.LayoutParams.WRAP_CONTENT,
+        ).apply {
+          gravity = Gravity.END or Gravity.CENTER_VERTICAL
+          marginEnd = 16
+        }
+    toolbar.addView(closeButton, buttonParams)
+
+    // Add toolbar to this view
+    addView(toolbar)
+  }
+
+  fun setTitle(title: String?) {
+    titleText = title
+    titleTextView.text = title
+  }
+
+  private fun dispatchCloseButtonPress() {
+    val reactContext = context as ThemedReactContext
+    val event =
+      CloseButtonPressEvent(
+        UIManagerHelper.getSurfaceId(reactContext),
+        id,
+      )
+    UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)?.dispatchEvent(event)
+  }
+
+  override fun onMeasure(
+    widthMeasureSpec: Int,
+    heightMeasureSpec: Int,
+  ) {
+    super.onMeasure(widthMeasureSpec, heightMeasureSpec)
+    // Set a fixed height for the navigation bar
+    val desiredHeight = (56 * resources.displayMetrics.density).toInt()
+    val newHeightMeasureSpec = MeasureSpec.makeMeasureSpec(desiredHeight, MeasureSpec.EXACTLY)
+    super.onMeasure(widthMeasureSpec, newHeightMeasureSpec)
+  }
+
+  private class CloseButtonPressEvent(
+    surfaceId: Int,
+    viewId: Int,
+  ) : Event<CloseButtonPressEvent>(surfaceId, viewId) {
+    override fun getEventName() = "onCloseButtonPress"
+
+    override fun getEventData() = Arguments.createMap()
+  }
+}

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

@@ -0,0 +1,228 @@
+package com.reactnativestripesdk
+
+import com.facebook.react.bridge.ReadableMap
+import com.reactnativestripesdk.utils.PaymentSheetException
+import com.reactnativestripesdk.utils.getBooleanOr
+import com.reactnativestripesdk.utils.getIntOr
+import com.reactnativestripesdk.utils.getLongOr
+import com.reactnativestripesdk.utils.getStringList
+import com.reactnativestripesdk.utils.isEmpty
+import com.stripe.android.paymentelement.PaymentMethodOptionsSetupFutureUsagePreview
+import com.stripe.android.paymentsheet.PaymentSheet
+
+@Throws(PaymentSheetException::class)
+internal fun buildIntentConfiguration(intentConfigurationParams: ReadableMap?): PaymentSheet.IntentConfiguration? {
+  if (intentConfigurationParams == null) {
+    return null
+  }
+  val modeParams =
+    intentConfigurationParams.getMap("mode")
+      ?: throw PaymentSheetException(
+        "If `intentConfiguration` is provided, `intentConfiguration.mode` is required",
+      )
+
+  return PaymentSheet.IntentConfiguration(
+    mode = buildIntentConfigurationMode(modeParams),
+    paymentMethodTypes =
+      intentConfigurationParams.getStringList("paymentMethodTypes")?.toList()
+        ?: emptyList(),
+    onBehalfOf = intentConfigurationParams.getString("onBehalfOf"),
+  )
+}
+
+@OptIn(PaymentMethodOptionsSetupFutureUsagePreview::class)
+private fun buildIntentConfigurationMode(modeParams: ReadableMap): PaymentSheet.IntentConfiguration.Mode =
+  if (modeParams.hasKey("amount")) {
+    val currencyCode =
+      modeParams.getString("currencyCode")
+        ?: throw PaymentSheetException(
+          "You must provide a value to intentConfiguration.mode.currencyCode",
+        )
+    PaymentSheet.IntentConfiguration.Mode.Payment(
+      amount = modeParams.getLongOr("amount", 0),
+      currency = currencyCode,
+      setupFutureUse = mapToSetupFutureUse(modeParams.getString("setupFutureUsage")),
+      captureMethod = mapToCaptureMethod(modeParams.getString("captureMethod")),
+      paymentMethodOptions = mapToPaymentMethodOptions(modeParams.getMap("paymentMethodOptions")),
+    )
+  } else {
+    val setupFutureUsage =
+      mapToSetupFutureUse(modeParams.getString("setupFutureUsage"))
+        ?: throw PaymentSheetException(
+          "You must provide a value to intentConfiguration.mode.setupFutureUsage",
+        )
+    PaymentSheet.IntentConfiguration.Mode.Setup(
+      currency = modeParams.getString("currencyCode"),
+      setupFutureUse = setupFutureUsage,
+    )
+  }
+
+internal fun buildLinkConfig(params: ReadableMap?): PaymentSheet.LinkConfiguration {
+  if (params == null) {
+    return PaymentSheet.LinkConfiguration()
+  }
+
+  val display = mapStringToLinkDisplay(params.getString("display"))
+
+  return PaymentSheet.LinkConfiguration(
+    display = display,
+  )
+}
+
+private fun mapStringToLinkDisplay(value: String?): PaymentSheet.LinkConfiguration.Display =
+  when (value) {
+    "automatic" -> PaymentSheet.LinkConfiguration.Display.Automatic
+    "never" -> PaymentSheet.LinkConfiguration.Display.Never
+    else -> PaymentSheet.LinkConfiguration.Display.Automatic
+  }
+
+private val mapIntToButtonType =
+  mapOf(
+    1 to PaymentSheet.GooglePayConfiguration.ButtonType.Buy,
+    6 to PaymentSheet.GooglePayConfiguration.ButtonType.Book,
+    5 to PaymentSheet.GooglePayConfiguration.ButtonType.Checkout,
+    4 to PaymentSheet.GooglePayConfiguration.ButtonType.Donate,
+    11 to PaymentSheet.GooglePayConfiguration.ButtonType.Order,
+    1000 to PaymentSheet.GooglePayConfiguration.ButtonType.Pay,
+    7 to PaymentSheet.GooglePayConfiguration.ButtonType.Subscribe,
+    1001 to PaymentSheet.GooglePayConfiguration.ButtonType.Plain,
+  )
+
+internal fun buildGooglePayConfig(params: ReadableMap?): PaymentSheet.GooglePayConfiguration? {
+  if (params == null || params.isEmpty()) {
+    return null
+  }
+
+  val countryCode = params.getString("merchantCountryCode").orEmpty()
+  val currencyCode = params.getString("currencyCode").orEmpty()
+  val testEnv = params.getBooleanOr("testEnv", false)
+  val amount = params.getString("amount")?.toLongOrNull()
+  val label = params.getString("label")
+  val buttonType =
+    mapIntToButtonType[params.getIntOr("buttonType", 0)]
+      ?: PaymentSheet.GooglePayConfiguration.ButtonType.Pay
+
+  return PaymentSheet.GooglePayConfiguration(
+    environment =
+      if (testEnv) {
+        PaymentSheet.GooglePayConfiguration.Environment.Test
+      } else {
+        PaymentSheet.GooglePayConfiguration.Environment.Production
+      },
+    countryCode = countryCode,
+    currencyCode = currencyCode,
+    amount = amount,
+    label = label,
+    buttonType = buttonType,
+  )
+}
+
+@Throws(PaymentSheetException::class)
+internal fun buildCustomerConfiguration(map: ReadableMap?): PaymentSheet.CustomerConfiguration? {
+  val customerId = map?.getString("customerId").orEmpty()
+  val customerEphemeralKeySecret = map?.getString("customerEphemeralKeySecret").orEmpty()
+  val customerSessionClientSecret = map?.getString("customerSessionClientSecret").orEmpty()
+  return if (customerSessionClientSecret.isNotEmpty() &&
+    customerEphemeralKeySecret.isNotEmpty()
+  ) {
+    throw PaymentSheetException(
+      "`customerEphemeralKeySecret` and `customerSessionClientSecret` cannot both be set",
+    )
+  } else if (customerId.isNotEmpty() && customerSessionClientSecret.isNotEmpty()) {
+    PaymentSheet.CustomerConfiguration.createWithCustomerSession(
+      id = customerId,
+      clientSecret = customerSessionClientSecret,
+    )
+  } else if (customerId.isNotEmpty() && customerEphemeralKeySecret.isNotEmpty()) {
+    PaymentSheet.CustomerConfiguration(
+      id = customerId,
+      ephemeralKeySecret = customerEphemeralKeySecret,
+    )
+  } else {
+    null
+  }
+}
+
+internal fun buildBillingDetails(map: ReadableMap?): PaymentSheet.BillingDetails? {
+  if (map == null) {
+    return null
+  }
+  val addressMap = map.getMap("address")
+  val address =
+    PaymentSheet.Address(
+      addressMap?.getString("city"),
+      addressMap?.getString("country"),
+      addressMap?.getString("line1"),
+      addressMap?.getString("line2"),
+      addressMap?.getString("postalCode"),
+      addressMap?.getString("state"),
+    )
+  return PaymentSheet.BillingDetails(
+    address,
+    map.getString("email"),
+    map.getString("name"),
+    map.getString("phone"),
+  )
+}
+
+internal fun buildBillingDetailsCollectionConfiguration(map: ReadableMap?): PaymentSheet.BillingDetailsCollectionConfiguration =
+  PaymentSheet.BillingDetailsCollectionConfiguration(
+    name = mapToCollectionMode(map?.getString("name")),
+    phone = mapToCollectionMode(map?.getString("phone")),
+    email = mapToCollectionMode(map?.getString("email")),
+    address = mapToAddressCollectionMode(map?.getString("address")),
+    attachDefaultsToPaymentMethod = map.getBooleanOr("attachDefaultsToPaymentMethod", false),
+  )
+
+internal fun mapToCollectionMode(str: String?): PaymentSheet.BillingDetailsCollectionConfiguration.CollectionMode =
+  when (str) {
+    "automatic" -> PaymentSheet.BillingDetailsCollectionConfiguration.CollectionMode.Automatic
+    "never" -> PaymentSheet.BillingDetailsCollectionConfiguration.CollectionMode.Never
+    "always" -> PaymentSheet.BillingDetailsCollectionConfiguration.CollectionMode.Always
+    else -> PaymentSheet.BillingDetailsCollectionConfiguration.CollectionMode.Automatic
+  }
+
+internal fun mapToAddressCollectionMode(str: String?): PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode =
+  when (str) {
+    "automatic" ->
+      PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode.Automatic
+
+    "never" -> PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode.Never
+    "full" -> PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode.Full
+    else -> PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode.Automatic
+  }
+
+internal fun mapToCardBrandAcceptance(params: ReadableMap?): PaymentSheet.CardBrandAcceptance {
+  val cardBrandAcceptanceParams = params?.getMap("cardBrandAcceptance") ?: return PaymentSheet.CardBrandAcceptance.all()
+  val filter = cardBrandAcceptanceParams.getString("filter") ?: return PaymentSheet.CardBrandAcceptance.all()
+
+  return when (filter) {
+    "all" -> PaymentSheet.CardBrandAcceptance.all()
+    "allowed" -> {
+      val brands = cardBrandAcceptanceParams.getStringList("brands") ?: return PaymentSheet.CardBrandAcceptance.all()
+      val brandCategories = brands.mapNotNull { mapToCardBrandCategory(it) }
+      if (brandCategories.isEmpty()) {
+        return PaymentSheet.CardBrandAcceptance.all()
+      }
+      PaymentSheet.CardBrandAcceptance.allowed(brandCategories)
+    }
+    "disallowed" -> {
+      val brands = cardBrandAcceptanceParams.getStringList("brands") ?: return PaymentSheet.CardBrandAcceptance.all()
+      val brandCategories = brands.mapNotNull { mapToCardBrandCategory(it) }
+      if (brandCategories.isEmpty()) {
+        return PaymentSheet.CardBrandAcceptance.all()
+      }
+      PaymentSheet.CardBrandAcceptance.disallowed(brandCategories)
+    }
+    else -> PaymentSheet.CardBrandAcceptance.all()
+  }
+}
+
+internal fun mapToCardBrandCategory(brand: String): PaymentSheet.CardBrandAcceptance.BrandCategory? =
+  when (brand) {
+    "visa" -> PaymentSheet.CardBrandAcceptance.BrandCategory.Visa
+    "mastercard" -> PaymentSheet.CardBrandAcceptance.BrandCategory.Mastercard
+    "amex" -> PaymentSheet.CardBrandAcceptance.BrandCategory.Amex
+    "discover" -> PaymentSheet.CardBrandAcceptance.BrandCategory.Discover
+    else -> null
+  }

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

@@ -342,6 +342,7 @@ class PaymentLauncherManager(
       StripeIntent.NextActionType.DisplayOxxoDetails,
       StripeIntent.NextActionType.DisplayBoletoDetails,
       StripeIntent.NextActionType.DisplayKonbiniDetails,
+      StripeIntent.NextActionType.DisplayPayNowDetails,
       StripeIntent.NextActionType.VerifyWithMicrodeposits,
       StripeIntent.NextActionType.DisplayMultibancoDetails,
       StripeIntent.NextActionType.DisplayPayNowDetails,

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

@@ -6,6 +6,7 @@ import com.reactnativestripesdk.utils.getValOr
 import com.reactnativestripesdk.utils.mapToBillingDetails
 import com.reactnativestripesdk.utils.mapToMetadata
 import com.reactnativestripesdk.utils.mapToPaymentIntentFutureUsage
+import com.reactnativestripesdk.utils.mapToShippingDetails
 import com.reactnativestripesdk.utils.mapToUSBankAccountHolderType
 import com.reactnativestripesdk.utils.mapToUSBankAccountType
 import com.stripe.android.model.ConfirmPaymentIntentParams
@@ -403,10 +404,12 @@ class PaymentMethodCreateParamsFactory(
     }
 
     val params = createAffirmParams()
+    val shippingDetails = mapToShippingDetails(paymentMethodData?.getMap("shippingDetails"))
 
     return ConfirmPaymentIntentParams.createWithPaymentMethodCreateParams(
       paymentMethodCreateParams = params,
       clientSecret = clientSecret,
+      shipping = shippingDetails,
       setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(options, "setupFutureUsage")),
       mandateData = buildMandateDataParams(),
     )

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

@@ -11,8 +11,6 @@ import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.unit.TextUnit
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
-import com.reactnativestripesdk.getBase64FromBitmap
-import com.reactnativestripesdk.getBitmapFromDrawable
 import com.reactnativestripesdk.utils.mapFromPaymentSheetBillingDetails
 import com.stripe.android.paymentelement.EmbeddedPaymentElement
 import kotlinx.coroutines.Dispatchers
@@ -50,7 +48,7 @@ suspend fun EmbeddedPaymentElement.PaymentOptionDisplayData.toWritableMap(): Wri
             getBase64FromBitmap(bitmap)
           } ?: ""
         }
-      } catch (e: Exception) {
+      } catch (_: Exception) {
         // If imageLoader fails or times out, return empty string
         ""
       }
@@ -120,17 +118,17 @@ fun AnnotatedString.toHtmlString(): String {
           }
         }
         AnnotationType.STRING_ANNOTATION -> {
-          val stringAnnotation = annotation.data as AnnotatedString.Range<String>
+          val stringAnnotation = annotation.data as AnnotatedString.Range<*>
           when (stringAnnotation.tag) {
             "URL", "LINK_TAG" -> {
               val url = stringAnnotation.item
-              htmlBuilder.append("<a href=\"${escapeHtml(url)}\">")
+              htmlBuilder.append("<a href=\"${escapeHtml(url as String)}\">")
               openTags.add(TagInfo(annotation.end, "</a>"))
             }
           }
         }
         AnnotationType.LINK_ANNOTATION -> {
-          val linkAnnotation = annotation.data as AnnotatedString.Range<LinkAnnotation>
+          val linkAnnotation = annotation.data as AnnotatedString.Range<*>
           when (val linkItem = linkAnnotation.item) {
             is LinkAnnotation.Url -> {
               htmlBuilder.append("<a href=\"${escapeHtml(linkItem.url)}\">")