@stripe/stripe-react-native 0.21.0 → 0.22.1

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## Unreleased
 
+## 0.22.1 - 2022-12-07
+
+## Fixes
+
+- Fixed the `ShippingMethod` type to contain the `isPending` field instead of a `type` field (which previously was never correct). This reflects the inputs accepted. [#1227](https://github.com/stripe/stripe-react-native/pull/1227)
+- Fixed the `ShippingMethod` type to contain the `startDate` and `endDate` keys, if applicable. [#1227](https://github.com/stripe/stripe-react-native/pull/1227)
+- Fixed instances of the "duplicate registered views" error. [#1233](https://github.com/stripe/stripe-react-native/pull/1233)
+- Fixed extra margin that was being added to `<CardForm />` on Android. [#1234](https://github.com/stripe/stripe-react-native/pull/1234)
+
+## 0.22.0 - 2022-12-02
+
+### Breaking changes
+
+### New features
+
+- Added the `hasPairedAppleWatch` option to `canAddCardToWallet`. [#1219](https://github.com/stripe/stripe-react-native/pull/1219)
+- Added new functions and a new component to streamline integrating with Apple and Google Pay and add more feature support. See the [Migrating to Platform Pay guide](https://github.com/stripe/stripe-react-native/blob/master/docs/Platform-Pay-Migration.md) for more details. The old Apple and Google Pay APIs are marked as `deprecated` and will be removed in a future release, but are still supported in this version.
+
+## Fixes
+
+- Fixed an issue where builds would error with the message `'const' enums are not supported.` [see commit](https://github.com/stripe/stripe-react-native/commit/f882bfa588aa6d23a980b4b43d2cca660ca1dd2a)
+- Fixed an issue where the `canAddCardToWallet` method would sometimes wrongly return `false` with a `details.status` of `MISSING_CONFIGURATION` in production builds. [#1215](https://github.com/stripe/stripe-react-native/pull/1215)
+- Fixed an issue on Android where, for certain countries, the postal code would not be enabled but would still be required. [#1213](https://github.com/stripe/stripe-react-native/pull/1213)
+- Fixed an issue on iOS where `canAddCardToWallet` would return `false` if the card had already been provisioned on a paired device like an Apple Watch, but had not yet been provisioned on the current device, and would also return `false` if the card had been provisioned on the current device, but not on a paired Apple Watch. [#1219](https://github.com/stripe/stripe-react-native/pull/1219)
+
 ## 0.21.0 - 2022-11-15
 
 ### Breaking changes
@@ -9,6 +34,7 @@
 ### New features
 
 - Added the `<AddressSheet />` component, which enables you to collect local and international shipping or billing addresses from your customers _with_ address autocomplete. [#1169](https://github.com/stripe/stripe-react-native/pull/1169)
+  - [Find the docs here](https://stripe.com/docs/elements/address-element?platform=react-native)
 - Added the `defaultShippingDetails` field to the `params` argument in `initPaymentSheet(params)`. This will allow you to collect shipping details (either in your own UI or using the new `<AddressSheet />` component) for payments in the Payment Sheet. [#1169](https://github.com/stripe/stripe-react-native/pull/1169)
 
 ## Fixes
@@ -38,7 +64,7 @@
 - Fixed an issue with Financial Connections on iOS where the app wouldn't properly redirect back after authentication. [#1178](https://github.com/stripe/stripe-react-native/pull/1178)
 - Fixed `borderWidth` and `borderRadius` for `<CardField />` and `CardForm />` was inconsistent across iOS and Android. [#1182](https://github.com/stripe/stripe-react-native/pull/1182)
 
-## 0.19.0 - 2022-09-16
+## 0.19.0 - 2022-09-16 (📌 Expo SDK 47)
 
 ### Breaking changes
 

package/android/build.gradle

@@ -35,6 +35,7 @@ android {
     versionName "1.0"
     vectorDrawables.useSupportLibrary = true
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    consumerProguardFiles 'proguard-rules.txt'
   }
 
   buildTypes {

package/android/proguard-rules.txt

@@ -0,0 +1,7 @@
+-keepclassmembers class com.google.android.gms.tapandpay.** {
+  public *;
+}
+
+-keepclassmembers class com.stripe.android.pushProvisioning.** {
+  public *;
+}

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

@@ -2,7 +2,6 @@ package com.reactnativestripesdk
 
 import android.content.res.ColorStateList
 import android.graphics.Color
-import android.graphics.Typeface
 import android.os.Build
 import android.text.Editable
 import android.text.InputFilter
@@ -143,7 +142,6 @@ class CardFieldView(context: ThemedReactContext) : FrameLayout(context) {
       }
     }
 
-    mCardWidget.setPadding(40, 0, 40, 0)
     mCardWidget.background = MaterialShapeDrawable(
       ShapeAppearanceModel()
         .toBuilder()
@@ -204,6 +202,10 @@ class CardFieldView(context: ThemedReactContext) : FrameLayout(context) {
 
   fun setPostalCodeEnabled(isEnabled: Boolean) {
     mCardWidget.postalCodeEnabled = isEnabled
+
+    if (isEnabled === false) {
+      mCardWidget.postalCodeRequired = false
+    }
   }
 
   /**

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

@@ -2,12 +2,12 @@ package com.reactnativestripesdk
 
 import android.content.res.ColorStateList
 import android.graphics.Color
-import android.graphics.Typeface
 import android.os.Build
 import android.text.InputFilter
 import android.view.View
 import android.view.View.OnFocusChangeListener
 import android.widget.FrameLayout
+import androidx.core.view.setMargins
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.uimanager.ThemedReactContext
@@ -40,7 +40,7 @@ class CardFormView(context: ThemedReactContext) : FrameLayout(context) {
   init {
     cardFormViewBinding.cardMultilineWidgetContainer.isFocusable = true
     cardFormViewBinding.cardMultilineWidgetContainer.isFocusableInTouchMode = true
-
+    (cardFormViewBinding.cardMultilineWidgetContainer.layoutParams as MarginLayoutParams).setMargins(0)
     addView(cardForm)
     setListeners()
 
@@ -191,7 +191,6 @@ class CardFormView(context: ThemedReactContext) : FrameLayout(context) {
       }
     }
 
-    cardFormViewBinding.cardMultilineWidgetContainer.setPadding(40, 0, 40, 0)
     cardFormViewBinding.cardMultilineWidgetContainer.background = MaterialShapeDrawable(
       ShapeAppearanceModel()
         .toBuilder()

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

@@ -17,6 +17,11 @@ class GooglePayButtonManager : SimpleViewManager<GooglePayButtonView?>() {
 
   @ReactProp(name = "buttonType")
   fun buttonType(view: GooglePayButtonView, buttonType: String) {
+    view.setButtonType(buttonType)
+  }
+
+  @ReactProp(name = "type")
+  fun type(view: GooglePayButtonView, buttonType: Int) {
     view.setType(buttonType)
   }
 

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

@@ -1,28 +1,66 @@
 package com.reactnativestripesdk
 
 import android.view.LayoutInflater
+import android.view.View
 import android.widget.FrameLayout
 import com.facebook.react.uimanager.ThemedReactContext
 
 class GooglePayButtonView(private val context: ThemedReactContext) : FrameLayout(context) {
+  private var button: View? = null
+  // Used in legacy GooglePayButton implementations
   private var buttonType: String? = null
 
+  // Used in the new PlatformPayButton implementations
+  private var type: Int? = null
+
   fun initialize() {
-    val type =
-      when (buttonType) {
-        "pay" -> R.layout.pay_with_googlepay_button
-        "standard" -> R.layout.googlepay_button
-        else -> R.layout.googlepay_button
+    val resAsset: Int =
+      if (type != null) {
+        when (type) {
+          0 -> R.layout.plain_googlepay_button
+          1 -> R.layout.buy_with_googlepay_button
+          6 -> R.layout.book_with_googlepay_button
+          5 -> R.layout.checkout_with_googlepay_button
+          4 -> R.layout.donate_with_googlepay_button
+          11 -> R.layout.order_with_googlepay_button
+          1000 -> R.layout.pay_with_googlepay_button
+          7 -> R.layout.subscribe_with_googlepay_button
+          1001 -> R.layout.googlepay_mark_button
+          else -> R.layout.plain_googlepay_button
+        }
+      } else {
+        when (buttonType) {
+          "pay" -> R.layout.pay_with_googlepay_button
+          "standard" -> R.layout.plain_googlepay_button
+          else -> R.layout.plain_googlepay_button
+        }
       }
 
-    val button = LayoutInflater.from(context).inflate(
-      type, null
+    button = LayoutInflater.from(context).inflate(
+      resAsset, null
     )
 
     addView(button)
+    viewTreeObserver.addOnGlobalLayoutListener { requestLayout() }
+  }
+
+  override fun requestLayout() {
+    super.requestLayout()
+    post(mLayoutRunnable)
   }
 
-  fun setType(type: String) {
+  private val mLayoutRunnable = Runnable {
+    measure(
+      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY))
+    button?.layout(left, top, right, bottom)
+  }
+
+  fun setButtonType(type: String) {
     buttonType = type
   }
+
+  fun setType(type: Int) {
+    this.type = type
+  }
 }

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

@@ -0,0 +1,132 @@
+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.stripe.android.googlepaylauncher.GooglePayEnvironment
+import com.stripe.android.googlepaylauncher.GooglePayLauncher
+
+class GooglePayLauncherFragment : Fragment() {
+  enum class Mode {
+    ForSetup, ForPayment
+  }
+
+  private lateinit var launcher: GooglePayLauncher
+  private lateinit var clientSecret: String
+  private lateinit var mode: Mode
+  private lateinit var configuration: GooglePayLauncher.Config
+  private lateinit var currencyCode: String
+  private lateinit var callback: (result: GooglePayLauncher.Result?, error: WritableMap?) -> Unit
+
+  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?) {
+    launcher = GooglePayLauncher(
+      fragment = this,
+      config = configuration,
+      readyCallback = ::onGooglePayReady,
+      resultCallback = ::onGooglePayResult
+    )
+  }
+
+  fun presentGooglePaySheet(clientSecret: String, mode: Mode, googlePayParams: ReadableMap, context: ReactApplicationContext, callback: (GooglePayLauncher.Result?, error: WritableMap?) -> Unit) {
+    this.clientSecret = clientSecret
+    this.mode = mode
+    this.callback = callback
+    this.currencyCode = googlePayParams.getString("currencyCode") ?: "USD"
+    this.configuration = GooglePayLauncher.Config(
+      environment = if (googlePayParams.getBoolean("testEnv")) 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),
+    )
+
+    (context.currentActivity as? AppCompatActivity)?.let {
+      attemptToCleanupPreviousFragment(it)
+      commitFragmentAndStartFlow(it)
+    } ?: run {
+      callback(null, createMissingActivityError())
+      return
+    }
+  }
+
+  private fun attemptToCleanupPreviousFragment(currentActivity: AppCompatActivity) {
+    currentActivity.supportFragmentManager.beginTransaction()
+      .remove(this)
+      .commitAllowingStateLoss()
+  }
+
+  private fun commitFragmentAndStartFlow(currentActivity: AppCompatActivity) {
+    try {
+      currentActivity.supportFragmentManager.beginTransaction()
+        .add(this, TAG)
+        .commit()
+    } catch (error: IllegalStateException) {
+      callback(
+        null,
+        createError(ErrorType.Failed.toString(), error.message)
+      )
+    }
+  }
+
+  private fun onGooglePayReady(isReady: Boolean) {
+    if (isReady) {
+      when (mode) {
+        Mode.ForSetup -> {
+          launcher.presentForSetupIntent(clientSecret, currencyCode)
+        }
+        Mode.ForPayment -> {
+          launcher.presentForPaymentIntent(clientSecret)
+        }
+      }
+    } 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 {
+    const val TAG = "google_pay_launcher_fragment"
+
+    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/GooglePayRequestHelper.kt

@@ -0,0 +1,144 @@
+package com.reactnativestripesdk
+
+import android.app.Activity
+import android.content.Intent
+import androidx.appcompat.app.AppCompatActivity
+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.*
+import com.reactnativestripesdk.utils.*
+import com.reactnativestripesdk.utils.createError
+import com.reactnativestripesdk.utils.mapFromPaymentMethod
+import com.reactnativestripesdk.utils.mapFromToken
+import com.stripe.android.ApiResultCallback
+import com.stripe.android.GooglePayJsonFactory
+import com.stripe.android.Stripe
+import com.stripe.android.model.GooglePayResult
+import com.stripe.android.model.PaymentMethod
+import com.stripe.android.model.PaymentMethodCreateParams
+import org.json.JSONObject
+import java.util.*
+
+class GooglePayRequestHelper {
+  companion object {
+    internal const val LOAD_PAYMENT_DATA_REQUEST_CODE = 414243
+
+    internal fun createPaymentRequest(activity: AppCompatActivity, factory: GooglePayJsonFactory, googlePayParams: ReadableMap): Task<PaymentData> {
+      val transactionInfo = buildTransactionInfo(googlePayParams)
+      val merchantInfo = GooglePayJsonFactory.MerchantInfo(googlePayParams.getString("merchantName").orEmpty())
+      val billingAddressParameters = buildBillingAddressParameters(googlePayParams.getMap("billingAddressConfig"))
+      val shippingAddressParameters = buildShippingAddressParameters(googlePayParams.getMap("shippingAddressConfig"))
+
+      val request = factory.createPaymentDataRequest(
+        transactionInfo = transactionInfo,
+        merchantInfo = merchantInfo,
+        billingAddressParameters = billingAddressParameters,
+        shippingAddressParameters = shippingAddressParameters,
+        isEmailRequired = googlePayParams.getBooleanOr("isEmailRequired", false),
+        allowCreditCards = googlePayParams.getBooleanOr("allowCreditCards", true)
+      )
+
+      val walletOptions =  Wallet.WalletOptions.Builder()
+        .setEnvironment(if (googlePayParams.getBoolean("testEnv")) WalletConstants.ENVIRONMENT_TEST else WalletConstants.ENVIRONMENT_PRODUCTION)
+        .build()
+      return Wallet.getPaymentsClient(activity, walletOptions).loadPaymentData(PaymentDataRequest.fromJson(request.toString()))
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun buildShippingAddressParameters(params: ReadableMap?): GooglePayJsonFactory.ShippingAddressParameters {
+      val isPhoneNumberRequired = params?.getBooleanOr("isPhoneNumberRequired", false)
+      val isRequired = params?.getBooleanOr("isRequired", false)
+      val allowedCountryCodes = if (params?.hasKey("allowedCountryCodes") == true)
+        params.getArray("allowedCountryCodes") as Array<String> else Locale.getISOCountries()
+
+      return GooglePayJsonFactory.ShippingAddressParameters(
+        isRequired = isRequired ?: false,
+        allowedCountryCodes = allowedCountryCodes.toSet(),
+        phoneNumberRequired = isPhoneNumberRequired ?: false
+      )
+    }
+
+    private fun buildBillingAddressParameters(params: ReadableMap?): GooglePayJsonFactory.BillingAddressParameters {
+      val isRequired = params?.getBooleanOr("isRequired", false)
+      val isPhoneNumberRequired = params?.getBooleanOr("isPhoneNumberRequired", false)
+      val format = when (params?.getString("format").orEmpty()) {
+        "FULL" -> GooglePayJsonFactory.BillingAddressParameters.Format.Full
+        "MIN" -> GooglePayJsonFactory.BillingAddressParameters.Format.Min
+        else -> GooglePayJsonFactory.BillingAddressParameters.Format.Min
+      }
+
+      return GooglePayJsonFactory.BillingAddressParameters(
+        isRequired = isRequired ?: false,
+        format = format,
+        isPhoneNumberRequired = isPhoneNumberRequired ?: false
+      )
+    }
+
+    private fun buildTransactionInfo(params: ReadableMap): GooglePayJsonFactory.TransactionInfo {
+      val countryCode = params.getString("merchantCountryCode").orEmpty()
+      val currencyCode = params.getString("currencyCode") ?: "USD"
+      val amount = params.getInt("amount")
+
+      return GooglePayJsonFactory.TransactionInfo(
+        currencyCode = currencyCode,
+        totalPriceStatus = GooglePayJsonFactory.TransactionInfo.TotalPriceStatus.Estimated,
+        countryCode = countryCode,
+        totalPrice = amount,
+        checkoutOption = GooglePayJsonFactory.TransactionInfo.CheckoutOption.Default
+      )
+    }
+
+    internal fun createPaymentMethod(request: Task<PaymentData>, activity: AppCompatActivity) {
+      AutoResolveHelper.resolveTask(
+        request,
+        activity,
+        LOAD_PAYMENT_DATA_REQUEST_CODE
+      )
+    }
+
+    internal fun handleGooglePaymentMethodResult(resultCode: Int, data: Intent?, stripe: Stripe, promise: Promise) {
+      when (resultCode) {
+        Activity.RESULT_OK -> {
+          data?.let { intent ->
+            PaymentData.getFromIntent(intent)?.let {
+              resolveWithPaymentMethodAndToken(it, stripe, promise)
+            }
+          }
+        }
+        Activity.RESULT_CANCELED -> {
+          promise.resolve(createError(ErrorType.Canceled.toString(), "The payment has been canceled"))
+        }
+        AutoResolveHelper.RESULT_ERROR -> {
+          AutoResolveHelper.getStatusFromIntent(data)?.let {
+            promise.resolve(createError(ErrorType.Failed.toString(), it.statusMessage))
+          }
+        }
+      }
+    }
+
+    private fun resolveWithPaymentMethodAndToken(paymentData: PaymentData, stripe: Stripe, promise: Promise) {
+      val paymentInformation = JSONObject(paymentData.toJson())
+      val googlePayResult = GooglePayResult.fromJson(paymentInformation)
+      val promiseResult = WritableNativeMap()
+      googlePayResult.token?.let {
+        promiseResult.putMap("token", mapFromToken(it))
+      }
+      stripe.createPaymentMethod(
+        PaymentMethodCreateParams.createFromGooglePay(paymentInformation),
+        callback = object : ApiResultCallback<PaymentMethod> {
+          override fun onError(e: Exception) {
+            promise.resolve(createError("Failed", e))
+          }
+
+          override fun onSuccess(result: PaymentMethod) {
+            promiseResult.putMap("paymentMethod", mapFromPaymentMethod(result))
+            promise.resolve(promiseResult)
+          }
+        }
+      )
+    }
+  }
+}
+

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

@@ -13,6 +13,7 @@ import com.reactnativestripesdk.utils.*
 import com.stripe.android.*
 import com.stripe.android.core.ApiVersion
 import com.stripe.android.core.AppInfo
+import com.stripe.android.googlepaylauncher.GooglePayLauncher
 import com.stripe.android.model.*
 import com.stripe.android.payments.bankaccount.CollectBankAccountConfiguration
 import com.stripe.android.paymentsheet.PaymentSheet
@@ -38,6 +39,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
   private var confirmPromise: Promise? = null
   private var confirmPaymentClientSecret: String? = null
+  private var createPlatformPayPaymentMethodPromise: Promise? = null
 
   private var paymentSheetFragment: PaymentSheetFragment? = null
   private var googlePayFragment: GooglePayFragment? = null
@@ -53,20 +55,31 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
       PaymentLauncherFragment.TAG,
       CollectBankAccountLauncherFragment.TAG,
       FinancialConnectionsSheetFragment.TAG,
-      AddressLauncherFragment.TAG
+      AddressLauncherFragment.TAG,
+      GooglePayLauncherFragment.TAG
     )
 
   private val mActivityEventListener = object : BaseActivityEventListener() {
     override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
       if (::stripe.isInitialized) {
-        dispatchActivityResultsToFragments(requestCode, resultCode, data)
-        try {
-          val result = AddPaymentMethodActivityStarter.Result.fromIntent(data)
-          if (data?.getParcelableExtra<Parcelable>("extra_activity_result") != null) {
-            onFpxPaymentMethodResult(result)
+        when (requestCode) {
+          GooglePayRequestHelper.LOAD_PAYMENT_DATA_REQUEST_CODE -> {
+            createPlatformPayPaymentMethodPromise?.let {
+              GooglePayRequestHelper.handleGooglePaymentMethodResult(resultCode, data, stripe, it)
+              createPlatformPayPaymentMethodPromise = null
+            } ?: run { Log.d("StripeReactNative", "No promise was found, Google Pay result went unhandled,") }
+          }
+          else -> {
+            dispatchActivityResultsToFragments(requestCode, resultCode, data)
+            try {
+              val result = AddPaymentMethodActivityStarter.Result.fromIntent(data)
+              if (data?.getParcelableExtra<Parcelable>("extra_activity_result") != null) {
+                onFpxPaymentMethodResult(result)
+              }
+            } catch (e: java.lang.Exception) {
+              Log.d("StripeReactNative", e.localizedMessage ?: e.toString())
+            }
           }
-        } catch (e: java.lang.Exception) {
-          Log.d("Error", e.localizedMessage ?: e.toString())
         }
       }
     }
@@ -495,6 +508,26 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
   }
 
+  @ReactMethod
+  fun isPlatformPaySupported(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 isGooglePaySupported(params: ReadableMap?, promise: Promise) {
     val fragment = GooglePayPaymentMethodLauncherFragment(
@@ -551,6 +584,62 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
   }
 
+  @ReactMethod
+  fun confirmPlatformPay(clientSecret: String, params: ReadableMap, isPaymentIntent: Boolean, promise: Promise) {
+    if (!::stripe.isInitialized) {
+      promise.resolve(createMissingInitError())
+      return
+    }
+
+    val googlePayParams: ReadableMap = params.getMap("googlePay") ?: run {
+      promise.resolve(createError(GooglePayErrorType.Failed.toString(), "You must provide the `googlePay` parameter."))
+      return
+    }
+
+    GooglePayLauncherFragment().also {
+      it.presentGooglePaySheet(
+        clientSecret,
+        if (isPaymentIntent) GooglePayLauncherFragment.Mode.ForPayment else GooglePayLauncherFragment.Mode.ForSetup,
+        googlePayParams,
+        reactApplicationContext
+      ) { launcherResult, errorMap ->
+        if (errorMap != null) {
+          promise.resolve(errorMap)
+        } else if (launcherResult != null) {
+          when (launcherResult) {
+            GooglePayLauncher.Result.Completed -> {
+              if (isPaymentIntent) {
+                stripe.retrievePaymentIntent(clientSecret, stripeAccountId,  object : ApiResultCallback<PaymentIntent> {
+                  override fun onError(e: Exception) {
+                    promise.resolve(createResult("paymentIntent", WritableNativeMap()))
+                  }
+                  override fun onSuccess(result: PaymentIntent) {
+                    promise.resolve(createResult("paymentIntent", mapFromPaymentIntentResult(result)))
+                  }
+                })
+              } else {
+                stripe.retrieveSetupIntent(clientSecret, stripeAccountId,  object : ApiResultCallback<SetupIntent> {
+                  override fun onError(e: Exception) {
+                    promise.resolve(createResult("setupIntent", WritableNativeMap()))
+                  }
+                  override fun onSuccess(result: SetupIntent) {
+                    promise.resolve(createResult("setupIntent", mapFromSetupIntentResult(result)))
+                  }
+                })
+              }
+            }
+            GooglePayLauncher.Result.Canceled -> {
+              promise.resolve(createError(GooglePayErrorType.Canceled.toString(), "Google Pay has been canceled"))
+            }
+            is GooglePayLauncher.Result.Failed -> {
+              promise.resolve(createError(GooglePayErrorType.Failed.toString(), launcherResult.error))
+            }
+          }
+        }
+      }
+    }
+  }
+
   @ReactMethod
   fun createGooglePayPaymentMethod(params: ReadableMap, promise: Promise) {
     val currencyCode = getValOr(params, "currencyCode", null) ?: run {
@@ -564,6 +653,23 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     googlePayFragment?.createPaymentMethod(currencyCode, amount, promise)
   }
 
+  @ReactMethod
+  fun createPlatformPayPaymentMethod(params: ReadableMap, promise: Promise) {
+    val googlePayParams: ReadableMap = params.getMap("googlePay") ?: run {
+      promise.resolve(createError(GooglePayErrorType.Failed.toString(), "You must provide the `googlePay` parameter."))
+      return
+    }
+    createPlatformPayPaymentMethodPromise = promise
+    getCurrentActivityOrResolveWithError(promise)?.let {
+      val request = GooglePayRequestHelper.createPaymentRequest(
+        it,
+        GooglePayJsonFactory(reactApplicationContext),
+        googlePayParams
+      )
+      GooglePayRequestHelper.createPaymentMethod(request, it)
+    }
+  }
+
   @ReactMethod
   fun canAddCardToWallet(params: ReadableMap, promise: Promise) {
     val last4 = getValOr(params, "cardLastFour", null) ?: run {
@@ -740,6 +846,15 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
   }
 
+  /**
+   * We need the following in order to avoid some annoying console.warns() from our Apple Pay event listeners. Otherwise,
+   * we'd have to put our users through some annoying (if Platform.OS...) logic & null-handling logic.
+   */
+  @ReactMethod
+  fun addListener(eventName: String) {}
+  @ReactMethod
+  fun removeListeners(count: Int) {}
+
   /**
    * Safely get and cast the current activity as an AppCompatActivity. If that fails, the promise
    * provided will be resolved with an error message instructing the user to retry the method.