react-native-hyperswitch-dev-sdk 0.4.1

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

@@ -0,0 +1,226 @@
+package io.hyperswitch.paymentsession
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import android.util.Log
+import androidx.activity.addCallback
+import androidx.fragment.app.FragmentActivity
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactInstanceEventListener
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.common.assets.ReactFontManager
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+import com.facebook.react.jstasks.HeadlessJsTaskContext
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
+import com.facebook.react.uimanager.PixelUtil
+import com.hyperswitchsdkreactnative.BuildConfig
+import io.hyperswitch.react.HyperActivity
+import io.hyperswitch.react.HyperEventEmitter
+import io.hyperswitch.react.HyperFragment
+import io.hyperswitch.react.ReactNativeController
+
+/**
+ * React Native backed engine for presenting the payment sheet and running headless tasks.
+ *
+ * This class is intentionally independent of [hyperswitch-sdk-android-api]; callers are expected
+ * to pass all configuration data as plain [Bundle]s or [Map]s.
+ */
+class PaymentSessionReactLauncher(
+  private val activity: Activity,
+) {
+
+  private var reactHost: ReactHost? = null
+  private var reactNativeHost: ReactNativeHost? = null
+  private var reactContext: ReactContext? = null
+  private var headlessTaskId: Int? = null
+
+  @SuppressLint("VisibleForTests")
+  fun initializeReactNativeInstance() {
+    reactContext = try {
+      // Get ReactNativeHost from ReactNativeController singleton instead of casting Application to ReactApplication
+      // This allows merchants to use their own Application class without extending MainApplication
+      if (!ReactNativeController.getIsInitialized()) {
+        ReactNativeController.initialize(activity.application)
+      }
+      reactNativeHost = ReactNativeController.getReactNativeHost()
+      reactHost = ReactNativeController.getReactHost()
+
+      if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+        val reactHost = checkNotNull(reactHost) { "ReactHost is not initialized in New Architecture" }
+        reactHost.currentReactContext
+      } else {
+        val reactInstanceManager = reactNativeHost?.reactInstanceManager
+        reactInstanceManager?.currentReactContext
+      }
+    } catch (ex: IllegalStateException) {
+      throw IllegalStateException(
+        "HyperSDK not initialized. Please call HyperSDK.initialize() in your Application.onCreate()",
+        ex
+      )
+    } catch (ex: RuntimeException) {
+      throw IllegalStateException(
+        "Failed to initialize React Native instance. " + "Please check your AndroidManifest.xml and React Native configuration.",
+        ex
+      )
+    }
+  }
+
+  /**
+   * 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) {
+    activity.runOnUiThread {
+      val context = reactContext
+      if (context == null) {
+        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+          val reactHost = checkNotNull(reactHost)
+          reactHost.addReactInstanceEventListener(
+            object : ReactInstanceEventListener {
+              override fun onReactContextInitialized(context: ReactContext) {
+                startHeadlessTask(context, bundle)
+                reactHost.removeReactInstanceEventListener(this)
+              }
+            }
+          )
+          reactHost.start()
+        } else {
+          val reactInstanceManager = reactNativeHost?.reactInstanceManager
+          reactInstanceManager?.addReactInstanceEventListener(
+            object : ReactInstanceEventListener {
+              override fun onReactContextInitialized(context: ReactContext) {
+                startHeadlessTask(context, bundle)
+                reactInstanceManager.removeReactInstanceEventListener(this)
+              }
+            }
+          )
+          reactInstanceManager?.createReactContextInBackground()
+        }
+      } else {
+        startHeadlessTask(context, bundle)
+      }
+    }
+  }
+
+  private fun startHeadlessTask(reactContext: ReactContext, bundle: Bundle) {
+    val taskConfig = HeadlessJsTaskConfig(
+      "HyperHeadless", Arguments.fromBundle(bundle), 5000, true, null
+    )
+
+    val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext)
+    UiThreadUtil.runOnUiThread {
+      headlessTaskId?.let {
+        headlessJsTaskContext.finishTask(it)
+      }
+      headlessTaskId = headlessJsTaskContext.startTask(taskConfig)
+    }
+  }
+
+  /**
+   * 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 {
+    applyFonts(bundle)
+    return presentSheetInternal(bottomInsetToDIPFromPixel(bundle))
+  }
+
+  private fun presentSheetInternal(bundle: Bundle): Boolean {
+    if (activity is DefaultHardwareBackBtnHandler && activity is FragmentActivity) {
+      val fragmentActivity = activity as FragmentActivity
+      val fragmentManager = fragmentActivity.supportFragmentManager
+      try {
+        fragmentManager.findFragmentByTag("paymentSheet")?.let { existingFragment ->
+          fragmentManager.beginTransaction()
+            .remove(existingFragment)
+            .commitNowAllowingStateLoss()
+        }
+      }catch(e:Exception){
+        Log.i("Manideep", e.message.toString())
+      }
+
+      val newReactNativeFragmentSheet =
+        HyperFragment.Builder()
+          .setComponentName("hyperSwitch")
+          .setLaunchOptions(bundle)
+          .setFabricEnabled(BuildConfig.IS_NEW_ARCHITECTURE_ENABLED)
+          .build()
+
+      fragmentActivity.onBackPressedDispatcher.addCallback {
+        newReactNativeFragmentSheet.onBackPressed()
+      }
+
+      fragmentManager.beginTransaction()
+        .add(android.R.id.content, newReactNativeFragmentSheet, "paymentSheet")
+        .commitAllowingStateLoss()
+
+      return true
+    } else {
+      activity.startActivity(
+        Intent(
+          activity.applicationContext,
+          HyperActivity::class.java
+        ).apply {
+          putExtra("flow", 1)
+          putExtra("configuration", bundle)
+        })
+      return false
+    }
+  }
+
+  /**
+   * Loads any custom fonts declared in the configuration bundle and rewrites the font entries
+   * so React Native can resolve them by family name.
+   */
+  private fun applyFonts(bundle: Bundle) {
+    val configuration = bundle.getBundle("props")?.getBundle("configuration") ?: return
+    val appearance = configuration.getBundle("appearance") ?: return
+
+    appearance.getBundle("font")?.let { font ->
+      loadFontAndUpdateBundle(font)
+    }
+
+    appearance.getBundle("primaryButton")?.getBundle("typography")?.let { typography ->
+      loadFontAndUpdateBundle(typography)
+    }
+  }
+
+  private fun loadFontAndUpdateBundle(fontBundle: Bundle) {
+    if (!fontBundle.containsKey("fontResId")) return
+    val fontResId = fontBundle.getInt("fontResId", 0)
+    if (fontResId == 0) return
+
+    try {
+      val family = activity.resources.getResourceName(fontResId).split("/")[1]
+      ReactFontManager.getInstance().addCustomFont(activity, family, fontResId)
+      fontBundle.remove("fontResId")
+      fontBundle.putString("family", family)
+    } catch (_: Exception) {
+      // Ignore invalid font resources.
+    }
+  }
+
+  private fun bottomInsetToDIPFromPixel(bundle: Bundle): Bundle {
+    val propsBundle = bundle.getBundle("props")
+    val sdkParamsBundle = propsBundle?.getBundle("sdkParams")
+    sdkParamsBundle?.getFloat("topInset")?.let { dipValue ->
+      sdkParamsBundle.putFloat("topInset", PixelUtil.toDIPFromPixel(dipValue))
+    }
+    sdkParamsBundle?.getFloat("leftInset")?.let { dipValue ->
+      sdkParamsBundle.putFloat("leftInset", PixelUtil.toDIPFromPixel(dipValue))
+    }
+    sdkParamsBundle?.getFloat("rightInset")?.let { dipValue ->
+      sdkParamsBundle.putFloat("rightInset", PixelUtil.toDIPFromPixel(dipValue))
+    }
+    sdkParamsBundle?.getFloat("bottomInset")?.let { dipValue ->
+      sdkParamsBundle.putFloat("bottomInset", PixelUtil.toDIPFromPixel(dipValue))
+    }
+    return bundle
+  }
+}

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

