@stripe/stripe-react-native 0.41.0 → 0.43.0

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

@@ -7,19 +7,32 @@ import android.view.ViewGroup
 import android.widget.FrameLayout
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentActivity
-import com.facebook.react.bridge.*
-import com.reactnativestripesdk.utils.*
+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.createError
 import com.reactnativestripesdk.utils.createMissingActivityError
+import com.reactnativestripesdk.utils.mapFromFinancialConnectionsEvent
 import com.reactnativestripesdk.utils.mapFromToken
+import com.stripe.android.financialconnections.FinancialConnections
 import com.stripe.android.financialconnections.FinancialConnectionsSheet
 import com.stripe.android.financialconnections.FinancialConnectionsSheetForTokenResult
 import com.stripe.android.financialconnections.FinancialConnectionsSheetResult
-import com.stripe.android.financialconnections.model.*
+import com.stripe.android.financialconnections.model.Balance
+import com.stripe.android.financialconnections.model.BalanceRefresh
+import com.stripe.android.financialconnections.model.FinancialConnectionsAccount
+import com.stripe.android.financialconnections.model.FinancialConnectionsAccountList
+import com.stripe.android.financialconnections.model.FinancialConnectionsSession
 
 class FinancialConnectionsSheetFragment : Fragment() {
   enum class Mode {
-    ForToken, ForSession
+    ForToken,
+    ForSession,
   }
 
   private lateinit var promise: Promise
@@ -27,104 +40,132 @@ class FinancialConnectionsSheetFragment : Fragment() {
   private lateinit var configuration: FinancialConnectionsSheet.Configuration
   private lateinit var mode: Mode
 
-  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
-                            savedInstanceState: Bundle?): View {
-    return FrameLayout(requireActivity()).also {
-      it.visibility = View.GONE
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    val stripeSdkModule: StripeSdkModule? = context.getNativeModule(StripeSdkModule::class.java)
+    if (stripeSdkModule != null && stripeSdkModule.eventListenerCount > 0) {
+      FinancialConnections.setEventListener { event ->
+        val params = mapFromFinancialConnectionsEvent(event)
+        stripeSdkModule.sendEvent(context, "onFinancialConnectionsEvent", params)
+      }
     }
   }
 
-  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+  override fun onCreateView(
+    inflater: LayoutInflater,
+    container: ViewGroup?,
+    savedInstanceState: Bundle?,
+  ): View = FrameLayout(requireActivity()).also { it.visibility = View.GONE }
+
+  override fun onViewCreated(
+    view: View,
+    savedInstanceState: Bundle?,
+  ) {
     when (mode) {
       Mode.ForToken -> {
-        FinancialConnectionsSheet.createForBankAccountToken(
-          this,
-          ::onFinancialConnectionsSheetForTokenResult
-        ).present(
-          configuration = configuration
-        )
+        FinancialConnectionsSheet
+          .createForBankAccountToken(
+            this,
+            ::onFinancialConnectionsSheetForTokenResult,
+          ).present(configuration = configuration)
       }
       Mode.ForSession -> {
-        FinancialConnectionsSheet.create(
-          this,
-          ::onFinancialConnectionsSheetForDataResult
-        ).present(
-          configuration = configuration
-        )
+        FinancialConnectionsSheet
+          .create(this, ::onFinancialConnectionsSheetForDataResult)
+          .present(configuration = configuration)
       }
     }
   }
 
+  override fun onDestroy() {
+    super.onDestroy()
+
+    // Remove any event listener that might be set
+    FinancialConnections.clearEventListener()
+  }
+
   private fun onFinancialConnectionsSheetForTokenResult(result: FinancialConnectionsSheetForTokenResult) {
-    when(result) {
+    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()
+        (context.currentActivity as? FragmentActivity)
+          ?.supportFragmentManager
+          ?.beginTransaction()
+          ?.remove(this)
+          ?.commitAllowingStateLoss()
       }
     }
   }
 
   private fun onFinancialConnectionsSheetForDataResult(result: FinancialConnectionsSheetResult) {
-    when(result) {
+    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 {
-              it.putMap("session", mapFromSession(result.financialConnectionsSession))
-            }
+          WritableNativeMap().also {
+            it.putMap("session", mapFromSession(result.financialConnectionsSession))
+          },
         )
-        (context.currentActivity as? FragmentActivity)?.supportFragmentManager?.beginTransaction()?.remove(this)?.commitAllowingStateLoss()
+        (context.currentActivity as? FragmentActivity)
+          ?.supportFragmentManager
+          ?.beginTransaction()
+          ?.remove(this)
+          ?.commitAllowingStateLoss()
       }
     }
   }
 
