@juspay-tech/react-native-hyperswitch 1.3.4 → 1.3.6

package/android/src/main/java/io/hyperswitch/paymentsession/PaymentSessionReactLauncher.kt

@@ -20,10 +20,16 @@ import com.facebook.react.jstasks.HeadlessJsTaskContext
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
 import com.facebook.react.uimanager.PixelUtil
 import com.hyperswitchsdkreactnative.BuildConfig
+import com.proyecto26.inappbrowser.ChromeTabsDismissedEvent
+import com.proyecto26.inappbrowser.ChromeTabsManagerActivity
 import io.hyperswitch.react.HyperActivity
 import io.hyperswitch.react.HyperEventEmitter
 import io.hyperswitch.react.HyperFragment
 import io.hyperswitch.react.ReactNativeController
+import io.hyperswitch.redirect.RedirectEvent
+import java.lang.ref.WeakReference
+import org.greenrobot.eventbus.EventBus
+import org.greenrobot.eventbus.Subscribe
 
 /**
  * React Native backed engine for presenting the payment sheet and running headless tasks.
@@ -32,9 +38,19 @@ import io.hyperswitch.react.ReactNativeController
  * to pass all configuration data as plain [Bundle]s or [Map]s.
  */
 class PaymentSessionReactLauncher(
-  private val activity: Activity,
+  private val activityProvider: () -> Activity?,
 ) {
 
+  constructor(activity: Activity) : this({ activity })
+
+  /**
+   * The host Activity, read on every use rather than captured once: a host Activity that is
+   * recreated (configuration change, recreate()) would otherwise leave the sheet committed to the
+   * destroyed Activity, where it is silently dropped.
+   */
+  private val activity: Activity
+    get() = checkNotNull(activityProvider()) { "No current Activity" }
+
   private var reactHost: ReactHost? = null
   private var reactNativeHost: ReactNativeHost? = null
   private var reactContext: ReactContext? = null
@@ -48,6 +64,7 @@ class PaymentSessionReactLauncher(
       if (!ReactNativeController.getIsInitialized()) {
         ReactNativeController.initialize(activity.application)
       }
+      RedirectBridge.install(activity)
       reactNativeHost = ReactNativeController.getReactNativeHost()
       reactHost = ReactNativeController.getReactHost()
 
@@ -75,7 +92,8 @@ class PaymentSessionReactLauncher(
    * Recreates the React context (if needed) and starts a headless JS task with the supplied
    * [bundle]. The caller is responsible for assembling the bundle (e.g. via [LaunchOptions]).
    */
-  fun recreateReactContext(bundle: Bundle) {
+  fun recreateReactContext(bundle: Bundle): Boolean {
+    val activity = activityProvider() ?: return false
     activity.runOnUiThread {
       var context = reactContext
       if (context == null) {
@@ -136,6 +154,7 @@ class PaymentSessionReactLauncher(
         startHeadlessTask(context, bundle)
       }
     }
+    return true
   }
 
   private fun startHeadlessTask(reactContext: ReactContext, bundle: Bundle) {
@@ -145,6 +164,7 @@ class PaymentSessionReactLauncher(
 
     val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext)
     UiThreadUtil.runOnUiThread {
+      resumeHost()
       headlessTaskId?.let {
         headlessJsTaskContext.finishTask(it)
       }
@@ -152,19 +172,63 @@ class PaymentSessionReactLauncher(
     }
   }
 
+  /**
+   * Headless flows (wallet buttons, saved methods) have no ReactFragment/ReactActivity to resume
+   * the SDK host, and React Native runs JS timers (so every `fetch`) and sets `currentActivity`
+   * only for a resumed host. The headless task itself ends immediately, so resume it here.
+   */
+  private fun resumeHost() {
+    val activity = activityProvider()?.takeUnless { it.isFinishing || it.isDestroyed } ?: return
+    RedirectBridge.install(activity)
+    val backHandler = activity as? DefaultHardwareBackBtnHandler
+    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      ReactNativeController.getReactHost().onHostResume(activity, backHandler)
+    } else {
+      val manager = ReactNativeController.getReactNativeHost().reactInstanceManager
+      if (backHandler != null) manager.onHostResume(activity, backHandler) else manager.onHostResume(activity)
+    }
+  }
+
+  /**
+   * Resumes the SDK host with the current Activity. Headless flows started from a session created
+   * before the host Activity was recreated would otherwise launch from the destroyed one.
+   */
+  fun resumeHostForCurrentActivity() {
+    UiThreadUtil.runOnUiThread { resumeHost() }
+  }
+
+  /** Like [resumeHostForCurrentActivity], then runs [action] after the resume, on the UI thread. */
+  fun runWithHostResumed(action: () -> Unit) {
+    UiThreadUtil.runOnUiThread {
+      resumeHost()
+      action()
+    }
+  }
+
+  /**
+   * Whether a payment sheet is currently attached and visible on [activity]. Closed sheets are
+   * hidden, not removed, so they do not count.
+   */
+  fun isSheetVisible(activity: Activity): Boolean {
+    val fragmentActivity = activity as? FragmentActivity ?: return false
+    return fragmentActivity.supportFragmentManager.fragments.any {
+      it.tag == "paymentSheet" && it.isAdded && !it.isHidden
+    }
+  }
+
   /**
    * Presents the payment sheet using a fully prepared launch [bundle].
    *
    * The bundle is expected to contain a `props` bundle with `configuration`, `sdkParams`, etc.
    */
-  fun presentSheet(bundle: Bundle): Boolean {
+  fun presentSheet(bundle: Bundle, host: Activity = activity): Boolean {
     applyFonts(bundle)
-    return presentSheetInternal(bottomInsetToDIPFromPixel(bundle))
+    return presentSheetInternal(bottomInsetToDIPFromPixel(bundle), host)
   }
 
-  private fun presentSheetInternal(bundle: Bundle): Boolean {
-    if (activity is DefaultHardwareBackBtnHandler && activity is FragmentActivity) {
-      val fragmentActivity = activity as FragmentActivity
+  private fun presentSheetInternal(bundle: Bundle, host: Activity): Boolean {
+    if (host is DefaultHardwareBackBtnHandler && host is FragmentActivity) {
+      val fragmentActivity = host as FragmentActivity
       val fragmentManager = fragmentActivity.supportFragmentManager
       try {
         fragmentManager.findFragmentByTag("paymentSheet")?.let { existingFragment ->
@@ -192,9 +256,9 @@ class PaymentSessionReactLauncher(
 
       return true
     } else {
-      activity.startActivity(
+      host.startActivity(
         Intent(
-          activity.applicationContext,
+          host.applicationContext,
           HyperActivity::class.java
         ).apply {
           putExtra("flow", 1)
@@ -253,4 +317,35 @@ class PaymentSessionReactLauncher(
     }
     return bundle
   }
+
+  /**
+   * The in-app browser returns through RedirectActivity, which posts a [RedirectEvent]. Only
+   * HyperFragment and HyperActivity turn that into the browser's own dismiss event, and the
+   * wallet-button and saved-methods flows have neither on screen, so the tab stayed open and the
+   * confirm never resumed. Registered once per process; a duplicate post while a sheet is up is
+   * ignored, because the browser drops it when no open call is pending.
+   */
+  private object RedirectBridge {
+    /* Weak: this object outlives the session, and the dismiss intent must be started from the
+       Activity, as HyperFragment does, so it lands in the task holding the browser tab. */
+    private var activityRef: WeakReference<Activity>? = null
+
+    fun install(activity: Activity) {
+      activityRef = WeakReference(activity)
+      val eventBus = EventBus.getDefault()
+      if (!eventBus.isRegistered(this)) {
+        eventBus.register(this)
+      }
+    }
+
+    @Subscribe
+    fun onEvent(event: RedirectEvent) {
+      Log.d("HyperswitchRedirect", "RedirectBridge got redirect: ${event.message}")
+      EventBus.getDefault().post(
+        ChromeTabsDismissedEvent(event.message, event.resultType, event.isError)
+      )
+      val activity = activityRef?.get() ?: return
+      activity.startActivity(ChromeTabsManagerActivity.createDismissIntent(activity))
+    }
+  }
 }

package/android/src/main/java/io/hyperswitch/paymentsheet/PaymentResult.kt

@@ -42,9 +42,15 @@ sealed class PaymentResult : Parcelable {
       }
 
       is Failed -> {
+        val text = throwable.message?.takeIf { it.isNotEmpty() }
+        val code = throwable.cause?.message?.takeIf { it.isNotEmpty() }
         JSONObject()
           .put("status", "failed")
-          .put("error", throwable.message)
+          // `error` is kept for existing consumers; `message`/`code` match StandardResult
+          // and what the JS layer reads.
+          .put("error", text)
+          .put("message", text)
+          .put("code", code)
           .put("type", throwable::class.java.name)
           .toString()
       }

package/android/src/main/java/io/hyperswitch/react/HyperModule.kt

@@ -23,6 +23,7 @@ import com.facebook.react.uimanager.UIManagerModule
 import com.facebook.react.uimanager.common.UIManagerType
 import com.hyperswitchsdkreactnative.BuildConfig
 import com.hyperswitchsdkreactnative.NativeHyperModuleSpec
+import com.hyperswitchsdkreactnative.modules.NativeLog
 import io.hyperswitch.payments.GooglePayCallbackManager
 import io.hyperswitch.paymentsession.LaunchOptions
 import io.hyperswitch.paymentsession.PaymentSheetCallbackManager
@@ -67,6 +68,7 @@ class HyperModule internal constructor(private val rct: ReactApplicationContext)
   }
 
   init {
+    NativeLog.attach(rct)
     activeInstance = this
   }
 
@@ -143,11 +145,17 @@ class HyperModule internal constructor(private val rct: ReactApplicationContext)
   // Method to launch Google Pay payment
   @ReactMethod
   override fun launchGPay(googlePayRequest: String, callBack: Callback) {
+    val activityName = currentActivity?.javaClass?.simpleName
+    NativeLog.debug("wallet_launch_called", mapOf("wallet" to "google_pay", "activity" to activityName))
+    if (currentActivity == null) {
+      NativeLog.warning("wallet_launch_without_activity", mapOf("wallet" to "google_pay"))
+    }
     currentActivity?.let {
       GooglePayCallbackManager.setCallback(
         it,
         googlePayRequest,
         fun(data: Map<String, Any?>) {
+          NativeLog.debug("wallet_result_delivered", mapOf("wallet" to "google_pay", "status" to data["status"]?.toString()))
           callBack.invoke(
             Arguments.fromBundle(
               LaunchOptions(
@@ -162,6 +170,7 @@ class HyperModule internal constructor(private val rct: ReactApplicationContext)
         reactApplicationContext,
         googlePayRequest,
         fun(data: Map<String, Any?>) {
+          NativeLog.debug("wallet_result_delivered", mapOf("wallet" to "google_pay", "status" to data["status"]?.toString()))
           callBack.invoke(
             Arguments.fromBundle(
               LaunchOptions(
@@ -199,6 +208,10 @@ class HyperModule internal constructor(private val rct: ReactApplicationContext)
   @ReactMethod
   override fun exitPaymentsheet(rootTag: Double, paymentResult: String, reset: Boolean) {
     val isFragment = PaymentSheetCallbackManager.executeCallback(paymentResult)
+    NativeLog.debug(
+      "exit_payment_sheet_resolved",
+      mapOf("isFragment" to isFragment, "activityPresent" to (currentActivity != null))
+    )
     (currentActivity as? FragmentActivity)?.let {
       if (isFragment) it.supportFragmentManager.findFragmentByTag("paymentSheet")
         ?.let { fragment ->

package/android/src/main/java/io/hyperswitch/view/PaymentWidgetView.kt

@@ -20,6 +20,7 @@ import io.hyperswitch.paymentsession.LaunchOptions
 import io.hyperswitch.react.HyperFragment
 import io.hyperswitch.react.HyperFragmentManager
 import io.hyperswitch.react.ReactNativeController
+import io.hyperswitch.utils.StandardResult
 import kotlin.collections.orEmpty
 
 import kotlin.math.abs
@@ -186,13 +187,23 @@ open class PaymentWidgetView : FrameLayout {
   }
 
   fun confirmPayment(callback: (String) -> Unit) {
-    this.fragment?.confirmPayment(callback)
+    val fragment = this.fragment
+    if (fragment != null) {
+      fragment.confirmPayment(callback)
+    } else {
+      /* Without this a detached fragment dropped the callback and the confirm promise hung. */
+      callback(fragmentNotAttachedFailure())
+    }
   }
 
-
   fun updatePaymentIntentInit(callback: () -> Unit) {
     if (isEligibleForUpdateIntent()) {
-      this.fragment?.updatePaymentIntentInit(callback)
+      val fragment = this.fragment
+      if (fragment != null) {
+        fragment.updatePaymentIntentInit(callback)
+      } else {
+        callback()
+      }
     } else {
       callback()
     }
@@ -245,9 +256,21 @@ open class PaymentWidgetView : FrameLayout {
     billing: String?,
     callback: (String) -> Unit
   ) {
-    this.fragment?.confirmCvcPayment(sdkAuthorization, paymentToken, billing, callback)
+    val fragment = this.fragment
+    if (fragment != null) {
+      fragment.confirmCvcPayment(sdkAuthorization, paymentToken, billing, callback)
+    } else {
+      callback(fragmentNotAttachedFailure())
+    }
   }
 
+  /* Mirrors StandardResult.Failed so the JS layer maps it to a failed result. */
+  private fun fragmentNotAttachedFailure() = StandardResult.Failed(
+    code = "FRAGMENT_NOT_ATTACHED",
+    message = "The payment widget's fragment is not attached",
+    error = Throwable("FRAGMENT_NOT_ATTACHED")
+  ).toJSONString()
+
   fun setSdkAuthorization(sdkAuthorization: String) {
     this.sdkAuthorization = sdkAuthorization
     if (isAttachedToWindow && !isSdkAuthorizationEmpty()) {