@@ -0,0 +1,40 @@
+package io.hyperswitch.paymentsession
+
+import org.json.JSONObject
+import java.util.concurrent.atomic.AtomicReference
+
+typealias Callback = (String) -> Unit
+
+object PaymentSheetCallbackManager {
+    private val callback = AtomicReference<Callback?>(null)
+    private var isFragment: Boolean = true
+
+    fun setCallback(newCallback: Callback, newIsFragment: Boolean = true) {
+        callback.set(newCallback)
+        isFragment = newIsFragment
+    }
+
+    fun getCallback(): Callback? {
+        return callback.get()
+    }
+
+    fun executeCallback(data: String): Boolean {
+//        val jsonObject = JSONObject(data)
+//        val result = when (val status = jsonObject.getString("status")) {
+//            "cancelled" -> PaymentResult.Canceled(status)
+//            "failed", "requires_payment_method" -> {
+//                val message = jsonObject.getString("message")
+//                val throwable = Throwable(message.ifEmpty { status })
+//                throwable.initCause(Throwable(jsonObject.getString("code")))
+//                PaymentResult.Failed(throwable)
+//            }
+//
+//            else -> PaymentResult.Completed(status)
+//        }
+
+        // Atomically get and clear callback to prevent double-invocation
+        val currentCallback = callback.getAndSet(null)
+        currentCallback?.invoke(data) ?: println("No callback set")
+        return isFragment
+    }
+}

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

