react-native-hyperswitch-dev-sdk 0.4.1

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

@@ -0,0 +1,429 @@
+package io.hyperswitch.react
+
+import android.annotation.SuppressLint
+import android.os.Bundle
+import android.util.Log
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import com.facebook.react.ReactFragment
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactRootView
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.views.scroll.ReactHorizontalScrollView
+import com.facebook.react.views.scroll.ReactScrollView
+import com.proyecto26.inappbrowser.ChromeTabsDismissedEvent
+import com.proyecto26.inappbrowser.ChromeTabsManagerActivity
+import io.hyperswitch.PaymentEvent
+import io.hyperswitch.PaymentEventListener
+import io.hyperswitch.model.ElementUpdateIntentResult
+import io.hyperswitch.paymentsession.ExitHeadlessCallBackManager
+import io.hyperswitch.paymentsheet.PaymentResult
+import io.hyperswitch.redirect.RedirectEvent
+import io.hyperswitch.utils.ConversionUtils
+import io.hyperswitch.utils.StandardResult
+import org.greenrobot.eventbus.EventBus
+import org.greenrobot.eventbus.Subscribe
+import org.json.JSONObject
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.collections.set
+import kotlin.text.ifEmpty
+
+
+enum class EventName {
+  CONFIRM_PAYMENT_ACTION,
+  CONFIRM_CVC_PAYMENT
+}
+
+enum class CallbackType {
+  PAYMENT_RESULT,
+  CONFIRM_ACTION,
+  CONFIRM_CVC_ACTION,
+  UPDATE_INTENT_INIT,
+  UPDATE_INTENT_COMPLETE,
+  PAYMENT_CONFIRM_BUTTON_CLICK
+}
+
+
+sealed class HyperCallback {
+  class Payment(val fn: ((String) -> Unit)) : HyperCallback()
+  class UpdateIntentInit(val fn: (() -> Unit)?) : HyperCallback()
+  class UpdateIntentComplete(val fn: ((String) -> Unit)) : HyperCallback()
+  class ConfirmButtonTriggered(
+    val callback: (data: String, onPaymentResultCallback: (Boolean) -> Unit) -> Unit,
+  ) : HyperCallback()
+}
+
+class HyperFragment : ReactFragment() {
+
+  /**
+   * Instance-level registry. No companion object, no static map.
+   * Keyed by [CallbackType] so each slot is independently replaceable.
+   */
+  private val callbacks = ConcurrentHashMap<CallbackType, HyperCallback>()
+
+  /** Per-widget listener set by HyperswitchBoundElement.subscribe(). Null for PaymentSheet. */
+  private var paymentEventListener: PaymentEventListener? = null
+
+  private var onExit: (() -> Unit)? = null
+
+  fun setOnExit(callback: () -> Unit) {
+    onExit = callback
+  }
+
+  fun setOnPaymentResult(callback: ((String) -> Unit)) {
+    callbacks[CallbackType.PAYMENT_RESULT] = HyperCallback.Payment(callback)
+  }
+
+  fun setOnPaymentConfirmButtonClick(callback: (data: String, onPaymentResultCallback: ((Boolean) -> Unit)) -> Unit) {
+    callbacks[CallbackType.PAYMENT_CONFIRM_BUTTON_CLICK] = HyperCallback.ConfirmButtonTriggered(
+      callback
+    )
+  }
+
+  fun setOnEventCallback(listener: PaymentEventListener) {
+    this.paymentEventListener = listener
+  }
+
+  fun updatePaymentIntentInit(callback: (() -> Unit)?) {
+    val rootTag = reactDelegate.reactRootView?.rootViewTag ?: -1
+    if (rootTag == -1) {
+      callback?.invoke()
+      return
+    }
+    if (callbacks[CallbackType.UPDATE_INTENT_INIT] != null) {
+      callback?.invoke()
+      return
+    }
+    callbacks[CallbackType.UPDATE_INTENT_INIT] = HyperCallback.UpdateIntentInit(callback)
+    reactNativeHost.reactInstanceManager.currentReactContext
+      ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      ?.emit("updateIntentInit", Arguments.createMap().apply {
+        putInt("rootTag", rootTag)
+      })
+  }
+
+  fun updatePaymentIntentComplete(
+    sdkAuthorization: String,
+    callback: ((String) -> Unit)
+  ) {
+    val rootTag = reactDelegate.reactRootView?.rootViewTag ?: -1
+    if (rootTag == -1) {
+      callback.invoke(
+        ElementUpdateIntentResult.Failure(
+          Throwable("React context not ready").apply {
+            initCause(Throwable("REACT_CONTEXT_NOT_READY"))
+          }
+        ).toString()
+      )
+      return
+    }
+    if (callbacks[CallbackType.UPDATE_INTENT_COMPLETE] != null) {
+      callback.invoke(
+        ElementUpdateIntentResult.Failure(
+          Throwable("Update intent complete already in progress").apply {
+            initCause(Throwable("ALREADY_IN_PROGRESS"))
+          }
+        ).toString()
+      )
+      return
+    }
+    callbacks[CallbackType.UPDATE_INTENT_COMPLETE] =
+      HyperCallback.UpdateIntentComplete(callback)
+    reactNativeHost.reactInstanceManager.currentReactContext
+      ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      ?.emit("updateIntentComplete", Arguments.createMap().apply {
+        putString("sdkAuthorization", sdkAuthorization)
+        putInt("rootTag", rootTag)
+      })
+  }
+
+  fun confirmPayment(callback: ((String) -> Unit)) {
+    if (callbacks.containsKey(CallbackType.CONFIRM_ACTION)) {
+      callback.invoke(
+        StandardResult.Failed(error = Throwable("Payment already in progress")).toJSONString()
+      )
+      return
+    }
+    val rootTag = reactDelegate.reactRootView?.rootViewTag ?: -1
+    if (rootTag == -1) {
+      callback.invoke(
+        StandardResult.Failed(error = Throwable("React Context not ready")).toJSONString()
+      )
+      return
+    }
+    if (callbacks[CallbackType.UPDATE_INTENT_COMPLETE] != null) {
+      callback.invoke(
+        StandardResult.Failed(error = Throwable("Payment Intent update is in progress"))
+          .toJSONString()
+      )
+      return
+    }
+    callbacks[CallbackType.CONFIRM_ACTION] = HyperCallback.Payment(callback)
+    reactNativeHost.reactInstanceManager.currentReactContext
+      ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      ?.emit("triggerWidgetAction", Arguments.createMap().apply {
+        putString("actionType", EventName.CONFIRM_PAYMENT_ACTION.name)
+        putInt("rootTag", rootTag)
+      })
+  }
+
+  /**
+   * Called directly on this instance by the native module after finding the
+   * fragment via [UIManagerModule] + [androidx.fragment.app.FragmentManager.findFragment].
+   *
+   * PAYMENT_RESULT  → fires CONFIRM_ACTION if present, otherwise PAYMENT_RESULT.
+   * CONFIRM_ACTION  → fires and removes CONFIRM_ACTION (one-shot resolve).
+   */
+  fun notifyResult(type: CallbackType, result: String) {
+    try {
+      when (type) {
+        CallbackType.PAYMENT_RESULT -> {
+          val confirmCallback =
+            callbacks.remove(CallbackType.CONFIRM_ACTION) as? HyperCallback.Payment
+          val confirmCvcCallback =
+            callbacks.remove(CallbackType.CONFIRM_CVC_ACTION) as? HyperCallback.Payment
+
+          when {
+            confirmCallback != null -> {
+//                            val parsed = parseResult(result)
+              confirmCallback.fn.invoke(result)
+              onExit?.invoke()
+            }
+
+            confirmCvcCallback != null -> {
+//                            val parsed = parseResult(result)
+              confirmCvcCallback.fn.invoke(result)
+              onExit?.invoke()
+            }
+
+            else -> {
+//                            val parsed = parseResult(result)
+              (callbacks.remove(CallbackType.PAYMENT_RESULT) as? HyperCallback.Payment)
+                ?.fn?.invoke(result)
+              onExit?.invoke()
+            }
+          }
+        }
+
+        CallbackType.UPDATE_INTENT_INIT ->
+          (callbacks.remove(CallbackType.UPDATE_INTENT_INIT) as? HyperCallback.UpdateIntentInit)?.fn?.invoke()
+
+        CallbackType.UPDATE_INTENT_COMPLETE ->
+          (callbacks.remove(CallbackType.UPDATE_INTENT_COMPLETE) as? HyperCallback.UpdateIntentComplete)?.fn?.invoke(
+            result
+          )
+//
+        CallbackType.CONFIRM_ACTION -> {
+//                    val parsed = parseResult(result)
+          (callbacks.remove(CallbackType.CONFIRM_ACTION) as? HyperCallback.Payment)?.fn?.invoke(
+            result
+          )
+        }
+
+        CallbackType.CONFIRM_CVC_ACTION -> {
+//                    val parsed = parseResult(result)
+          (callbacks.remove(CallbackType.CONFIRM_CVC_ACTION) as? HyperCallback.Payment)?.fn?.invoke(
+            result
+          )
+        }
+
+        else -> Log.i("HyperFragment", "notifyResult: unhandled type $type")
+      }
+    } catch (e: Exception) {
+      Log.e("HyperFragment", "Error in notifyResult", e)
+    }
+  }
+
+  fun notifyConfirmButtonClicked(payload: String, callback: (Boolean) -> Unit) {
+    val confirmTriggeredCallback =
+      callbacks[CallbackType.PAYMENT_CONFIRM_BUTTON_CLICK] as HyperCallback.ConfirmButtonTriggered?
+    if (confirmTriggeredCallback == null) {
+      callback.invoke(true)
+    } else {
+      confirmTriggeredCallback.callback.invoke(payload, callback)
+    }
+    callbacks.remove(CallbackType.CONFIRM_ACTION)
+  }
+
+  /**
+   * Called directly on this instance for streaming widget lifecycle events.
+   */
+  fun notifyEvent(eventType: String, result: ReadableMap) {
+    try {
+      val payload = ConversionUtils.readableMapToMap(result)
+      val listener = paymentEventListener
+      if (listener != null) {
+        val event = PaymentEvent(type = eventType, payload = payload)
+        listener.onPaymentEvent(event)
+      } else {
+        HyperEventEmitter.emitPaymentEvent(eventType, payload)
+      }
+    } catch (e: Exception) {
+      Log.e("HyperFragment", "Error in notifyEvent", e)
+    }
+  }
+
+
+  fun confirmCvcPayment(
+    sdkAuthorization: String,
+    paymentToken: String,
+    billing: String?,
+    callback: ((String) -> Unit)
+  ) {
+    val rootTag = reactDelegate.reactRootView?.rootViewTag ?: -1
+    if (rootTag == -1) {
+      val paymentResult = StandardResult.Failed(error = Throwable("cannot find the view"))
+      callback.invoke(paymentResult.toJSONString())
+      return
+    }
+
+    val exitCallback = { data: PaymentResult ->
+      callback.invoke(data.toJSONString())
+    }
+    val registered = ExitHeadlessCallBackManager.tryRegisterCallback(rootTag, exitCallback)
+    if (!registered) {
+      val paymentResult =
+        StandardResult.Failed(error = Throwable("CVC payment already in progress for this widget").apply {
+          initCause(Throwable("ALREADY_IN_PROGRESS"))
+        })
+      callback.invoke(paymentResult.toJSONString())
+      return
+    }
+
+    val map = Arguments.createMap()
+    map.putString("actionType", EventName.CONFIRM_CVC_PAYMENT.name)
+    map.putInt("rootTag", rootTag)
+    map.putString("sdkAuthorization", sdkAuthorization)
+    map.putString("paymentToken", paymentToken)
+    billing?.let { map.putString("billing", it) }
+    reactNativeHost.reactInstanceManager.currentReactContext
+      ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      ?.emit("triggerWidgetAction", map)
+  }
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    registerEventBus()
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+    val reactRootView = view as? ReactRootView ?: return
+    var scrollFixScheduled = false
+    reactRootView.setOnHierarchyChangeListener(object : ViewGroup.OnHierarchyChangeListener {
+      override fun onChildViewAdded(parent: View?, child: View?) {
+        if (!scrollFixScheduled) {
+          scrollFixScheduled = true
+          view.post {
+            scrollFixScheduled = false
+            fixScrollInterception(reactRootView)
+          }
+        }
+      }
+
+      override fun onChildViewRemoved(parent: View?, child: View?) {}
+    })
+  }
+
+  override fun onDestroyView() {
+    try {
+      super.onDestroyView()
+      callbacks.clear()
+      onExit = null
+      paymentEventListener = null
+    } catch (_: Exception) {
+    }
+  }
+
+  override fun onDestroy() {
+    try {
+      super.onDestroy()
+      unRegisterEventBus()
+      callbacks.clear()
+      onExit = null
+      paymentEventListener = null
+    } catch (_: Exception) {
+    }
+  }
+
+  override fun onPause() {
+    try {
+      super.onPause()
+    } catch (_: Exception) {
+    }
+  }
+
+  // ── Scroll fix ────────────────────────────────────────────────────────────
+
+  @SuppressLint("ClickableViewAccessibility")
+  private fun fixScrollInterception(root: ViewGroup) {
+    root.isNestedScrollingEnabled = true
+    findReactScrollViews(root).forEach { scrollView ->
+      scrollView.isNestedScrollingEnabled = true
+      scrollView.setOnTouchListener { v, event ->
+        when (event.action) {
+          MotionEvent.ACTION_DOWN,
+          MotionEvent.ACTION_MOVE -> v.parent?.requestDisallowInterceptTouchEvent(true)
+
+          MotionEvent.ACTION_UP,
+          MotionEvent.ACTION_CANCEL -> v.parent?.requestDisallowInterceptTouchEvent(false)
+        }
+        false
+      }
+    }
+  }
+
+  private fun findReactScrollViews(root: ViewGroup): List<ViewGroup> {
+    val result = mutableListOf<ViewGroup>()
+    for (i in 0 until root.childCount) {
+      val child = root.getChildAt(i)
+      if (child is ReactScrollView || child is ReactHorizontalScrollView) result.add(child as ViewGroup)
+      if (child is ViewGroup) result.addAll(findReactScrollViews(child))
+    }
+    return result
+  }
+
+  // ── EventBus ──────────────────────────────────────────────────────────────
+
+  private fun registerEventBus() {
+    if (!EventBus.getDefault().isRegistered(this)) EventBus.getDefault().register(this)
+  }
+
+  private fun unRegisterEventBus() {
+    if (EventBus.getDefault().isRegistered(this)) EventBus.getDefault().unregister(this)
+  }
+
+
+  @Subscribe
+  fun onEvent(event: RedirectEvent) {
+    unRegisterEventBus()
+    EventBus.getDefault()
+      .post(ChromeTabsDismissedEvent(event.message, event.resultType, event.isError))
+    startActivity(ChromeTabsManagerActivity.createDismissIntent(requireContext()))
+  }
+
+  override fun getReactNativeHost(): ReactNativeHost = ReactNativeController.getReactNativeHost()
+  override fun getReactHost(): ReactHost = ReactNativeController.getReactHost()
+
+  class Builder {
+    private var mComponentName: String? = null
+    private var mLaunchOptions: Bundle? = null
+    private var mFabricEnabled: Boolean = false
+
+    fun setComponentName(componentName: String?) = apply { mComponentName = componentName }
+    fun setLaunchOptions(launchOptions: Bundle?) = apply { mLaunchOptions = launchOptions }
+    fun setFabricEnabled(fabricEnabled: Boolean) = apply { mFabricEnabled = fabricEnabled }
+
+    fun build(): HyperFragment = HyperFragment().also { fragment ->
+      fragment.arguments = Bundle().apply {
+        putString(ARG_COMPONENT_NAME, mComponentName)
+        putBundle(ARG_LAUNCH_OPTIONS, mLaunchOptions)
+        putBoolean(ARG_FABRIC_ENABLED, mFabricEnabled)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,155 @@
+package io.hyperswitch.react
+
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import android.widget.FrameLayout
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
+
+object HyperFragmentManager {
+
+    // Thread-safe collections; all mutations happen on the main thread via mainHandler,
+    // but public query methods (isActive, isPending, getFragment) can be called from any thread.
+    private val fragmentRegistry = ConcurrentHashMap<String, Fragment>()
+    private val pendingTags = ConcurrentHashMap.newKeySet<String>()
+    private val debounceHandlers = ConcurrentHashMap<String, Runnable>()
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    // Monotonically increasing counter for stable, collision-free view IDs.
+    private val idCounter = AtomicInteger(0x00F00001)
+
+    private const val DEBOUNCE_MS = 300L
+
+    /**
+     * Request to add/replace a fragment. Debounced per tag —
+     * rapid successive calls for the same tag collapse into one.
+     */
+    fun addOrReplace(
+        activity: FragmentActivity,
+        container: FrameLayout,
+        fragment: Fragment,
+        tag: String,
+        addToBackStack: Boolean = true,
+        debounce: Boolean = true
+    ) {
+        if (debounce) {
+            scheduleAddOrReplace(activity, container, fragment, tag, addToBackStack)
+        } else {
+            commitAddOrReplace(activity, container, fragment, tag, addToBackStack)
+        }
+    }
+
+    private fun scheduleAddOrReplace(
+        activity: FragmentActivity,
+        container: FrameLayout,
+        fragment: Fragment,
+        tag: String,
+        addToBackStack: Boolean
+    ) {
+        // Cancel any previously scheduled runnable for this tag
+        debounceHandlers[tag]?.let { mainHandler.removeCallbacks(it) }
+
+        // Mark as pending so callers can check
+        pendingTags.add(tag)
+
+        val runnable = Runnable {
+            pendingTags.remove(tag)
+            debounceHandlers.remove(tag)
+            if (!activity.isFinishing && !activity.isDestroyed) {
+                commitAddOrReplace(activity, container, fragment, tag, addToBackStack)
+            }
+        }
+
+        debounceHandlers[tag] = runnable
+        mainHandler.postDelayed(runnable, DEBOUNCE_MS)
+    }
+
+    private fun commitAddOrReplace(
+        activity: FragmentActivity,
+        container: FrameLayout,
+        fragment: Fragment,
+        tag: String,
+        addToBackStack: Boolean
+    ) {
+        try {
+            if (activity.isFinishing || activity.isDestroyed) return
+            if (container.parent == null || !container.isAttachedToWindow) return
+            if (fragment.isAdded) return
+
+            val fm: FragmentManager = activity.supportFragmentManager
+
+        // Remove existing fragment with the same tag if present, including its back-stack entry
+        // so that onDestroy is called and the React tree is fully released.
+        val existing = fm.findFragmentByTag(tag)
+        if (existing != null) {
+            fm.popBackStackImmediate(tag, FragmentManager.POP_BACK_STACK_INCLUSIVE)
+            if (existing.isAdded) {
+                fm.beginTransaction().remove(existing).commitNowAllowingStateLoss()
+            }
+            fragmentRegistry.remove(tag)
+        }
+
+        if (container.id == View.NO_ID) {
+            container.id = generateStableId()
+        }
+
+        val tx = fm.beginTransaction().add(container.id, fragment, tag)
+        if (addToBackStack) tx.addToBackStack(tag)
+        tx.commitNowAllowingStateLoss()
+
+            fragmentRegistry[tag] = fragment
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    /**
+     * Cancel any pending debounced creation for this tag.
+     */
+    fun cancelPending(tag: String) {
+        debounceHandlers[tag]?.let { mainHandler.removeCallbacks(it) }
+        debounceHandlers.remove(tag)
+        pendingTags.remove(tag)
+    }
+
+    fun remove(activity: FragmentActivity, tag: String) {
+        cancelPending(tag)
+        val fm = activity.supportFragmentManager
+        val fragment = fm.findFragmentByTag(tag)
+        if (fragment != null) {
+            // Pop from back stack if the fragment was added with addToBackStack=true.
+            // This is a no-op when the fragment was added without a back-stack entry.
+            fm.popBackStackImmediate(tag, FragmentManager.POP_BACK_STACK_INCLUSIVE)
+            // If still attached (was never on the back stack), remove it directly.
+            if (fragment.isAdded) {
+                fm.beginTransaction().remove(fragment).commitNowAllowingStateLoss()
+            }
+        }
+        fragmentRegistry.remove(tag)
+    }
+
+    fun removeAll(activity: FragmentActivity) {
+        debounceHandlers.keys.toList().forEach { cancelPending(it) }
+        val fm = activity.supportFragmentManager
+        fragmentRegistry.keys.toList().forEach { tag ->
+            if (fm.findFragmentByTag(tag) != null) {
+                fm.popBackStackImmediate(tag, FragmentManager.POP_BACK_STACK_INCLUSIVE)
+            }
+        }
+        fragmentRegistry.clear()
+    }
+
+    /** True if a debounced commit is scheduled but not yet executed */
+    fun isPending(tag: String): Boolean = pendingTags.contains(tag)
+
+    fun isActive(tag: String): Boolean = fragmentRegistry.containsKey(tag)
+
+    fun getFragment(tag: String): Fragment? = fragmentRegistry[tag]
+
+    /** Generates a unique, valid view ID using an atomic counter. */
+    internal fun generateStableId(): Int = idCounter.getAndIncrement()
+}

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

@@ -0,0 +1,43 @@
+package io.hyperswitch.react
+
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.hyperswitchsdkreactnative.NativeHyperHeadlessSpec
+import io.hyperswitch.paymentsession.GetPaymentSessionCallBackManager
+import io.hyperswitch.paymentsession.PaymentSessionHandlerImpl
+
+class HyperHeadlessModule internal constructor(private val rct: ReactApplicationContext) :
+    NativeHyperHeadlessSpec(rct) {
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    override  fun getPaymentSession(
+        rootTag: Double,
+        getPaymentMethodData: ReadableMap,
+        getPaymentMethodData2: ReadableMap,
+        getPaymentMethodDataArray: ReadableArray,
+        callback: Callback
+    ) {
+        val handler = PaymentSessionHandlerImpl(
+            sdkAuthorization = GetPaymentSessionCallBackManager.getSdkAuthorization(),
+            defaultMethodData = getPaymentMethodData,
+            lastUsedMethodData = getPaymentMethodData2,
+            allMethodsData = getPaymentMethodDataArray,
+            jsCallback = callback,
+        )
+      GetPaymentSessionCallBackManager.executeCallback(handler)
+    }
+
+    @ReactMethod
+    override fun exitHeadless(rootTag: Double, status: String) {
+//        ExitHeadlessCallBackManager.executeCallback(rootTag, status)
+    }
+
+  companion object {
+    const val NAME = "HyperHeadless"
+  }
+}