@stripe/stripe-react-native 0.20.0 → 0.22.0

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

@@ -5,16 +5,15 @@ import android.content.Intent
 import android.os.Parcelable
 import android.util.Log
 import androidx.appcompat.app.AppCompatActivity
-import androidx.fragment.app.Fragment
 import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
+import com.reactnativestripesdk.addresssheet.AddressLauncherFragment
 import com.reactnativestripesdk.pushprovisioning.PushProvisioningProxy
 import com.reactnativestripesdk.utils.*
-import com.reactnativestripesdk.utils.createError
-import com.reactnativestripesdk.utils.createMissingActivityError
 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
@@ -40,32 +39,47 @@ 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
   private var paymentLauncherFragment: PaymentLauncherFragment? = null
   private var collectBankAccountLauncherFragment: CollectBankAccountLauncherFragment? = null
-  private var financialConnectionsSheetFragment: FinancialConnectionsSheetFragment? = null
-  private val allFragments: List<Fragment?>
+
+  // If you create a new Fragment, you must put the tag here, otherwise result callbacks for that
+  // Fragment will not work on RN < 0.65
+  private val allStripeFragmentTags: List<String>
     get() = listOf(
-      paymentSheetFragment,
-      googlePayFragment,
-      paymentLauncherFragment,
-      collectBankAccountLauncherFragment,
-      financialConnectionsSheetFragment
+      PaymentSheetFragment.TAG,
+      GooglePayFragment.TAG,
+      PaymentLauncherFragment.TAG,
+      CollectBankAccountLauncherFragment.TAG,
+      FinancialConnectionsSheetFragment.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())
         }
       }
     }
@@ -77,8 +91,12 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
   // Necessary on older versions of React Native (~0.65 and below)
   private fun dispatchActivityResultsToFragments(requestCode: Int, resultCode: Int, data: Intent?) {
-    for (fragment in allFragments) {
-      fragment?.activity?.activityResultRegistry?.dispatchResult(requestCode, resultCode, data)
+    getCurrentActivityOrResolveWithError(null)?.supportFragmentManager?.let { fragmentManager ->
+      for (tag in allStripeFragmentTags) {
+        fragmentManager.findFragmentByTag(tag)?.let {
+          it.activity?.activityResultRegistry?.dispatchResult(requestCode, resultCode, data)
+        }
+      }
     }
   }
 
@@ -120,6 +138,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     }
 
     this.publishableKey = publishableKey
+    AddressLauncherFragment.publishableKey = publishableKey
 
     val name = getValOr(appInfo, "name", "") as String
     val partnerId = getValOr(appInfo, "partnerId", "")