@@ -0,0 +1,63 @@
+package io.hyperswitch.paymentsheet
+
+import android.content.Intent
+import android.os.Bundle
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+import org.json.JSONObject
+
+/**
+ * Result to be passed to the callback of [PaymentLauncher]
+ */
+sealed class PaymentResult : Parcelable {
+  @Parcelize
+  class Completed(val data: String) : PaymentResult()
+
+  @Parcelize
+  class Failed(val throwable: Throwable) : PaymentResult()
+
+  @Parcelize
+  class Canceled(val data: String) : PaymentResult()
+
+  @JvmSynthetic
+  fun toBundle() = Bundle().apply {
+    putParcelable(EXTRA, this@PaymentResult)
+  }
+
+  @JvmSynthetic
+  fun toJSONString(): String {
+    return when (this) {
+      is Completed -> {
+        JSONObject()
+          .put("status", "completed")
+          .put("data", data)
+          .toString()
+      }
+
+      is Canceled -> {
+        JSONObject()
+          .put("status", "canceled")
+          .put("data", data)
+          .toString()
+      }
+
+      is Failed -> {
+        JSONObject()
+          .put("status", "failed")
+          .put("error", throwable.message)
+          .put("type", throwable::class.java.name)
+          .toString()
+      }
+    }
+  }
+
+  internal companion object {
+    private const val EXTRA = "extra_args"
+
+    @JvmSynthetic
+    fun fromIntent(intent: Intent?): PaymentResult {
+      return intent?.getParcelableExtra(EXTRA)
+        ?: Failed(IllegalStateException("Failed to get PaymentResult from Intent"))
+    }
+  }
+}

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

