@stripe/stripe-react-native 0.57.2 → 0.57.3

package/android/build.gradle

@@ -183,6 +183,7 @@ dependencies {
   testImplementation "org.mockito:mockito-core:3.+"
   testImplementation "org.robolectric:robolectric:4.10"
   testImplementation "androidx.test:core:1.4.0"
+  testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.0"
 
   implementation "androidx.compose.ui:ui:1.7.8"
   implementation "androidx.compose.foundation:foundation-layout:1.7.8"

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

@@ -58,8 +58,11 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withTimeoutOrNull
 import java.io.ByteArrayOutputStream
 import kotlin.Exception
+import kotlin.coroutines.resume
 
 @OptIn(
   ReactNativeSdkInternal::class,
@@ -140,28 +143,42 @@ class PaymentSheetManager(
 
     val paymentOptionCallback =
       PaymentOptionResultCallback { paymentOptionResult ->
-        val result =
-          paymentOptionResult.paymentOption?.let {
-            val bitmap = getBitmapFromDrawable(it.icon())
-            val imageString = getBase64FromBitmap(bitmap)
+        paymentOptionResult.paymentOption?.let { paymentOption ->
+          // Convert drawable to bitmap asynchronously to avoid shared state issues
+          CoroutineScope(Dispatchers.Default).launch {
+            val imageString =
+              try {
+                convertDrawableToBase64(paymentOption.icon())
+              } catch (e: Exception) {
+                val result =
+                  createError(
+                    PaymentSheetErrorType.Failed.toString(),
+                    "Failed to process payment option image: ${e.message}",
+                  )
+                resolvePresentPromise(result)
+                return@launch
+              }
+
             val option: WritableMap = Arguments.createMap()
-            option.putString("label", it.label)
+            option.putString("label", paymentOption.label)
             option.putString("image", imageString)
             val additionalFields: Map<String, Any> = mapOf("didCancel" to paymentOptionResult.didCancel)
-            createResult("paymentOption", option, additionalFields)
+            val result = createResult("paymentOption", option, additionalFields)
+            resolvePresentPromise(result)
           }
-            ?: run {
-              if (paymentSheetTimedOut) {
-                paymentSheetTimedOut = false
-                createError(PaymentSheetErrorType.Timeout.toString(), "The payment has timed out")
-              } else {
-                createError(
-                  PaymentSheetErrorType.Canceled.toString(),
-                  "The payment option selection flow has been canceled",
-                )
-              }
+        } ?: run {
+          val result =
+            if (paymentSheetTimedOut) {
+              paymentSheetTimedOut = false
+              createError(PaymentSheetErrorType.Timeout.toString(), "The payment has timed out")
+            } else {
+              createError(
+                PaymentSheetErrorType.Canceled.toString(),
+                "The payment option selection flow has been canceled",
+              )
             }
-        resolvePresentPromise(result)
+          resolvePresentPromise(result)
+        }
       }
 
     val paymentResultCallback =
@@ -413,16 +430,31 @@ class PaymentSheetManager(
   private fun configureFlowController() {
     val onFlowControllerConfigure =
       PaymentSheet.FlowController.ConfigCallback { _, _ ->
-        val result =
-          flowController?.getPaymentOption()?.let {
-            val bitmap = getBitmapFromDrawable(it.icon())
-            val imageString = getBase64FromBitmap(bitmap)
+        flowController?.getPaymentOption()?.let { paymentOption ->
+          // Launch async job to convert drawable, but resolve promise synchronously
+          CoroutineScope(Dispatchers.Default).launch {
+            val imageString =
+              try {
+                convertDrawableToBase64(paymentOption.icon())
+              } catch (e: Exception) {
+                val result =
+                  createError(
+                    PaymentSheetErrorType.Failed.toString(),
+                    "Failed to process payment option image: ${e.message}",
+                  )
+                initPromise.resolve(result)
+                return@launch
+              }
+
             val option: WritableMap = Arguments.createMap()
-            option.putString("label", it.label)
+            option.putString("label", paymentOption.label)
             option.putString("image", imageString)
-            createResult("paymentOption", option)
-          } ?: run { Arguments.createMap() }
-        initPromise.resolve(result)
+            val result = createResult("paymentOption", option)
+            initPromise.resolve(result)
+          }
+        } ?: run {
+          initPromise.resolve(Arguments.createMap())
+        }
       }
 
     if (!paymentIntentClientSecret.isNullOrEmpty()) {
@@ -550,17 +582,86 @@ class PaymentSheetManager(
   }
 }
 
+suspend fun waitForDrawableToLoad(
+  drawable: Drawable,
+  timeoutMs: Long = 3000,
+): Drawable {
+  // If already loaded, return immediately
+  if (drawable.intrinsicWidth > 1 && drawable.intrinsicHeight > 1) {
+    return drawable
+  }
+
+  // Use callback to be notified when drawable finishes loading
+  return withTimeoutOrNull(timeoutMs) {
+    suspendCancellableCoroutine { continuation ->
+      val callback =
+        object : Drawable.Callback {
+          override fun invalidateDrawable(who: Drawable) {
+            // Drawable has changed/loaded - check if it's ready now
+            if (who.intrinsicWidth > 1 && who.intrinsicHeight > 1) {
+              who.callback = null // Remove callback
+              if (continuation.isActive) {
+                continuation.resume(who)
+              }
+            }
+          }
+
+          override fun scheduleDrawable(
+            who: Drawable,
+            what: Runnable,
+            `when`: Long,
+          ) {}
+
+          override fun unscheduleDrawable(
+            who: Drawable,
+            what: Runnable,
+          ) {}
+        }
+
+      drawable.callback = callback
+
+      // Trigger an invalidation to check if it loads immediately
+      drawable.invalidateSelf()
+
+      continuation.invokeOnCancellation { drawable.callback = null }
+    }
+  } ?: drawable // Return drawable even if timeout (best effort)
+}
+
+suspend fun convertDrawableToBase64(drawable: Drawable): String? {
+  val loadedDrawable = waitForDrawableToLoad(drawable)
+  val bitmap = getBitmapFromDrawable(loadedDrawable)
+  return getBase64FromBitmap(bitmap)
+}
+
 fun getBitmapFromDrawable(drawable: Drawable): Bitmap? {
   val drawableCompat = DrawableCompat.wrap(drawable).mutate()
-  if (drawableCompat.intrinsicWidth <= 0 || drawableCompat.intrinsicHeight <= 0) {
+
+  // Determine the size to use - prefer intrinsic size, fall back to bounds
+  val width =
+    if (drawableCompat.intrinsicWidth > 0) {
+      drawableCompat.intrinsicWidth
+    } else {
+      drawableCompat.bounds.width()
+    }
+
+  val height =
+    if (drawableCompat.intrinsicHeight > 0) {
+      drawableCompat.intrinsicHeight
+    } else {
+      drawableCompat.bounds.height()
+    }
+
+  if (width <= 0 || height <= 0) {
     return null
   }
-  val bitmap =
-    createBitmap(drawableCompat.intrinsicWidth, drawableCompat.intrinsicHeight)
+
+  val bitmap = createBitmap(width, height, Bitmap.Config.ARGB_8888)
   bitmap.eraseColor(Color.TRANSPARENT)
   val canvas = Canvas(bitmap)
-  drawable.setBounds(0, 0, canvas.width, canvas.height)
-  drawable.draw(canvas)
+  drawableCompat.setBounds(0, 0, canvas.width, canvas.height)
+  drawableCompat.draw(canvas)
+
   return bitmap
 }
 

package/android/src/main/java/com/reactnativestripesdk/customersheet/CustomerSheetManager.kt

@@ -17,8 +17,7 @@ import com.reactnativestripesdk.ReactNativeCustomerSessionProvider
 import com.reactnativestripesdk.buildBillingDetails
 import com.reactnativestripesdk.buildBillingDetailsCollectionConfiguration
 import com.reactnativestripesdk.buildPaymentSheetAppearance
-import com.reactnativestripesdk.getBase64FromBitmap
-import com.reactnativestripesdk.getBitmapFromDrawable
+import com.reactnativestripesdk.convertDrawableToBase64
 import com.reactnativestripesdk.mapToCardBrandAcceptance
 import com.reactnativestripesdk.utils.CreateTokenErrorType
 import com.reactnativestripesdk.utils.ErrorType
@@ -163,25 +162,49 @@ class CustomerSheetManager(
   }
 
   private fun handleResult(result: CustomerSheetResult) {
-    var promiseResult = Arguments.createMap()
     when (result) {
       is CustomerSheetResult.Failed -> {
         resolvePresentPromise(createError(ErrorType.Failed.toString(), result.exception))
       }
 
       is CustomerSheetResult.Selected -> {
-        promiseResult = createPaymentOptionResult(result.selection)
+        // Convert drawable asynchronously to avoid shared state issues
+        CoroutineScope(Dispatchers.Default).launch {
+          try {
+            val promiseResult = createPaymentOptionResult(result.selection)
+            resolvePresentPromise(promiseResult)
+          } catch (e: Exception) {
+            resolvePresentPromise(
+              createError(
+                ErrorType.Failed.toString(),
+                "Failed to process payment option image: ${e.message}",
+              ),
+            )
+          }
+        }
       }
 
       is CustomerSheetResult.Canceled -> {
-        promiseResult = createPaymentOptionResult(result.selection)
-        promiseResult.putMap(
-          "error",
-          Arguments.createMap().also { it.putString("code", ErrorType.Canceled.toString()) },
-        )
+        // Convert drawable asynchronously to avoid shared state issues
+        CoroutineScope(Dispatchers.Default).launch {
+          try {
+            val promiseResult = createPaymentOptionResult(result.selection)
+            promiseResult.putMap(
+              "error",
+              Arguments.createMap().also { it.putString("code", ErrorType.Canceled.toString()) },
+            )
+            resolvePresentPromise(promiseResult)
+          } catch (e: Exception) {
+            resolvePresentPromise(
+              createError(
+                ErrorType.Failed.toString(),
+                "Failed to process payment option image: ${e.message}",
+              ),
+            )
+          }
+        }
       }
     }
-    resolvePresentPromise(promiseResult)
   }
 
   override fun onPresent() {
@@ -355,7 +378,7 @@ class CustomerSheetManager(
       )
     }
 
-    internal fun createPaymentOptionResult(selection: PaymentOptionSelection?): WritableMap {
+    internal suspend fun createPaymentOptionResult(selection: PaymentOptionSelection?): WritableMap {
       var paymentOptionResult = Arguments.createMap()
 
       when (selection) {
@@ -392,16 +415,18 @@ class CustomerSheetManager(
           }.build()
       }
 
-    private fun buildResult(
+    private suspend fun buildResult(
       label: String,
       drawable: Drawable,
       paymentMethod: PaymentMethod?,
     ): WritableMap {
+      val imageString = convertDrawableToBase64(drawable)
+
       val result = Arguments.createMap()
       val paymentOption =
         Arguments.createMap().also {
           it.putString("label", label)
-          it.putString("image", getBase64FromBitmap(getBitmapFromDrawable(drawable)))
+          it.putString("image", imageString)
         }
       result.putMap("paymentOption", paymentOption)
       if (paymentMethod != null) {

package/android/src/test/java/com/reactnativestripesdk/DrawableConversionPropertyTest.kt

@@ -0,0 +1,224 @@
+package com.reactnativestripesdk
+
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import kotlin.random.Random
+
+/**
+ * Property-based tests for drawable conversion.
+ * These tests verify mathematical properties that should always hold true.
+ */
+@RunWith(RobolectricTestRunner::class)
+class DrawableConversionPropertyTest {
+  @Test
+  fun `PROPERTY - conversion is idempotent`() =
+    runTest {
+      // Property: Converting the same drawable multiple times yields same result
+      repeat(20) {
+        val color =
+          Color.rgb(
+            Random.nextInt(256),
+            Random.nextInt(256),
+            Random.nextInt(256),
+          )
+        val width = Random.nextInt(50, 200)
+        val height = Random.nextInt(50, 200)
+
+        val drawable =
+          ColorDrawable(color).apply {
+            setBounds(0, 0, width, height)
+          }
+
+        val result1 = convertDrawableToBase64(drawable)
+        val result2 = convertDrawableToBase64(drawable)
+
+        assertEquals(
+          "Same drawable should always produce same base64 (iteration $it, ${width}x$height)",
+          result1,
+          result2,
+        )
+      }
+    }
+
+  @Test
+  fun `PROPERTY - different drawables produce different base64`() =
+    runTest {
+      val drawable1 =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 100, 100)
+        }
+      val drawable2 =
+        ColorDrawable(Color.BLUE).apply {
+          setBounds(0, 0, 100, 100)
+        }
+
+      val result1 = convertDrawableToBase64(drawable1)
+      val result2 = convertDrawableToBase64(drawable2)
+
+      assertNotEquals(
+        "Different colored drawables should produce different base64",
+        result1,
+        result2,
+      )
+    }
+
+  @Test
+  fun `PROPERTY - base64 length scales with drawable size`() =
+    runTest {
+      val small =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 50, 50)
+        }
+      val medium =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 100, 100)
+        }
+      val large =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 200, 200)
+        }
+
+      val smallResult = convertDrawableToBase64(small)
+      val mediumResult = convertDrawableToBase64(medium)
+      val largeResult = convertDrawableToBase64(large)
+
+      assertNotNull(smallResult)
+      assertNotNull(mediumResult)
+      assertNotNull(largeResult)
+
+      assertTrue(
+        "Medium drawable should produce longer base64 than small",
+        mediumResult!!.length > smallResult!!.length,
+      )
+      assertTrue(
+        "Large drawable should produce longer base64 than medium",
+        largeResult!!.length > mediumResult.length,
+      )
+    }
+
+  @Test
+  fun `PROPERTY - conversion preserves drawable dimensions`() =
+    runTest {
+      val testSizes =
+        listOf(
+          Pair(50, 50),
+          Pair(100, 75),
+          Pair(147, 105), // Typical card icon
+          Pair(200, 150),
+          Pair(250, 200),
+        )
+
+      testSizes.forEach { (width, height) ->
+        val drawable =
+          ColorDrawable(Color.GREEN).apply {
+            setBounds(0, 0, width, height)
+          }
+
+        val bitmap = getBitmapFromDrawable(drawable)
+
+        assertNotNull("Bitmap should not be null for ${width}x$height", bitmap)
+        assertEquals("Width should be preserved for ${width}x$height", width, bitmap!!.width)
+        assertEquals("Height should be preserved for ${width}x$height", height, bitmap.height)
+      }
+    }
+
+  @Test
+  fun `PROPERTY - null input produces null output consistently`() =
+    runTest {
+      // Invalid drawables (no bounds set) should consistently return null
+      val invalidDrawable1 = ColorDrawable(Color.RED)
+      val invalidDrawable2 = ColorDrawable(Color.BLUE)
+
+      val result1 = convertDrawableToBase64(invalidDrawable1)
+      val result2 = convertDrawableToBase64(invalidDrawable2)
+
+      assertNotNull("Result1 should be null for invalid drawable", result1 == null)
+      assertNotNull("Result2 should be null for invalid drawable", result2 == null)
+    }
+
+  @Test
+  fun `PROPERTY - aspect ratio is preserved in bitmap`() {
+    val testCases =
+      listOf(
+        Triple(100, 100, 1.0), // Square
+        Triple(200, 100, 2.0), // 2:1
+        Triple(147, 105, 1.4), // Card icon ratio
+        Triple(100, 200, 0.5), // Portrait
+      )
+
+    testCases.forEach { (width, height, expectedRatio) ->
+      val drawable =
+        ColorDrawable(Color.YELLOW).apply {
+          setBounds(0, 0, width, height)
+        }
+
+      val bitmap = getBitmapFromDrawable(drawable)
+
+      assertNotNull(bitmap)
+      val actualRatio = bitmap!!.width.toDouble() / bitmap.height.toDouble()
+      assertEquals(
+        "Aspect ratio should be preserved for ${width}x$height",
+        expectedRatio,
+        actualRatio,
+        0.01, // Allow small floating point error
+      )
+    }
+  }
+
+  @Test
+  fun `PROPERTY - conversion is deterministic across multiple runs`() =
+    runTest {
+      // Same drawable, converted multiple times in sequence, should always yield same result
+      val drawable =
+        ColorDrawable(Color.CYAN).apply {
+          setBounds(0, 0, 120, 90)
+        }
+
+      val results = (1..15).map { convertDrawableToBase64(drawable) }
+
+      // All results should be identical
+      val firstResult = results.first()
+      results.forEach { result ->
+        assertEquals("All conversions should be identical", firstResult, result)
+      }
+    }
+
+  @Test
+  fun `PROPERTY - different sizes with same color produce different base64`() =
+    runTest {
+      val color = Color.rgb(100, 150, 200)
+
+      val sizes =
+        listOf(
+          Pair(50, 50),
+          Pair(75, 75),
+          Pair(100, 100),
+          Pair(125, 125),
+        )
+
+      val results =
+        sizes.map { (width, height) ->
+          val drawable =
+            ColorDrawable(color).apply {
+              setBounds(0, 0, width, height)
+            }
+          convertDrawableToBase64(drawable)
+        }
+
+      // All results should be different (different sizes → different images)
+      val uniqueResults = results.toSet()
+      assertEquals(
+        "Different sizes should produce different base64 even with same color",
+        results.size,
+        uniqueResults.size,
+      )
+    }
+}

package/android/src/test/java/com/reactnativestripesdk/DrawableConversionTest.kt

@@ -0,0 +1,146 @@
+package com.reactnativestripesdk
+
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class DrawableConversionTest {
+  // ============================================
+  // convertDrawableToBase64 Tests
+  // ============================================
+
+  @Test
+  fun `convertDrawableToBase64 returns non-null for valid drawable`() =
+    runTest {
+      val drawable =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 100, 100)
+        }
+
+      val result = convertDrawableToBase64(drawable)
+
+      assertNotNull("Base64 should not be null for valid drawable", result)
+      assertTrue("Base64 should not be empty", result!!.isNotEmpty())
+    }
+
+  @Test
+  fun `convertDrawableToBase64 returns consistent results for same drawable`() =
+    runTest {
+      val drawable =
+        ColorDrawable(Color.BLUE).apply {
+          setBounds(0, 0, 100, 100)
+        }
+
+      val result1 = convertDrawableToBase64(drawable)
+      val result2 = convertDrawableToBase64(drawable)
+      val result3 = convertDrawableToBase64(drawable)
+
+      assertEquals("Multiple calls should return identical base64", result1, result2)
+      assertEquals("Multiple calls should return identical base64", result2, result3)
+    }
+
+  @Test
+  fun `convertDrawableToBase64 returns null for invalid drawable`() =
+    runTest {
+      // Drawable with 0 intrinsic size (never set bounds)
+      val drawable = ColorDrawable(Color.RED)
+
+      val result = convertDrawableToBase64(drawable)
+
+      assertNull("Base64 should be null for invalid drawable", result)
+    }
+
+  @Test
+  fun `convertDrawableToBase64 result is valid base64 format`() =
+    runTest {
+      val drawable =
+        ColorDrawable(Color.GREEN).apply {
+          setBounds(0, 0, 50, 50)
+        }
+
+      val result = convertDrawableToBase64(drawable)
+
+      assertNotNull(result)
+      // Valid base64 should match pattern: [A-Za-z0-9+/=]+
+      assertTrue(
+        "Result should be valid base64",
+        result!!.matches(Regex("^[A-Za-z0-9+/=\\n]+$")),
+      )
+    }
+
+  @Test
+  fun `convertDrawableToBase64 result size is reasonable`() =
+    runTest {
+      val drawable =
+        ColorDrawable(Color.YELLOW).apply {
+          setBounds(0, 0, 100, 100)
+        }
+
+      val result = convertDrawableToBase64(drawable)
+
+      assertNotNull(result)
+      // Should be larger than tiny placeholder (134 bytes)
+      // but smaller than unreasonably large
+      assertTrue(
+        "Base64 should be larger than 200 chars (not a 1x1 placeholder)",
+        result!!.length > 200,
+      )
+      assertTrue(
+        "Base64 should be smaller than 100KB",
+        result.length < 100_000,
+      )
+    }
+
+  // ============================================
+  // getBitmapFromDrawable Tests
+  // ============================================
+
+  @Test
+  fun `getBitmapFromDrawable returns correct size bitmap`() {
+    val drawable =
+      ColorDrawable(Color.CYAN).apply {
+        setBounds(0, 0, 150, 100)
+      }
+
+    val bitmap = getBitmapFromDrawable(drawable)
+
+    assertNotNull("Bitmap should not be null", bitmap)
+    assertEquals("Bitmap width should match drawable", 150, bitmap!!.width)
+    assertEquals("Bitmap height should match drawable", 100, bitmap.height)
+    assertEquals("Bitmap should use ARGB_8888", Bitmap.Config.ARGB_8888, bitmap.config)
+  }
+
+  @Test
+  fun `getBitmapFromDrawable returns null for zero-size drawable`() {
+    val drawable = ColorDrawable(Color.MAGENTA)
+    // Don't set bounds, intrinsic size will be -1
+
+    val bitmap = getBitmapFromDrawable(drawable)
+
+    assertNull("Bitmap should be null for invalid drawable", bitmap)
+  }
+
+  @Test
+  fun `getBitmapFromDrawable preserves drawable dimensions`() {
+    // Test with typical card icon dimensions
+    val drawable =
+      ColorDrawable(Color.RED).apply {
+        setBounds(0, 0, 147, 105)
+      }
+
+    val bitmap = getBitmapFromDrawable(drawable)
+
+    assertNotNull(bitmap)
+    assertEquals("Width should be preserved", 147, bitmap!!.width)
+    assertEquals("Height should be preserved", 105, bitmap.height)
+  }
+}