@@ -489,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(
@@ -545,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 {
@@ -558,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 {
@@ -718,7 +830,7 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
       promise.resolve(createMissingInitError())
       return
     }
-    financialConnectionsSheetFragment = FinancialConnectionsSheetFragment().also {
+    FinancialConnectionsSheetFragment().also {
       it.presentFinancialConnectionsSheet(clientSecret, FinancialConnectionsSheetFragment.Mode.ForToken, publishableKey, stripeAccountId, promise, reactApplicationContext)
     }
   }
@@ -729,11 +841,20 @@ class StripeSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
       promise.resolve(createMissingInitError())
       return
     }
-    financialConnectionsSheetFragment = FinancialConnectionsSheetFragment().also {
+    FinancialConnectionsSheetFragment().also {
       it.presentFinancialConnectionsSheet(clientSecret, FinancialConnectionsSheetFragment.Mode.ForSession, publishableKey, stripeAccountId, promise, reactApplicationContext)
     }
   }
 
+  /**
+   * 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.

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

@@ -4,6 +4,7 @@ import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
+import com.reactnativestripesdk.addresssheet.AddressSheetViewManager
 import com.reactnativestripesdk.pushprovisioning.AddToWalletButtonManager
 
 class StripeSdkPackage : ReactPackage {
@@ -18,7 +19,8 @@ class StripeSdkPackage : ReactPackage {
         StripeContainerManager(),
         CardFormViewManager(),
         GooglePayButtonManager(),
-        AddToWalletButtonManager(reactContext)
+        AddToWalletButtonManager(reactContext),
+        AddressSheetViewManager()
       )
     }
 }

package/android/src/main/java/com/reactnativestripesdk/addresssheet/AddressLauncherFragment.kt

@@ -0,0 +1,111 @@
+package com.reactnativestripesdk.addresssheet
+
+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.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.reactnativestripesdk.utils.ErrorType
+import com.reactnativestripesdk.utils.createError
+import com.stripe.android.paymentsheet.PaymentSheet
+import com.stripe.android.paymentsheet.addresselement.AddressDetails
+import com.stripe.android.paymentsheet.addresselement.AddressLauncher
+import com.stripe.android.paymentsheet.addresselement.AddressLauncherResult
+
+class AddressLauncherFragment : Fragment() {
+  companion object {
+    internal var publishableKey: String? = null
+    internal const val TAG = "address_launcher_fragment"
+  }
+
+  private lateinit var addressLauncher: AddressLauncher
+  private var configuration = AddressLauncher.Configuration()
+  private var callback: ((error: WritableMap?, address: AddressDetails?) -> Unit)? = null
+
+  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?) {
+    publishableKey?.let { publishableKey ->
+      addressLauncher = AddressLauncher(this,
+                                        ::onAddressLauncherResult).also {
+        it.present(
+          publishableKey = publishableKey,
+          configuration = configuration
+        )
+      }
+    } ?: run {
+      callback?.invoke(
+        createError(ErrorType.Failed.toString(), "No publishable key set. Stripe has not been initialized. Initialize Stripe in your app with the StripeProvider component or the initStripe method."),
+        null
+      )
+    }
+  }
+
+  private fun onAddressLauncherResult(result: AddressLauncherResult) {
+    when (result) {
+      is AddressLauncherResult.Canceled -> {
+        callback?.invoke(
+          createError(ErrorType.Canceled.toString(), "The flow has been canceled."),
+          null
+        )
+      }
+      is AddressLauncherResult.Succeeded -> {
+        callback?.invoke(
+          null,
+          result.address
+        )
+      }
+    }
+  }
+
+  fun presentAddressSheet(
+    context: ReactContext,
+    appearance: PaymentSheet.Appearance,
+    defaultAddress: AddressDetails?,
+    allowedCountries: Set<String>,
+    buttonTitle: String?,
+    title: String?,
+    googlePlacesApiKey: String?,
+    autocompleteCountries: Set<String>,
+    additionalFields: AddressLauncher.AdditionalFieldsConfiguration?,
+    callback: ((error: WritableMap?, address: AddressDetails?) -> Unit)) {
+    configuration = AddressLauncher.Configuration(
+      appearance = appearance,
+      address = defaultAddress,
+      allowedCountries = allowedCountries,
+      buttonTitle = buttonTitle,
+      additionalFields = additionalFields,
+      title = title,
+      googlePlacesApiKey = googlePlacesApiKey,
+      autocompleteCountries = autocompleteCountries,
+    )
+    this.callback = callback
+    (context.currentActivity as? AppCompatActivity)?.let {
+      attemptToCleanupPreviousFragment(it)
+      commitFragmentAndStartFlow(it)
+    }
+  }
+
+  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 (_: IllegalStateException) {}
+  }
+}

package/android/src/main/java/com/reactnativestripesdk/addresssheet/AddressSheetEvent.kt

@@ -0,0 +1,28 @@
+package com.reactnativestripesdk.addresssheet
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+internal class AddressSheetEvent constructor(viewTag: Int, private val eventType: EventType, private val eventMap: WritableMap?) : Event<AddressSheetEvent>(viewTag) {
+  enum class EventType {
+    OnSubmit,
+    OnError
+  }
+
+  override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+    rctEventEmitter.receiveEvent(viewTag, eventName, eventMap)
+  }
+
+  companion object {
+    const val ON_SUBMIT = "onSubmitAction"
+    const val ON_ERROR = "onErrorAction"
+  }
+
+  override fun getEventName(): String {
+    return when (eventType) {
+      EventType.OnSubmit -> ON_SUBMIT
+      EventType.OnError -> ON_ERROR
+    }
+  }
+}

package/android/src/main/java/com/reactnativestripesdk/addresssheet/AddressSheetView.kt

@@ -0,0 +1,178 @@
+package com.reactnativestripesdk.addresssheet
+
+import android.os.Bundle
+import android.util.Log
+import android.widget.FrameLayout
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerModule
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.reactnativestripesdk.buildPaymentSheetAppearance
+import com.reactnativestripesdk.utils.ErrorType
+import com.reactnativestripesdk.utils.PaymentSheetAppearanceException
+import com.reactnativestripesdk.utils.createError
+import com.reactnativestripesdk.utils.toBundleObject
+import com.stripe.android.paymentsheet.PaymentSheet
+import com.stripe.android.paymentsheet.addresselement.AddressDetails
+import com.stripe.android.paymentsheet.addresselement.AddressLauncher
+import com.stripe.android.paymentsheet.addresselement.AddressLauncherResult
+
+class AddressSheetView(private val context: ThemedReactContext) : FrameLayout(context) {
+  private var eventDispatcher: EventDispatcher? = context.getNativeModule(UIManagerModule::class.java)?.eventDispatcher
+  private var isVisible = false
+  private var appearanceParams: ReadableMap? = null
+  private var defaultAddress: AddressDetails? = null
+  private var allowedCountries: Set<String> = emptySet()
+  private var buttonTitle: String? = null
+  private var sheetTitle: String? = null
+  private var googlePlacesApiKey: String? = null
+  private var autocompleteCountries: Set<String> = emptySet()
+  private var additionalFields: AddressLauncher.AdditionalFieldsConfiguration? = null
+
+  private fun onSubmit(params: WritableMap) {
+    eventDispatcher?.dispatchEvent(
+      AddressSheetEvent(id, AddressSheetEvent.EventType.OnSubmit, params)
+    )
+  }
+
+  private fun onError(params: WritableMap?) {
+    eventDispatcher?.dispatchEvent(
+      AddressSheetEvent(id, AddressSheetEvent.EventType.OnError, params)
+    )
+  }
+
+  fun setVisible(newVisibility: Boolean) {
+    if (newVisibility && !isVisible) {
+      launchAddressSheet()
+    } else if (!newVisibility && isVisible) {
+      Log.w("StripeReactNative", "Programmatically dismissing the Address Sheet is not supported on Android.")
+    }
+    isVisible = newVisibility
+  }
+
+  private fun launchAddressSheet() {
+    val appearance = try {
+      buildPaymentSheetAppearance(toBundleObject(appearanceParams), context)
+    } catch (error: PaymentSheetAppearanceException) {
+      onError(createError(ErrorType.Failed.toString(), error))
+      return
+    }
+    AddressLauncherFragment().presentAddressSheet(
+      context,
+      appearance,
+      defaultAddress,
+      allowedCountries,
+      buttonTitle,
+      sheetTitle,
+      googlePlacesApiKey,
+      autocompleteCountries,
+      additionalFields
+    ) { error, address ->
+      if (address != null) {
+        onSubmit(buildResult(address))
+      } else {
+        onError(error)
+      }
+      isVisible = false
+    }
+  }
+
+  fun setAppearance(appearanceParams: ReadableMap) {
+    this.appearanceParams = appearanceParams
+  }
+
+  fun setDefaultValues(defaults: ReadableMap) {
+    defaultAddress = buildAddressDetails(defaults)
+  }
+
+  fun setAdditionalFields(fields: ReadableMap) {
+    additionalFields = buildAdditionalFieldsConfiguration(fields)
+  }
+
+  fun setAllowedCountries(countries: List<String>) {
+    allowedCountries = countries.toSet()
+  }
+
+  fun setAutocompleteCountries(countries: List<String>) {
+    autocompleteCountries = countries.toSet()
+  }
+
+  fun setPrimaryButtonTitle(title: String) {
+    buttonTitle = title
+  }
+
+  fun setSheetTitle(title: String) {
+    sheetTitle = title
+  }
+
+  fun setGooglePlacesApiKey(key: String) {
+    googlePlacesApiKey = key
+  }
+
+  companion object {
+    internal fun buildAddressDetails(bundle: Bundle): AddressDetails {
+      return AddressDetails(
+        name = bundle.getString("name"),
+        address = buildAddress(bundle.getBundle("address")),
+        phoneNumber = bundle.getString("phone"),
+        isCheckboxSelected = bundle.getBoolean("isCheckboxSelected"),
+      )
+    }
+
+    internal fun buildAddressDetails(map: ReadableMap): AddressDetails {
+      return buildAddressDetails(toBundleObject(map))
+    }
+
+    internal fun buildAddress(bundle: Bundle?): PaymentSheet.Address? {
+      if (bundle == null) {
+        return null
+      }
+      return PaymentSheet.Address(
+        city = bundle.getString("city"),
+        country = bundle.getString("country"),
+        line1 = bundle.getString("line1"),
+        line2 = bundle.getString("line2"),
+        state = bundle.getString("state"),
+        postalCode = bundle.getString("postalCode")
+      )
+    }
+
+    internal fun getFieldConfiguration(key: String?): AddressLauncher.AdditionalFieldsConfiguration.FieldConfiguration {
+      return when (key) {
+        "hidden" -> AddressLauncher.AdditionalFieldsConfiguration.FieldConfiguration.HIDDEN
+        "optional" -> AddressLauncher.AdditionalFieldsConfiguration.FieldConfiguration.OPTIONAL
+        "required" -> AddressLauncher.AdditionalFieldsConfiguration.FieldConfiguration.REQUIRED
+        else -> AddressLauncher.AdditionalFieldsConfiguration.FieldConfiguration.HIDDEN
+      }
+    }
+
+    internal fun buildAdditionalFieldsConfiguration(params: ReadableMap): AddressLauncher.AdditionalFieldsConfiguration {
+      val phoneConfiguration = getFieldConfiguration(params.getString("phoneNumber"))
+
+      return AddressLauncher.AdditionalFieldsConfiguration(
+        phone = phoneConfiguration,
+        checkboxLabel = params.getString("checkboxLabel")
+      )
+    }
+
+    internal fun buildResult(addressDetails: AddressDetails): WritableMap {
+      val result = WritableNativeMap()
+      result.putString("name", addressDetails.name)
+      WritableNativeMap().let {
+        it.putString("city", addressDetails.address?.city)
+        it.putString("country", addressDetails.address?.country)
+        it.putString("line1", addressDetails.address?.line1)
+        it.putString("line2", addressDetails.address?.line2)
+        it.putString("postalCode", addressDetails.address?.postalCode)
+        it.putString("state", addressDetails.address?.state)
+        result.putMap("address", it)
+      }
+      result.putString("phone", addressDetails.phoneNumber)
+      result.putBoolean("isCheckboxSelected", addressDetails.isCheckboxSelected ?: false)
+      return result
+    }
+  }
+}

package/android/src/main/java/com/reactnativestripesdk/addresssheet/AddressSheetViewManager.kt

@@ -0,0 +1,67 @@
+package com.reactnativestripesdk.addresssheet
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class AddressSheetViewManager : SimpleViewManager<AddressSheetView>() {
+  override fun getName() = "AddressSheetView"
+
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
+    return MapBuilder.of(
+      AddressSheetEvent.ON_SUBMIT, MapBuilder.of("registrationName", "onSubmitAction"),
+      AddressSheetEvent.ON_ERROR, MapBuilder.of("registrationName", "onErrorAction"))
+  }
+
+  @ReactProp(name = "visible")
+  fun setVisible(view: AddressSheetView, visibility: Boolean) {
+    view.setVisible(visibility)
+  }
+
+  @ReactProp(name = "appearance")
+  fun setAppearance(view: AddressSheetView, appearance: ReadableMap) {
+    view.setAppearance(appearance)
+  }
+
+  @ReactProp(name = "defaultValues")
+  fun setDefaultValues(view: AddressSheetView, defaults: ReadableMap) {
+    view.setDefaultValues(defaults)
+  }
+
+  @ReactProp(name = "additionalFields")
+  fun setAdditionalFields(view: AddressSheetView, fields: ReadableMap) {
+    view.setAdditionalFields(fields)
+  }
+
+  @ReactProp(name = "allowedCountries")
+  fun setAllowedCountries(view: AddressSheetView, countries: ReadableArray) {
+    view.setAllowedCountries(countries.toArrayList().filterIsInstance<String>())
+  }
+
+  @ReactProp(name = "autocompleteCountries")
+  fun setAutocompleteCountries(view: AddressSheetView, countries: ReadableArray) {
+    view.setAutocompleteCountries(countries.toArrayList().filterIsInstance<String>())
+  }
+
+  @ReactProp(name = "primaryButtonTitle")
+  fun setPrimaryButtonTitle(view: AddressSheetView, title: String) {
+    view.setPrimaryButtonTitle(title)
+  }
+
+  @ReactProp(name = "sheetTitle")
+  fun setSheetTitle(view: AddressSheetView, title: String) {
+    view.setSheetTitle(title)
+  }
+
+  @ReactProp(name = "googlePlacesApiKey")
+  fun setGooglePlacesApiKey(view: AddressSheetView, key: String) {
+    view.setGooglePlacesApiKey(key)
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): AddressSheetView {
+    return AddressSheetView(reactContext)
+  }
+}

package/android/src/main/java/com/reactnativestripesdk/utils/Extensions.kt

@@ -6,6 +6,7 @@ import android.view.inputmethod.InputMethodManager
 import androidx.appcompat.app.AppCompatActivity
 import androidx.fragment.app.Fragment
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
 
 fun View.showSoftKeyboard() {
   post {
@@ -30,3 +31,7 @@ fun Fragment.removeFragment(context: ReactApplicationContext) {
     }
   }
 }
+
+fun ReadableMap.getBooleanOr(key: String, default: Boolean): Boolean {
+  return if (this.hasKey(key)) this.getBoolean(key) else default
+}

package/android/src/main/java/com/reactnativestripesdk/utils/Mappers.kt

@@ -487,7 +487,7 @@ internal fun mapNextAction(type: NextActionType?, data: NextActionData?): Writab
     NextActionType.AlipayRedirect -> { // TODO: Can't access, private
       return null
     }
-    NextActionType.BlikAuthorize, NextActionType.UseStripeSdk, null -> {
+    NextActionType.BlikAuthorize, NextActionType.UseStripeSdk, NextActionType.UpiAwaitNotification,  null -> {
       return null
     }
   }