@@ -0,0 +1,54 @@
+package io.hyperswitch.react
+
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.google.android.gms.wallet.button.ButtonConstants
+import io.hyperswitch.view.GooglePayButtonView
+
+class GooglePayButtonManager : SimpleViewManager<GooglePayButtonView>() {
+    override fun getName() = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext) = GooglePayButtonView(context)
+
+    override fun onAfterUpdateTransaction(view: GooglePayButtonView) {
+        super.onAfterUpdateTransaction(view)
+        view.addButton()
+    }
+
+    @ReactProp(name = "allowedPaymentMethods")
+    fun allowedPaymentMethods(view: GooglePayButtonView, allowedPaymentMethods: String) {
+        view.allowedPaymentMethods = allowedPaymentMethods
+    }
+
+    @ReactProp(name = "buttonType")
+    fun buttonType(view: GooglePayButtonView, type: String?) {
+        view.type = when (type) {
+            "BUY" -> ButtonConstants.ButtonType.BUY
+            "BOOK" -> ButtonConstants.ButtonType.BOOK
+            "CHECKOUT" -> ButtonConstants.ButtonType.CHECKOUT
+            "DONATE" -> ButtonConstants.ButtonType.DONATE
+            "ORDER" -> ButtonConstants.ButtonType.ORDER
+            "PAY" -> ButtonConstants.ButtonType.PAY
+            "SUBSCRIBE" -> ButtonConstants.ButtonType.SUBSCRIBE
+            else -> ButtonConstants.ButtonType.PLAIN
+        }
+    }
+
+    @ReactProp(name = "buttonStyle")
+    fun buttonStyle(view: GooglePayButtonView, theme: String?) {
+        view.theme = when (theme) {
+            "light" -> ButtonConstants.ButtonTheme.LIGHT
+            else -> ButtonConstants.ButtonTheme.DARK
+        }
+    }
+
+    @ReactProp(name = "borderRadius")
+    fun borderRadius(view: GooglePayButtonView, radius: Int) {
+        view.cornerRadius = radius
+    }
+
+    companion object {
+        const val REACT_CLASS = "GooglePayButton"
+    }
+}

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

@@ -0,0 +1,73 @@
+package io.hyperswitch.react
+
+import android.os.Bundle
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
+import com.facebook.react.defaults.DefaultReactActivityDelegate
+import com.proyecto26.inappbrowser.ChromeTabsDismissedEvent
+import com.proyecto26.inappbrowser.ChromeTabsManagerActivity
+import io.hyperswitch.redirect.RedirectEvent
+import org.greenrobot.eventbus.EventBus
+import org.greenrobot.eventbus.Subscribe
+
+class HyperActivity : ReactActivity() {
+
+    /**
+     * Returns the name of the main component registered from JavaScript. This is used to schedule
+     * rendering of the component.
+     */
+    override fun getMainComponentName(): String = "hyperSwitch"
+
+    /**
+     * Returns the instance of the [ReactActivityDelegate]. We use [DefaultReactActivityDelegate]
+     * which allows you to enable New Architecture with a single boolean flags [fabricEnabled]
+     */
+    override fun createReactActivityDelegate(): ReactActivityDelegate {
+        return object : DefaultReactActivityDelegate(this, mainComponentName, fabricEnabled) {
+            override fun getLaunchOptions(): Bundle =
+                intent.getBundleExtra("configuration") ?: Bundle()
+
+            override fun getReactNativeHost(): ReactNativeHost {
+                return ReactNativeController.getReactNativeHost()
+            }
+        }
+    }
+
+    @Subscribe
+    fun onEvent(event: RedirectEvent) {
+        unRegisterEventBus()
+        EventBus.getDefault().post(
+            ChromeTabsDismissedEvent(
+                event.message,
+                event.resultType,
+                event.isError
+            )
+        )
+        startActivity(ChromeTabsManagerActivity.createDismissIntent(applicationContext))
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        registerEventBus()
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        unRegisterEventBus()
+    }
+
+    private fun registerEventBus() {
+        if (!EventBus.getDefault().isRegistered(this)) {
+            EventBus.getDefault().register(this)
+        }
+    }
+
+    private fun unRegisterEventBus() {
+        if (EventBus.getDefault().isRegistered(this)) {
+            EventBus.getDefault().unregister(this)
+        }
+    }
+
+}

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