-  fun presentFinancialConnectionsSheet(clientSecret: String, mode: Mode, publishableKey: String, stripeAccountId: String?, promise: Promise, context: ReactApplicationContext) {
+  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,
-    )
+    this.configuration =
+      FinancialConnectionsSheet.Configuration(
+        financialConnectionsSessionClientSecret = clientSecret,
+        publishableKey = publishableKey,
+        stripeAccountId = stripeAccountId,
+      )
 
     (context.currentActivity as? FragmentActivity)?.let {
       attemptToCleanupPreviousFragment(it)
       commitFragmentAndStartFlow(it)
-    } ?: run {
-      promise.resolve(createMissingActivityError())
-      return
     }
+      ?: run {
+        promise.resolve(createMissingActivityError())
+        return
+      }
   }
 
   private fun attemptToCleanupPreviousFragment(currentActivity: FragmentActivity) {
-    currentActivity.supportFragmentManager.beginTransaction()
+    currentActivity.supportFragmentManager
+      .beginTransaction()
       .remove(this)
       .commitAllowingStateLoss()
   }
 
   private fun commitFragmentAndStartFlow(currentActivity: FragmentActivity) {
     try {
-      currentActivity.supportFragmentManager.beginTransaction()
+      currentActivity.supportFragmentManager
+        .beginTransaction()
         .add(this, TAG)
         .commit()
     } catch (error: IllegalStateException) {
@@ -135,12 +176,11 @@ class FinancialConnectionsSheetFragment : Fragment() {
   companion object {
     internal const val TAG = "financial_connections_sheet_launch_fragment"
 
-    private fun createTokenResult(result: FinancialConnectionsSheetForTokenResult.Completed): WritableMap {
-      return WritableNativeMap().also {
+    private fun createTokenResult(result: FinancialConnectionsSheetForTokenResult.Completed): WritableMap =
+      WritableNativeMap().also {
         it.putMap("session", mapFromSession(result.financialConnectionsSession))
         it.putMap("token", mapFromToken(result.token))
       }
-    }
 
     private fun mapFromSession(financialConnectionsSession: FinancialConnectionsSession): WritableMap {
       val session = WritableNativeMap()
@@ -166,8 +206,19 @@ class FinancialConnectionsSheetFragment : Fragment() {
         map.putMap("balanceRefresh", mapFromAccountBalanceRefresh(account.balanceRefresh))
         map.putString("category", mapFromCategory(account.category))
         map.putString("subcategory", mapFromSubcategory(account.subcategory))
-        map.putArray("permissions", (account.permissions?.map { permission -> mapFromPermission(permission) })?.toReadableArray())
-        map.putArray("supportedPaymentMethodTypes", (account.supportedPaymentMethodTypes.map { type -> mapFromSupportedPaymentMethodTypes(type) }).toReadableArray())
+        map.putArray(
+          "permissions",
+          (account.permissions?.map { permission -> mapFromPermission(permission) })
+            ?.toReadableArray(),
+        )
+        map.putArray(
+          "supportedPaymentMethodTypes",
+          (
+            account.supportedPaymentMethodTypes.map { type ->
+              mapFromSupportedPaymentMethodTypes(type)
+            }
+          ).toReadableArray(),
+        )
         results.pushMap(map)
       }
       return results
@@ -192,8 +243,8 @@ class FinancialConnectionsSheetFragment : Fragment() {
       return map
     }
 
-    private fun mapFromCashAvailable(balance: Balance): WritableNativeMap {
-      return WritableNativeMap().also { cashMap ->
+    private fun mapFromCashAvailable(balance: Balance): WritableNativeMap =
+      WritableNativeMap().also { cashMap ->
         WritableNativeMap().also { availableMap ->
           balance.cash?.available?.entries?.let { entries ->
             for (entry in entries) {
@@ -203,10 +254,9 @@ class FinancialConnectionsSheetFragment : Fragment() {
           cashMap.putMap("available", availableMap)
         }
       }
-    }
 
-    private fun mapFromCreditUsed(balance: Balance): WritableNativeMap {
-      return WritableNativeMap().also { creditMap ->
+    private fun mapFromCreditUsed(balance: Balance): WritableNativeMap =
+      WritableNativeMap().also { creditMap ->
         WritableNativeMap().also { usedMap ->
           balance.credit?.used?.entries?.let { entries ->
             for (entry in entries) {
@@ -216,7 +266,6 @@ class FinancialConnectionsSheetFragment : Fragment() {
           creditMap.putMap("used", usedMap)
         }
       }
-    }
 
     private fun mapFromAccountBalanceRefresh(balanceRefresh: BalanceRefresh?): WritableMap? {
       if (balanceRefresh == null) {
@@ -228,27 +277,25 @@ class FinancialConnectionsSheetFragment : Fragment() {
       return map
     }
 
-    private fun mapFromStatus(status: FinancialConnectionsAccount.Status): String {
-      return when (status) {
+    private fun mapFromStatus(status: FinancialConnectionsAccount.Status): String =
+      when (status) {
         FinancialConnectionsAccount.Status.ACTIVE -> "active"
         FinancialConnectionsAccount.Status.DISCONNECTED -> "disconnected"
         FinancialConnectionsAccount.Status.INACTIVE -> "inactive"
         FinancialConnectionsAccount.Status.UNKNOWN -> "unparsable"
       }
-    }
 
-    private fun mapFromCategory(category: FinancialConnectionsAccount.Category): String {
-      return when (category) {
+    private fun mapFromCategory(category: FinancialConnectionsAccount.Category): String =
+      when (category) {
         FinancialConnectionsAccount.Category.CASH -> "cash"
         FinancialConnectionsAccount.Category.CREDIT -> "credit"
         FinancialConnectionsAccount.Category.INVESTMENT -> "investment"
         FinancialConnectionsAccount.Category.OTHER -> "other"
         FinancialConnectionsAccount.Category.UNKNOWN -> "unparsable"
       }
-    }
 
-    private fun mapFromSubcategory(subcategory: FinancialConnectionsAccount.Subcategory): String {
-      return when (subcategory) {
+    private fun mapFromSubcategory(subcategory: FinancialConnectionsAccount.Subcategory): String =
+      when (subcategory) {
         FinancialConnectionsAccount.Subcategory.CHECKING -> "checking"
         FinancialConnectionsAccount.Subcategory.CREDIT_CARD -> "creditCard"
         FinancialConnectionsAccount.Subcategory.LINE_OF_CREDIT -> "lineOfCredit"
@@ -257,10 +304,9 @@ class FinancialConnectionsSheetFragment : Fragment() {
         FinancialConnectionsAccount.Subcategory.SAVINGS -> "savings"
         FinancialConnectionsAccount.Subcategory.UNKNOWN -> "unparsable"
       }
-    }
 
-    private fun mapFromPermission(permission: FinancialConnectionsAccount.Permissions): String {
-      return when (permission) {
+    private fun mapFromPermission(permission: FinancialConnectionsAccount.Permissions): String =
+      when (permission) {
         FinancialConnectionsAccount.Permissions.PAYMENT_METHOD -> "paymentMethod"
         FinancialConnectionsAccount.Permissions.BALANCES -> "balances"
         FinancialConnectionsAccount.Permissions.OWNERSHIP -> "ownership"
@@ -269,33 +315,29 @@ class FinancialConnectionsSheetFragment : Fragment() {
         FinancialConnectionsAccount.Permissions.UNKNOWN -> "unparsable"
         FinancialConnectionsAccount.Permissions.ACCOUNT_NUMBERS -> "accountNumbers"
       }
-    }
 
-    private fun mapFromSupportedPaymentMethodTypes(type: FinancialConnectionsAccount.SupportedPaymentMethodTypes): String {
-      return when (type) {
+    private fun mapFromSupportedPaymentMethodTypes(type: FinancialConnectionsAccount.SupportedPaymentMethodTypes): String =
+      when (type) {
         FinancialConnectionsAccount.SupportedPaymentMethodTypes.US_BANK_ACCOUNT -> "usBankAccount"
         FinancialConnectionsAccount.SupportedPaymentMethodTypes.LINK -> "link"
         FinancialConnectionsAccount.SupportedPaymentMethodTypes.UNKNOWN -> "unparsable"
       }
-    }
 
-    private fun mapFromBalanceType(type: Balance.Type): String {
-      return when (type) {
+    private fun mapFromBalanceType(type: Balance.Type): String =
+      when (type) {
         Balance.Type.CASH -> "cash"
         Balance.Type.CREDIT -> "credit"
         Balance.Type.UNKNOWN -> "unparsable"
       }
-    }
 
-    private fun mapFromBalanceRefreshStatus(status: BalanceRefresh.BalanceRefreshStatus?): String {
-      return when (status) {
+    private fun mapFromBalanceRefreshStatus(status: BalanceRefresh.BalanceRefreshStatus?): String =
+      when (status) {
         BalanceRefresh.BalanceRefreshStatus.SUCCEEDED -> "succeeded"
         BalanceRefresh.BalanceRefreshStatus.FAILED -> "failed"
         BalanceRefresh.BalanceRefreshStatus.PENDING -> "pending"
         BalanceRefresh.BalanceRefreshStatus.UNKNOWN -> "unparsable"
         null -> "null"
       }
-    }
   }
 }
 

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

@@ -1,19 +1,17 @@
 package com.reactnativestripesdk
+
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.Event
-import com.facebook.react.uimanager.events.RCTEventEmitter
-
-internal class FormCompleteEvent constructor(viewTag: Int, private val formDetails: MutableMap<String, Any>) : Event<FormCompleteEvent>(viewTag) {
-  override fun getEventName(): String {
-    return EVENT_NAME
-  }
 
-  override fun dispatch(rctEventEmitter: RCTEventEmitter) {
-    rctEventEmitter.receiveEvent(viewTag, eventName, serializeEventData())
-  }
+internal class FormCompleteEvent(
+  surfaceId: Int,
+  viewTag: Int,
+  private val formDetails: MutableMap<String, Any>,
+) : Event<FormCompleteEvent>(surfaceId, viewTag) {
+  override fun getEventName() = EVENT_NAME
 
-  private fun serializeEventData(): WritableMap {
+  override fun getEventData(): WritableMap? {
     val eventData = Arguments.createMap()
     eventData.putString("accountNumber", formDetails["accountNumber"].toString())
     eventData.putString("bsbNumber", formDetails["bsbNumber"].toString())
@@ -24,6 +22,6 @@ internal class FormCompleteEvent constructor(viewTag: Int, private val formDetai
   }
 
   companion object {
-    const val EVENT_NAME = "onCompleteAction"
+    const val EVENT_NAME = "topCompleteAction"
   }
 }

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

@@ -1,13 +1,13 @@
 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 = GooglePayButtonManager.REACT_CLASS)
 class GooglePayButtonManager : SimpleViewManager<GooglePayButtonView>() {
-  override fun getName(): String {
-    return REACT_CLASS
-  }
+  override fun getName() = REACT_CLASS
 
   override fun onAfterUpdateTransaction(view: GooglePayButtonView) {
     super.onAfterUpdateTransaction(view)
@@ -16,23 +16,30 @@ class GooglePayButtonManager : SimpleViewManager<GooglePayButtonView>() {
   }
 
   @ReactProp(name = "type")
-  fun type(view: GooglePayButtonView, buttonType: Int) {
+  fun type(
+    view: GooglePayButtonView,
+    buttonType: Int,
+  ) {
     view.setType(buttonType)
   }
 
   @ReactProp(name = "appearance")
-  fun appearance(view: GooglePayButtonView, appearance: Int) {
+  fun appearance(
+    view: GooglePayButtonView,
+    appearance: Int,
+  ) {
     view.setAppearance(appearance)
   }
 
   @ReactProp(name = "borderRadius")
-  fun borderRadius(view: GooglePayButtonView, borderRadius: Int) {
+  fun borderRadius(
+    view: GooglePayButtonView,
+    borderRadius: Int,
+  ) {
     view.setBorderRadius(borderRadius)
   }
 
-  override fun createViewInstance(reactContext: ThemedReactContext): GooglePayButtonView {
-    return GooglePayButtonView(reactContext)
-  }
+  override fun createViewInstance(reactContext: ThemedReactContext): GooglePayButtonView = GooglePayButtonView(reactContext)
 
   companion object {
     const val REACT_CLASS = "GooglePayButton"

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

@@ -13,7 +13,10 @@ import com.google.android.gms.wallet.button.PayButton
 import com.stripe.android.GooglePayJsonFactory
 import org.json.JSONArray
 
-class GooglePayButtonView(private val context: ThemedReactContext) : FrameLayout(context) {
+@SuppressLint("ViewConstructor")
+class GooglePayButtonView(
+  private val context: ThemedReactContext,
+) : FrameLayout(context) {
   private var type: Int? = null
   private var appearance: Int? = null
   private var borderRadius: Int = 4 // Matches the default on iOS's ApplePayButton
@@ -29,30 +32,35 @@ class GooglePayButtonView(private val context: ThemedReactContext) : FrameLayout
   }
 
   private fun configureGooglePayButton(): PayButton {
-    val googlePayButton = PayButton(
-      context
-    )
+    val googlePayButton =
+      PayButton(
+        context,
+      )
     googlePayButton.initialize(buildButtonOptions())
     googlePayButton.setOnClickListener { _ ->
       // Call the Javascript TouchableOpacity parent where the onClick handler is set
       (this.parent as? View)?.performClick() ?: run {
         Log.e("StripeReactNative", "Unable to find parent of GooglePayButtonView.")
       }
-    };
+    }
     return googlePayButton
   }
 
   @SuppressLint("RestrictedApi")
   private fun buildButtonOptions(): ButtonOptions {
-    val allowedPaymentMethods = JSONArray().put(
-      GooglePayJsonFactory(context).createCardPaymentMethod(
-        billingAddressParameters = null,
-        allowCreditCards = null
-      )
-    ).toString()
-
-    val options = ButtonOptions.newBuilder()
-      .setAllowedPaymentMethods(allowedPaymentMethods)
+    val allowedPaymentMethods =
+      JSONArray()
+        .put(
+          GooglePayJsonFactory(context).createCardPaymentMethod(
+            billingAddressParameters = null,
+            allowCreditCards = null,
+          ),
+        ).toString()
+
+    val options =
+      ButtonOptions
+        .newBuilder()
+        .setAllowedPaymentMethods(allowedPaymentMethods)
 
     getButtonType()?.let {
       options.setButtonType(it)
@@ -67,10 +75,11 @@ class GooglePayButtonView(private val context: ThemedReactContext) : FrameLayout
     return options.build()
   }
 
-  private fun getButtonType(): Int? {
-    return when (this.type) {
+  private fun getButtonType(): Int? =
+    when (this.type) {
       0,
-      1 -> ButtonType.BUY
+      1,
+      -> ButtonType.BUY
       6 -> ButtonType.BOOK
       5 -> ButtonType.CHECKOUT
       4 -> ButtonType.DONATE
@@ -80,28 +89,27 @@ class GooglePayButtonView(private val context: ThemedReactContext) : FrameLayout
       1001 -> ButtonType.PLAIN
       else -> null
     }
-  }
 
-  private fun getButtonTheme(): Int? {
-    return when (this.appearance) {
+  private fun getButtonTheme(): Int? =
+    when (this.appearance) {
       0, 1 -> ButtonTheme.LIGHT
       2 -> ButtonTheme.DARK
       else -> null
     }
-  }
 
   override fun requestLayout() {
     super.requestLayout()
     post(mLayoutRunnable)
   }
 
-  private val mLayoutRunnable = Runnable {
-    measure(
-      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
-      MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY))
-    button?.layout(left, top, right, bottom)
-
-  }
+  private val mLayoutRunnable =
+    Runnable {
+      measure(
+        MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+        MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
+      )
+      button?.layout(left, top, right, bottom)
+    }
 
   fun setType(type: Int) {
     this.type = type