@stripe/stripe-react-native 0.56.0 → 0.57.1

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

@@ -0,0 +1,154 @@
+package com.reactnativestripesdk
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.reactnativestripesdk.utils.createFailedError
+
+@ReactModule(name = NativeOnrampSdkModuleSpec.NAME)
+class FakeOnrampSdkModule(
+  reactContext: ReactApplicationContext,
+) : NativeOnrampSdkModuleSpec(reactContext) {
+  @ReactMethod
+  override fun initialise(
+    params: ReadableMap?,
+    promise: Promise?,
+  ) {
+    promise?.resolve(null)
+  }
+
+  @ReactMethod
+  override fun configureOnramp(
+    config: ReadableMap?,
+    promise: Promise?,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun hasLinkAccount(
+    email: String?,
+    promise: Promise?,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun registerLinkUser(
+    info: ReadableMap?,
+    promise: Promise?,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun registerWalletAddress(
+    walletAddress: String?,
+    network: String?,
+    promise: Promise?,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun attachKycInfo(
+    kycInfo: ReadableMap?,
+    promise: Promise?,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun updatePhoneNumber(
+    phone: String?,
+    promise: Promise?,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun authenticateUser(promise: Promise?) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun verifyIdentity(promise: Promise?) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun presentKycInfoVerification(
+    updatedAddress: ReadableMap?,
+    promise: Promise,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun collectPaymentMethod(
+    paymentMethod: String?,
+    platformPayParams: ReadableMap?,
+    promise: Promise?,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun provideCheckoutClientSecret(clientSecret: String?) {
+    // No-op
+  }
+
+  @ReactMethod
+  override fun createCryptoPaymentToken(promise: Promise?) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun performCheckout(
+    onrampSessionId: String?,
+    promise: Promise?,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun onrampAuthorize(
+    linkAuthIntentId: String?,
+    promise: Promise?,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun logout(promise: Promise?) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun getCryptoTokenDisplayData(
+    token: ReadableMap,
+    promise: Promise,
+  ) {
+    promise?.resolveNotImplemented()
+  }
+
+  @ReactMethod
+  override fun authenticateUserWithToken(
+    token: String,
+    promise: Promise,
+  ) {
+    promise.resolveNotImplemented()
+  }
+
+  private fun Promise.resolveNotImplemented() {
+    this.resolve(
+      createFailedError(
+        NotImplementedError(
+          "To enable Onramp, add 'StripeSdk_includeOnramp=true' to gradle.properties.",
+        ),
+      ),
+    )
+  }
+}

package/android/src/main/java/com/reactnativestripesdk/{FinancialConnectionsSheetFragment.kt → FinancialConnectionsSheetManager.kt}

@@ -1,19 +1,17 @@
 package com.reactnativestripesdk
 
-import androidx.fragment.app.FragmentActivity
+import android.annotation.SuppressLint
 import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeMap
 import com.reactnativestripesdk.utils.ErrorType
-import com.reactnativestripesdk.utils.StripeFragment
+import com.reactnativestripesdk.utils.StripeUIManager
 import com.reactnativestripesdk.utils.createError
-import com.reactnativestripesdk.utils.createMissingActivityError
 import com.reactnativestripesdk.utils.mapFromFinancialConnectionsEvent
 import com.reactnativestripesdk.utils.mapFromToken
+import com.stripe.android.core.reactnative.ReactNativeSdkInternal
 import com.stripe.android.financialconnections.FinancialConnections
 import com.stripe.android.financialconnections.FinancialConnectionsSheet
 import com.stripe.android.financialconnections.FinancialConnectionsSheetForTokenResult
@@ -24,18 +22,28 @@ import com.stripe.android.financialconnections.model.FinancialConnectionsAccount
 import com.stripe.android.financialconnections.model.FinancialConnectionsAccountList
 import com.stripe.android.financialconnections.model.FinancialConnectionsSession
 
-class FinancialConnectionsSheetFragment : StripeFragment() {
+@OptIn(ReactNativeSdkInternal::class)
+class FinancialConnectionsSheetManager(
+  context: ReactApplicationContext,
+  clientSecret: String,
+  private var mode: Mode,
+  publishableKey: String,
+  stripeAccountId: String?,
+) : StripeUIManager(context) {
   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
+  private var configuration =
+    FinancialConnectionsSheet.Configuration(
+      financialConnectionsSessionClientSecret = clientSecret,
+      publishableKey = publishableKey,
+      stripeAccountId = stripeAccountId,
+    )
 
-  override fun prepare() {
+  override fun onPresent() {
+    val activity = getCurrentActivityOrResolveWithError(promise) ?: return
     val stripeSdkModule: StripeSdkModule? = context.getNativeModule(StripeSdkModule::class.java)
     FinancialConnections.setEventListener { event ->
       val params = mapFromFinancialConnectionsEvent(event)
@@ -44,16 +52,19 @@ class FinancialConnectionsSheetFragment : StripeFragment() {
 
     when (mode) {
       Mode.ForToken -> {
+        @SuppressLint("RestrictedApi")
         FinancialConnectionsSheet
           .createForBankAccountToken(
-            this,
+            activity,
+            signal,
             ::onFinancialConnectionsSheetForTokenResult,
           ).present(configuration = configuration)
       }
 
       Mode.ForSession -> {
+        @SuppressLint("RestrictedApi")
         FinancialConnectionsSheet
-          .create(this, ::onFinancialConnectionsSheetForDataResult)
+          .create(activity, signal, ::onFinancialConnectionsSheetForDataResult)
           .present(configuration = configuration)
       }
     }
@@ -61,7 +72,6 @@ class FinancialConnectionsSheetFragment : StripeFragment() {
 
   override fun onDestroy() {
     super.onDestroy()
-
     // Remove any event listener that might be set
     FinancialConnections.clearEventListener()
   }
@@ -69,20 +79,15 @@ class FinancialConnectionsSheetFragment : StripeFragment() {
   private fun onFinancialConnectionsSheetForTokenResult(result: FinancialConnectionsSheetForTokenResult) {
     when (result) {
       is FinancialConnectionsSheetForTokenResult.Canceled -> {
-        promise.resolve(createError(ErrorType.Canceled.toString(), "The flow has been canceled"))
+        promise?.resolve(createError(ErrorType.Canceled.toString(), "The flow has been canceled"))
       }
 
       is FinancialConnectionsSheetForTokenResult.Failed -> {
-        promise.resolve(createError(ErrorType.Failed.toString(), result.error))
+        promise?.resolve(createError(ErrorType.Failed.toString(), result.error))
       }
 
       is FinancialConnectionsSheetForTokenResult.Completed -> {
-        promise.resolve(createTokenResult(result))
-        (context.currentActivity as? FragmentActivity)
-          ?.supportFragmentManager
-          ?.beginTransaction()
-          ?.remove(this)
-          ?.commitAllowingStateLoss()
+        promise?.resolve(createTokenResult(result))
       }
     }
   }
@@ -90,85 +95,32 @@ class FinancialConnectionsSheetFragment : StripeFragment() {
   private fun onFinancialConnectionsSheetForDataResult(result: FinancialConnectionsSheetResult) {
     when (result) {
       is FinancialConnectionsSheetResult.Canceled -> {
-        promise.resolve(createError(ErrorType.Canceled.toString(), "The flow has been canceled"))
+        promise?.resolve(createError(ErrorType.Canceled.toString(), "The flow has been canceled"))
       }
 
       is FinancialConnectionsSheetResult.Failed -> {
-        promise.resolve(createError(ErrorType.Failed.toString(), result.error))
+        promise?.resolve(createError(ErrorType.Failed.toString(), result.error))
       }
 
       is FinancialConnectionsSheetResult.Completed -> {
-        promise.resolve(
-          WritableNativeMap().also {
+        promise?.resolve(
+          Arguments.createMap().also {
             it.putMap("session", mapFromSession(result.financialConnectionsSession))
           },
         )
-        (context.currentActivity as? FragmentActivity)
-          ?.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? FragmentActivity)?.let {
-      attemptToCleanupPreviousFragment(it)
-      commitFragmentAndStartFlow(it)
-    }
-      ?: run {
-        promise.resolve(createMissingActivityError())
-        return
-      }
-  }
-
-  private fun attemptToCleanupPreviousFragment(currentActivity: FragmentActivity) {
-    currentActivity.supportFragmentManager
-      .beginTransaction()
-      .remove(this)
-      .commitAllowingStateLoss()
-  }
-
-  private fun commitFragmentAndStartFlow(currentActivity: FragmentActivity) {
-    try {
-      currentActivity.supportFragmentManager
-        .beginTransaction()
-        .add(this, TAG)
-        .commit()
-    } catch (error: IllegalStateException) {
-      promise.resolve(createError(ErrorType.Failed.toString(), error.message))
-    }
-  }
-
   companion object {
-    internal const val TAG = "financial_connections_sheet_launch_fragment"
-
     private fun createTokenResult(result: FinancialConnectionsSheetForTokenResult.Completed): WritableMap =
-      WritableNativeMap().also {
+      Arguments.createMap().also {
         it.putMap("session", mapFromSession(result.financialConnectionsSession))
         it.putMap("token", mapFromToken(result.token))
       }
 
     private fun mapFromSession(financialConnectionsSession: FinancialConnectionsSession): WritableMap {
-      val session = WritableNativeMap()
+      val session = Arguments.createMap()
       session.putString("id", financialConnectionsSession.id)
       session.putString("clientSecret", financialConnectionsSession.clientSecret)
       session.putBoolean("livemode", financialConnectionsSession.livemode)
@@ -179,7 +131,7 @@ class FinancialConnectionsSheetFragment : StripeFragment() {
     private fun mapFromAccountsList(accounts: FinancialConnectionsAccountList): ReadableArray {
       val results: WritableArray = Arguments.createArray()
       for (account in accounts.data) {
-        val map = WritableNativeMap()
+        val map = Arguments.createMap()
         map.putString("id", account.id)
         map.putBoolean("livemode", account.livemode)
         map.putString("displayName", account.displayName)
@@ -213,10 +165,10 @@ class FinancialConnectionsSheetFragment : StripeFragment() {
       if (balance == null) {
         return null
       }
-      val map = WritableNativeMap()
+      val map = Arguments.createMap()
       map.putDouble("asOf", balance.asOf * 1000.0)
       map.putString("type", mapFromBalanceType(balance.type))
-      WritableNativeMap().also {
+      Arguments.createMap().also {
         for (entry in balance.current.entries) {
           it.putInt(entry.key, entry.value)
         }
@@ -228,9 +180,9 @@ class FinancialConnectionsSheetFragment : StripeFragment() {
       return map
     }
 
-    private fun mapFromCashAvailable(balance: Balance): WritableNativeMap =
-      WritableNativeMap().also { cashMap ->
-        WritableNativeMap().also { availableMap ->
+    private fun mapFromCashAvailable(balance: Balance): WritableMap =
+      Arguments.createMap().also { cashMap ->
+        Arguments.createMap().also { availableMap ->
           balance.cash?.available?.entries?.let { entries ->
             for (entry in entries) {
               availableMap.putInt(entry.key, entry.value)
@@ -240,9 +192,9 @@ class FinancialConnectionsSheetFragment : StripeFragment() {
         }
       }
 
-    private fun mapFromCreditUsed(balance: Balance): WritableNativeMap =
-      WritableNativeMap().also { creditMap ->
-        WritableNativeMap().also { usedMap ->
+    private fun mapFromCreditUsed(balance: Balance): WritableMap =
+      Arguments.createMap().also { creditMap ->
+        Arguments.createMap().also { usedMap ->
           balance.credit?.used?.entries?.let { entries ->
             for (entry in entries) {
               usedMap.putInt(entry.key, entry.value)
@@ -256,7 +208,7 @@ class FinancialConnectionsSheetFragment : StripeFragment() {
       if (balanceRefresh == null) {
         return null
       }
-      val map = WritableNativeMap()
+      val map = Arguments.createMap()
       map.putString("status", mapFromBalanceRefreshStatus(balanceRefresh.status))
       map.putDouble("lastAttemptedAt", balanceRefresh.lastAttemptedAt * 1000.0)
       return map
@@ -298,7 +250,6 @@ class FinancialConnectionsSheetFragment : StripeFragment() {
         FinancialConnectionsAccount.Permissions.TRANSACTIONS -> "transactions"
         FinancialConnectionsAccount.Permissions.ACCOUNT_NUMBERS -> "accountNumbers"
         FinancialConnectionsAccount.Permissions.UNKNOWN -> "unparsable"
-        FinancialConnectionsAccount.Permissions.ACCOUNT_NUMBERS -> "accountNumbers"
       }
 
     private fun mapFromSupportedPaymentMethodTypes(type: FinancialConnectionsAccount.SupportedPaymentMethodTypes): String =

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

@@ -108,7 +108,7 @@ class GooglePayButtonView(
         MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
         MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
       )
-      button?.layout(left, top, right, bottom)
+      layout(left, top, right, bottom)
     }
 
   fun setType(type: Int) {

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

@@ -0,0 +1,107 @@
+package com.reactnativestripesdk
+
+import android.annotation.SuppressLint
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.reactnativestripesdk.utils.GooglePayErrorType
+import com.reactnativestripesdk.utils.StripeUIManager
+import com.reactnativestripesdk.utils.createError
+import com.reactnativestripesdk.utils.getBooleanOr
+import com.reactnativestripesdk.utils.getIntOrNull
+import com.stripe.android.core.reactnative.ReactNativeSdkInternal
+import com.stripe.android.googlepaylauncher.GooglePayEnvironment
+import com.stripe.android.googlepaylauncher.GooglePayLauncher
+
+@OptIn(ReactNativeSdkInternal::class)
+class GooglePayLauncherManager(
+  context: ReactApplicationContext,
+  private val clientSecret: String,
+  private val mode: Mode,
+  googlePayParams: ReadableMap,
+  private val callback: (GooglePayLauncher.Result?, error: WritableMap?) -> Unit,
+) : StripeUIManager(context) {
+  enum class Mode {
+    ForSetup,
+    ForPayment,
+  }
+
+  private var launcher: GooglePayLauncher? = null
+  private var configuration =
+    GooglePayLauncher.Config(
+      environment =
+        if (googlePayParams.getBooleanOr("testEnv", false)) {
+          GooglePayEnvironment.Test
+        } else {
+          GooglePayEnvironment.Production
+        },
+      merchantCountryCode = googlePayParams.getString("merchantCountryCode").orEmpty(),
+      merchantName = googlePayParams.getString("merchantName").orEmpty(),
+      isEmailRequired = googlePayParams.getBooleanOr("isEmailRequired", false),
+      billingAddressConfig =
+        buildBillingAddressParameters(googlePayParams.getMap("billingAddressConfig")),
+      existingPaymentMethodRequired =
+        googlePayParams.getBooleanOr("existingPaymentMethodRequired", false),
+      allowCreditCards = googlePayParams.getBooleanOr("allowCreditCards", true),
+    )
+  private var currencyCode = googlePayParams.getString("currencyCode") ?: "USD"
+  private var amount = googlePayParams.getIntOrNull("amount")
+  private var label = googlePayParams.getString("label")
+
+  override fun onPresent() {
+    val activity = getCurrentActivityOrResolveWithError(promise) ?: return
+    @SuppressLint("RestrictedApi")
+    launcher =
+      GooglePayLauncher(
+        activity = activity,
+        signal = signal,
+        config = configuration,
+        readyCallback = ::onGooglePayReady,
+        resultCallback = ::onGooglePayResult,
+      )
+  }
+
+  private fun onGooglePayReady(isReady: Boolean) {
+    if (isReady) {
+      when (mode) {
+        Mode.ForSetup -> {
+          launcher?.presentForSetupIntent(clientSecret, currencyCode, amount?.toLong(), label)
+        }
+        Mode.ForPayment -> {
+          launcher?.presentForPaymentIntent(clientSecret, label)
+        }
+      }
+    } else {
+      callback(
+        null,
+        createError(
+          GooglePayErrorType.Failed.toString(),
+          "Google Pay is not available on this device. You can use isPlatformPaySupported to preemptively check for Google Pay support.",
+        ),
+      )
+    }
+  }
+
+  private fun onGooglePayResult(result: GooglePayLauncher.Result) {
+    callback(result, null)
+  }
+
+  companion object {
+    private fun buildBillingAddressParameters(params: ReadableMap?): GooglePayLauncher.BillingAddressConfig {
+      val isRequired = params?.getBooleanOr("isRequired", false)
+      val isPhoneNumberRequired = params?.getBooleanOr("isPhoneNumberRequired", false)
+      val format =
+        when (params?.getString("format").orEmpty()) {
+          "FULL" -> GooglePayLauncher.BillingAddressConfig.Format.Full
+          "MIN" -> GooglePayLauncher.BillingAddressConfig.Format.Min
+          else -> GooglePayLauncher.BillingAddressConfig.Format.Min
+        }
+
+      return GooglePayLauncher.BillingAddressConfig(
+        isRequired = isRequired ?: false,
+        format = format,
+        isPhoneNumberRequired = isPhoneNumberRequired ?: false,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,37 @@
+package com.reactnativestripesdk
+
+import android.annotation.SuppressLint
+import com.facebook.react.bridge.ReactApplicationContext
+import com.reactnativestripesdk.utils.StripeUIManager
+import com.stripe.android.core.reactnative.ReactNativeSdkInternal
+import com.stripe.android.googlepaylauncher.GooglePayEnvironment
+import com.stripe.android.googlepaylauncher.GooglePayPaymentMethodLauncher
+
+@ReactNativeSdkInternal
+class GooglePayPaymentMethodLauncherManager(
+  context: ReactApplicationContext,
+  private val isTestEnv: Boolean,
+  private val paymentMethodRequired: Boolean,
+) : StripeUIManager(context) {
+  override fun onPresent() {
+    val activity = getCurrentActivityOrResolveWithError(promise) ?: return
+    @SuppressLint("RestrictedApi")
+    GooglePayPaymentMethodLauncher(
+      activity = activity,
+      signal = signal,
+      config =
+        GooglePayPaymentMethodLauncher.Config(
+          environment =
+            if (isTestEnv) GooglePayEnvironment.Test else GooglePayEnvironment.Production,
+          existingPaymentMethodRequired = paymentMethodRequired,
+          merchantCountryCode =
+            "", // Unnecessary since all we are checking for is Google Pay availability
+          merchantName = "", // Same as above
+        ),
+      readyCallback = {
+        promise?.resolve(it)
+      },
+      resultCallback = {},
+    )
+  }
+}

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

@@ -3,9 +3,9 @@ package com.reactnativestripesdk
 import android.app.Activity
 import android.content.Intent
 import androidx.fragment.app.FragmentActivity
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableNativeMap
 import com.google.android.gms.tasks.Task
 import com.google.android.gms.wallet.AutoResolveHelper
 import com.google.android.gms.wallet.PaymentData
@@ -15,6 +15,7 @@ import com.google.android.gms.wallet.WalletConstants
 import com.reactnativestripesdk.utils.ErrorType
 import com.reactnativestripesdk.utils.createError
 import com.reactnativestripesdk.utils.getBooleanOr
+import com.reactnativestripesdk.utils.getIntOr
 import com.reactnativestripesdk.utils.mapFromPaymentMethod
 import com.reactnativestripesdk.utils.mapFromShippingContact
 import com.reactnativestripesdk.utils.mapFromToken
@@ -58,7 +59,7 @@ class GooglePayRequestHelper {
         Wallet.WalletOptions
           .Builder()
           .setEnvironment(
-            if (googlePayParams.getBoolean("testEnv")) {
+            if (googlePayParams.getBooleanOr("testEnv", false)) {
               WalletConstants.ENVIRONMENT_TEST
             } else {
               WalletConstants.ENVIRONMENT_PRODUCTION
@@ -107,7 +108,7 @@ class GooglePayRequestHelper {
     private fun buildTransactionInfo(params: ReadableMap): GooglePayJsonFactory.TransactionInfo {
       val countryCode = params.getString("merchantCountryCode").orEmpty()
       val currencyCode = params.getString("currencyCode") ?: "USD"
-      val amount = params.getInt("amount")
+      val amount = params.getIntOr("amount", 0)
       val label = params.getString("label")
 
       return GooglePayJsonFactory.TransactionInfo(
@@ -124,6 +125,7 @@ class GooglePayRequestHelper {
       request: Task<PaymentData>,
       activity: FragmentActivity,
     ) {
+      @Suppress("DEPRECATION")
       AutoResolveHelper.resolveTask(request, activity, LOAD_PAYMENT_DATA_REQUEST_CODE)
     }
 
@@ -165,7 +167,7 @@ class GooglePayRequestHelper {
       promise: Promise,
     ) {
       val paymentInformation = JSONObject(paymentData.toJson())
-      val promiseResult = WritableNativeMap()
+      val promiseResult = Arguments.createMap()
       stripe.createPaymentMethod(
         PaymentMethodCreateParams.createFromGooglePay(paymentInformation),
         callback =
@@ -193,7 +195,7 @@ class GooglePayRequestHelper {
     ) {
       val paymentInformation = JSONObject(paymentData.toJson())
       val googlePayResult = GooglePayResult.fromJson(paymentInformation)
-      val promiseResult = WritableNativeMap()
+      val promiseResult = Arguments.createMap()
       googlePayResult.token?.let {
         promiseResult.putMap("token", mapFromToken(it))
         if (googlePayResult.shippingInformation != null) {

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"
+  }
+}