@@ -0,0 +1,144 @@
+package io.hyperswitch.react
+
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+//import io.hyperswitch.PaymentEvent
+//import io.hyperswitch.PaymentEventListener
+//import io.hyperswitch.PaymentEventSubscription
+import java.util.concurrent.ConcurrentLinkedQueue
+
+object HyperEventEmitter {
+    private var reactContext: ReactApplicationContext? = null
+    private val pendingEvents = ConcurrentLinkedQueue<Pair<String, Map<String, String?>>>()
+//    @Volatile private var eventListener: PaymentEventListener? = null
+//    @Volatile private var subscriptionEvents: PaymentEventSubscription? = null
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    fun initialize(context: ReactApplicationContext) {
+        reactContext = context
+        processPendingEvents()
+    }
+
+    fun deinitialize() {
+        reactContext = null
+//        eventListener = null
+//        subscriptionEvents = null
+        mainHandler.removeCallbacksAndMessages(null)
+    }
+
+    /**
+     * Set the payment event listener for merchant callbacks
+     * @param listener The listener to receive payment events
+     * @param subscription The event subscription configuration
+     */
+//    fun setEventListener(listener: PaymentEventListener?, subscription: PaymentEventSubscription? = null) {
+//        eventListener = listener
+//        subscriptionEvents = subscription
+//    }
+
+    /**
+     * Emit a payment event to merchant listener (if subscribed)
+     * @param eventType The type of event (e.g., "payment_method.info.card")
+     * @param payload The event payload data
+     */
+    fun emitPaymentEvent(
+        eventType: String,
+        payload: Map<String, Any>
+    ) {
+//        val shouldEmit = isSubscribed(eventType)
+
+//        if (shouldEmit && eventListener != null) {
+//            val event = PaymentEvent(
+//                type = eventType,
+//                payload = payload
+//            )
+//
+//            mainHandler.post {
+//                eventListener?.onPaymentEvent(event)
+//            }
+//        }
+    }
+
+//    fun isSubscribed(eventType: String): Boolean {
+//        val subscription = subscriptionEvents ?: return false
+//        return subscription.isSubscribed(eventType)
+//    }
+
+    /**
+     * Get the list of subscribed event types
+     * Called by React Native to initialize subscription state
+     * @return List of subscribed event type strings
+     */
+    fun getSubscribedEvents(): List<String> {
+//        val subscription = subscriptionEvents ?:
+        return emptyList()
+//        return subscription.getSubscribedEventStrings()
+    }
+
+    fun confirmStatic(tag: String, map: MutableMap<String, String?>) {
+        val writableMap = Arguments.createMap()
+        for ((key, value) in map) {
+            when (value) {
+                "true" -> {
+                    writableMap.putBoolean(key, true)
+                }
+                "false" -> {
+                    writableMap.putBoolean(key, false)
+                }
+                else -> {
+                    writableMap.putString(key, value)
+                }
+            }
+        }
+
+        if (reactContext != null && reactContext!!.hasCatalystInstance()) {
+            try {
+                reactContext!!.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    ?.emit(tag, writableMap)
+            } catch (e: Exception) {
+                pendingEvents.add(Pair(tag, map))
+            }
+        } else {
+            pendingEvents.add(Pair(tag, map))
+        }
+    }
+
+    fun confirmCardStatic(map: MutableMap<String, String?>) {
+        confirmStatic("confirm", map)
+    }
+
+    fun confirmECStatic(map: MutableMap<String, String?>) {
+        confirmStatic("confirmEC", map)
+    }
+
+    private fun processPendingEvents() {
+        if (reactContext?.hasCatalystInstance() != true || reactContext?.catalystInstance?.isDestroyed == true) {
+            return
+        }
+
+        val iterator = pendingEvents.iterator()
+        while (iterator.hasNext()) {
+            val (tag, map) = iterator.next()
+            val writableMap = Arguments.createMap()
+            for ((key, value) in map) {
+                 when (value) {
+                    "true" -> {
+                        writableMap.putBoolean(key, true)
+                    }
+                    "false" -> {
+                        writableMap.putBoolean(key, false)
+                    }
+                    else -> {
+                        writableMap.putString(key, value)
+                    }
+                }
+            }
+                reactContext!!.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    ?.emit(tag, writableMap)
+                iterator.remove()
+        }
+    }
+}