react-native-hyperswitch-dev-sdk 0.4.1

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

@@ -0,0 +1,405 @@
+package io.hyperswitch.react
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebResourceRequest
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.IllegalViewOperationException
+import com.facebook.react.uimanager.UIManagerModule
+import com.hyperswitchsdkreactnative.BuildConfig
+import com.hyperswitchsdkreactnative.NativeHyperswitchSdkNativeSpec
+import io.hyperswitch.payments.GooglePayCallbackManager
+import io.hyperswitch.paymentsession.LaunchOptions
+import io.hyperswitch.paymentsession.PaymentSheetCallbackManager
+import io.hyperswitch.webview.utils.HSWebViewManagerImpl
+import io.hyperswitch.webview.utils.HSWebViewWrapper
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+import org.json.JSONObject
+import io.hyperswitch.webview.utils.Callback as HSCallback
+
+class HyperModule internal constructor(private val rct: ReactApplicationContext) :
+  NativeHyperswitchSdkNativeSpec(rct) {
+  companion object {
+
+    const val NAME = "HyperModule"
+
+    // Static methods with unique signatures for reflection access from lite SDK
+    @JvmStatic
+    fun confirmStatic(tag: String, map: MutableMap<String, String?>) {
+      HyperEventEmitter.confirmStatic(tag, map)
+    }
+
+    @JvmStatic
+    fun confirmCardStatic(map: MutableMap<String, String?>) {
+      HyperEventEmitter.confirmCardStatic(map)
+    }
+
+    @JvmStatic
+    fun confirmECStatic(map: MutableMap<String, String?>) {
+      HyperEventEmitter.confirmECStatic(map)
+    }
+  }
+
+  override fun getName(): String {
+    HyperEventEmitter.initialize(rct)
+    return NAME
+  }
+
+  // Using invalidate instead of deprecated onCatalystInstanceDestroy
+  override fun invalidate() {
+    super.invalidate()
+    HyperEventEmitter.deinitialize()
+  }
+
+  @ReactMethod
+  override fun updateWidgetHeight(height: Double) {
+    // Express checkout widget height adjustment is not yet implemented.
+  }
+
+  /**
+   * Called from JS when a wallet confirm button is tapped.
+   * Stores the callback; native later calls [resolveConfirmCallback] to proceed/abort.
+   */
+  @ReactMethod
+  override fun onPaymentConfirmButtonClick(rootTag: Double, payload: String, callback: Callback) {
+    findViewWithRootTag(rootTag.toInt()) {
+      try {
+        if (it == null) {
+          callback.invoke(true)
+        } else {
+          it.notifyConfirmButtonClicked(payload, { it: Boolean ->
+            callback.invoke(it)
+          })
+        }
+      } catch (_: Exception) {
+        callback.invoke(false)
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun sendMessageToNative(rnMessage: String) {
+    val jsonObject = JSONObject(rnMessage)
+    if (jsonObject.optBoolean("isReady", false)) {
+      HyperEventEmitter.initialize(rct)
+//            WidgetLauncher.onPaymentReadyCallback(true)
+    }
+  }
+
+  // Method to launch Google Pay payment
+  @ReactMethod
+  override fun launchGPay(googlePayRequest: String, callBack: Callback) {
+    currentActivity?.let {
+      GooglePayCallbackManager.setCallback(
+        it,
+        googlePayRequest,
+        fun(data: Map<String, Any?>) {
+          callBack.invoke(
+            Arguments.fromBundle(
+              LaunchOptions(
+                it, BuildConfig.VERSION_NAME
+              ).toBundle(data)
+            )
+          )
+        },
+      )
+    } ?: run {
+      GooglePayCallbackManager.setCallback(
+        reactApplicationContext,
+        googlePayRequest,
+        fun(data: Map<String, Any?>) {
+          callBack.invoke(
+            Arguments.fromBundle(
+              LaunchOptions(
+                reactApplicationContext, BuildConfig.VERSION_NAME
+              ).toBundle(data)
+            )
+          )
+        },
+      )
+    }
+  }
+
+  override fun launchApplePay(
+    requestObj: String?,
+    callback: Callback?
+  ) {
+    callback?.invoke("Apple pay is not supported")
+
+  }
+
+  override fun startApplePay(
+    requestObj: String?,
+    callback: Callback?
+  ) {
+    callback?.invoke("Apple pay is not supported")
+  }
+
+  override fun presentApplePay(
+    requestObj: String?,
+    callback: Callback?
+  ) {
+    callback?.invoke("Apple pay is not supported")
+  }
+
+  // Method to exit the payment sheet
+  @ReactMethod
+  override fun exitPaymentsheet(rootTag: Double, paymentResult: String, reset: Boolean) {
+    val isFragment = PaymentSheetCallbackManager.executeCallback(paymentResult)
+    (currentActivity as? FragmentActivity)?.let {
+      if (isFragment) it.supportFragmentManager.findFragmentByTag("paymentSheet")
+        ?.let { fragment ->
+          it.supportFragmentManager.beginTransaction().hide(fragment)
+            .commitAllowingStateLoss()
+        }
+      else it.finish()
+    }
+  }
+
+  override fun exitPaymentMethodManagement(
+    rootTag: Double,
+    result: String?,
+    reset: Boolean
+  ) {
+    TODO("Not yet implemented")
+  }
+
+  // Method to exit the widget
+  @ReactMethod
+  override fun exitWidget(paymentResult: String, widgetType: String) {
+//        WidgetLaunche.onPaymentResultCallback(widgetType, paymentResult)
+  }
+
+  // Method to exit the card form
+  @ReactMethod
+  override fun exitCardForm(paymentResult: String) {
+//        WidgetLauncher.onPaymentResultCallback(PaymentMethod.CARD.apiValue, paymentResult)
+  }
+
+  // Method to launch widget payment sheet
+  @ReactMethod
+  override fun launchWidgetPaymentSheet(paymentResult: String, callBack: Callback) {
+  }
+
+  // Method to exit widget payment sheet
+  @ReactMethod
+  override fun exitWidgetPaymentsheet(rootTag: Double, paymentResult: String, reset: Boolean) {
+    findViewWithRootTag(rootTag.toInt(), {
+      it?.notifyResult(CallbackType.PAYMENT_RESULT, paymentResult)
+    })
+  }
+
+  @ReactMethod
+  override fun notifyWidgetPaymentResult(rootTag: Double, result: String) {
+    Log.i("Manideep", rootTag.toInt().toString())
+    findViewWithRootTag(rootTag.toInt(), { fragment ->
+      if (fragment == null) {
+        Log.w(
+          "HyperModule",
+          "notifyWidgetPaymentResult: no fragment found for rootTag=$rootTag"
+        )
+      } else {
+        fragment.notifyResult(CallbackType.CONFIRM_ACTION, result)
+      }
+    })
+  }
+
+  override fun onAddPaymentMethod(data: String?) {
+    TODO("Not yet implemented")
+  }
+
+  @ReactMethod
+  override fun onUpdateIntentEvent(rootTag: Double, type: String, result: String) {
+    findViewWithRootTag(rootTag.toInt(), { fragment ->
+      if (fragment == null) {
+        Log.w("HyperModule", "onUpdateIntentEvent: no fragment found for rootTag=$rootTag")
+        return@findViewWithRootTag
+      }
+      if (type == "UPDATE_INTENT_INIT_RETURNED") {
+        fragment.notifyResult(CallbackType.UPDATE_INTENT_INIT, result)
+      } else if (type == "UPDATE_INTENT_COMPLETE_RETURNED") {
+        fragment.notifyResult(CallbackType.UPDATE_INTENT_COMPLETE, result)
+      }
+    })
+  }
+
+  // Variable to keep track of event listener count
+  private val listenerCount = AtomicInteger(0)
+
+
+  // Method to add event listener
+  @ReactMethod
+  override fun addListener(eventName: String?) {
+    if (listenerCount.incrementAndGet() == 1) {
+      HyperEventEmitter.initialize(rct)
+    }
+  }
+
+  // Method to remove event listeners
+  @ReactMethod
+  override fun removeListeners(count: Double) {
+    listenerCount.addAndGet(-count.toInt())
+  }
+
+  @ReactMethod
+  override fun emitPaymentEvent(rootTag: Double, eventType: String, payload: ReadableMap) {
+    Log.i("Manideep", rootTag.toInt().toString())
+    findViewWithRootTag(rootTag.toInt(), { fragment ->
+      if (fragment == null) {
+        Log.w("HyperModule", "emitPaymentEvent: no fragment found for rootTag=$rootTag")
+      } else {
+        fragment.notifyEvent(eventType, payload)
+      }
+    })
+  }
+
+  @ReactMethod
+  override fun openIframeBridge(url: String, timeoutMs: Double, callback: Callback) {
+    if (timeoutMs <= 0) {
+      callback.invoke("")
+      return
+    }
+    if (url.isBlank()) {
+      callback.invoke("")
+      return
+    }
+
+    val mainHandler = Handler(Looper.getMainLooper())
+    val callbackInvoked = AtomicBoolean(false)
+    var webViewWrapper: HSWebViewWrapper? = null
+    var timeoutRunnable: Runnable? = null
+
+    val invokeCallback = { redirectUrl: String ->
+      if (callbackInvoked.compareAndSet(false, true)) {
+        timeoutRunnable?.let { mainHandler.removeCallbacks(it) }
+        mainHandler.post {
+          webViewWrapper?.let { wrapper ->
+            try {
+              (wrapper.parent as? ViewGroup)?.removeView(wrapper)
+              wrapper.webView.stopLoading()
+              wrapper.webView.destroy()
+            } catch (e: Exception) {
+              Log.e("HyperDDC", "cleanup error: ${e.message}")
+            }
+          }
+          webViewWrapper = null
+        }
+        callback.invoke(redirectUrl)
+      }
+    }
+
+    mainHandler.post {
+      val activity = currentActivity ?: run {
+        invokeCallback("")
+        return@post
+      }
+
+      val manager = HSWebViewManagerImpl(activity, HSCallback { _ -> })
+
+      var wrapper: HSWebViewWrapper? = null
+      repeat(2) { attempt ->
+        if (wrapper != null) return@repeat
+        try {
+          wrapper = manager.createViewInstance()
+        } catch (e: Exception) {
+          if (attempt == 0) Thread.sleep(200)
+        }
+      }
+      val resolvedWrapper = wrapper ?: run {
+        invokeCallback("")
+        return@post
+      }
+
+      manager.setJavaScriptEnabled(resolvedWrapper, true)
+
+      val ddcBridge = object : Any() {
+        @android.webkit.JavascriptInterface
+        fun onMessage(data: String) {
+          invokeCallback(data)
+        }
+      }
+      resolvedWrapper.webView.addJavascriptInterface(ddcBridge, "HyperDDCBridge")
+
+      resolvedWrapper.webView.webViewClient = object : WebViewClient() {
+        override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest): Boolean {
+          if (request.isForMainFrame) {
+            val url = request.url.toString()
+            Log.d("HyperDDC", "shouldOverride intercepted: $url")
+            invokeCallback("{\"next_action\":{\"type\":\"redirect_to_url\",\"url\":\"$url\"}}")
+            return true
+          }
+          return false
+        }
+
+        @Suppress("DEPRECATION")
+        override fun shouldOverrideUrlLoading(view: WebView, url: String): Boolean {
+          Log.d("HyperDDC", "shouldOverride intercepted (legacy): $url")
+          invokeCallback("{\"next_action\":{\"type\":\"redirect_to_url\",\"url\":\"$url\"}}")
+          return true
+        }
+      }
+
+      resolvedWrapper.apply {
+        isFocusable = false
+        isFocusableInTouchMode = false
+        layoutParams = ViewGroup.LayoutParams(1, 1)
+        translationX = -9999f
+        translationY = -9999f
+        importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+      }
+
+      activity.findViewById<ViewGroup>(android.R.id.content).addView(resolvedWrapper)
+      webViewWrapper = resolvedWrapper
+
+      val wrapperHtml = """
+                <html><body>
+                <iframe src="$url" style="display:none;width:1px;height:1px;"></iframe>
+                <script>
+                window.addEventListener('message', function(event) {
+                  var str = typeof event.data === 'string' ? event.data : JSON.stringify(event.data);
+                  try { HyperDDCBridge.onMessage(str); } catch(e) {}
+                });
+                </script>
+                </body></html>
+            """.trimIndent()
+      resolvedWrapper.webView.loadDataWithBaseURL(url, wrapperHtml, "text/html", "UTF-8", null)
+
+      timeoutRunnable = Runnable { invokeCallback("") }.also {
+        mainHandler.postDelayed(it, timeoutMs.toLong())
+      }
+    }
+  }
+
+  private fun findViewWithRootTag(rootTag: Int, onFound: (HyperFragment?) -> Unit) {
+    val uiManagerModule =
+      reactApplicationContext.getNativeModule<UIManagerModule?>(UIManagerModule::class.java)
+
+    if (uiManagerModule == null) {
+      onFound(null)
+      return
+    }
+
+    uiManagerModule.addUIBlock { nvhm ->
+      try {
+        val reactRootView = nvhm.resolveView(rootTag)
+        onFound(FragmentManager.findFragment(reactRootView))
+      } catch (e: IllegalViewOperationException) {
+        onFound(null)
+      } catch (e: Exception) {
+        onFound(null)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+package io.hyperswitch.react
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class HyperPackage : ReactPackage {
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(GooglePayButtonManager())
+    }
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(HyperModule(reactContext), HyperHeadlessModule(reactContext))
+    }
+}

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

@@ -0,0 +1,251 @@
+package io.hyperswitch.react
+
+import android.app.Application
+import android.content.Context
+import com.facebook.react.HyperPackageList
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.JSBundleLoader
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.defaults.DefaultComponentsRegistry
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint
+import com.facebook.react.defaults.DefaultReactHost
+import com.facebook.react.defaults.DefaultReactHostDelegate
+import com.facebook.react.defaults.DefaultReactNativeHost
+import com.facebook.react.defaults.DefaultTurboModuleManagerDelegate
+import com.facebook.react.fabric.ComponentFactory
+import com.facebook.react.runtime.ReactHostImpl
+import com.facebook.react.runtime.cxxreactpackage.CxxReactPackage
+import com.facebook.react.runtime.hermes.HermesInstance
+import com.facebook.react.soloader.OpenSourceMergedSoMapping
+import com.facebook.soloader.SoLoader
+import com.hyperswitchsdkreactnative.BuildConfig
+import com.hyperswitchsdkreactnative.R
+import io.hyperswitch.logs.CrashHandler
+import io.hyperswitch.logs.EventName
+import io.hyperswitch.logs.HSLog
+import io.hyperswitch.logs.HyperLogManager
+import io.hyperswitch.logs.LogCategory
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * ReactNativeController
+ *
+ * Entry point for initializing and accessing the Hyperswitch React Native runtime.
+ * This object is responsible for:
+ * - Initializing React Native (Old & New Architecture)
+ * - Loading JS bundles (OTA or bundled assets)
+ * - Managing ReactHost / ReactNativeHost lifecycle
+ * - Setting up crash handling and native dependencies
+ *
+ * This SDK is designed to be initialized once per application lifecycle.
+ */
+object ReactNativeController {
+
+  @Volatile
+  private var reactNativeHost = AtomicReference<ReactNativeHost?>(null)
+
+  @Volatile
+  private var reactHost = AtomicReference<ReactHost?>(null)
+
+  @Volatile
+  private var isInitialized = AtomicBoolean(false)
+
+  /**
+   * Resolves the JavaScript bundle path using Hyper Airborne OTA if available.
+   *
+   * Behavior:
+   * - Determines SDK environment using the publishable key
+   * - Reads OTA endpoint from resources based on environment
+   * - Dynamically loads AirborneOTA via reflection (optional dependency)
+   * - Fetches the OTA-downloaded bundle path
+   * - Falls back to bundled assets if OTA is disabled, unavailable, or fails
+   *
+   * @param application Application context
+   * @return Path to the JS bundle (OTA or bundled asset)
+   */
+  private fun getBundleFromAirborne(application: Application): String {
+    try {
+//            val environment = SDKEnvironment.PROD
+      // TODO: change this to ENV check based on the Configuration.
+      val airborneUrl = application.getString(
+        R.string.hyperOTAEndPoint
+      )
+
+      // Ensure OTA endpoint is valid
+      if (airborneUrl != "hyperOTA_END_POINT_") {
+        val airborneClass =
+          Class.forName("io.hyperswitch.airborne.AirborneOTA")
+
+        val constructor = airborneClass.getConstructor(
+          Context::class.java,
+          String::class.java,
+          String::class.java
+        )
+
+        val instance = constructor.newInstance(
+          application.applicationContext,
+          BuildConfig.VERSION_NAME,
+          airborneUrl
+        )
+
+        val getBundlePath =
+          airborneClass.getMethod("getBundlePath")
+        return getBundlePath.invoke(instance) as String
+      }
+    } catch (_: Exception) {
+    }
+    return "assets://hyperswitch.bundle"
+  }
+
+  /**
+   * Creates and configures the ReactNativeHost instance.
+   *
+   * Responsibilities:
+   * - Registers required React Native packages
+   * - Enables Hermes and New Architecture flags
+   * - Resolves JS bundle source (OTA or bundled)
+   *
+   * @param application Application context
+   * @return Configured ReactNativeHost instance
+   */
+  private fun createReactNativeHost(
+    application: Application,
+  ): ReactNativeHost {
+    return object : DefaultReactNativeHost(application) {
+      override fun getPackages(): List<ReactPackage> {
+        return HyperPackageList(this).packages.apply {
+          add(HyperPackage())
+        }
+      }
+
+      override fun getJSMainModuleName(): String = "index"
+      override fun getUseDeveloperSupport(): Boolean = false
+      override val isNewArchEnabled: Boolean =
+        BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+      override val isHermesEnabled: Boolean =
+        BuildConfig.IS_HERMES_ENABLED
+
+      override fun getJSBundleFile(): String =
+        getBundleFromAirborne(application)
+
+    }
+  }
+
+  /**
+   * Returns whether the SDK has already been initialized.
+   *
+   * @return true if initialized, false otherwise
+   */
+  fun getIsInitialized(): Boolean {
+    return isInitialized.get()
+  }
+
+  /**
+   * Returns the initialized ReactNativeHost instance.
+   *
+   * @throws IllegalStateException if SDK is not initialized
+   * @return ReactNativeHost
+   */
+  fun getReactNativeHost(): ReactNativeHost {
+    return checkNotNull(reactNativeHost.get()) {
+      "ReactNative not initialized. Call ReactNativeController.initialize()"
+    }
+  }
+
+  /**
+   * Returns the initialized ReactHost instance.
+   *
+   * @throws IllegalStateException if SDK is not initialized
+   * @return ReactHost
+   */
+  fun getReactHost(): ReactHost {
+    return checkNotNull(reactHost.get()) {
+      "ReactNative not initialized. Call ReactNativeController.initialize()"
+    }
+  }
+
+  @OptIn(UnstableReactNativeAPI::class)
+  fun createReactHost(application: Application): ReactHost {
+
+    val bundleLoader =
+      JSBundleLoader.createAssetLoader(application, "assets://hyperswitch.bundle", true)
+
+    val defaultTmmDelegateBuilder = DefaultTurboModuleManagerDelegate.Builder()
+    val cxxReactPackageProviders: List<(ReactContext) -> CxxReactPackage> = emptyList()
+    cxxReactPackageProviders.forEach { defaultTmmDelegateBuilder.addCxxReactPackage(it) }
+    val defaultReactHostDelegate =
+      DefaultReactHostDelegate(
+        jsMainModulePath = "index",
+        jsBundleLoader = bundleLoader,
+        reactPackages = HyperPackageList(application).packages,
+        jsRuntimeFactory = HermesInstance(),
+        bindingsInstaller = null,
+        turboModuleManagerDelegateBuilder = defaultTmmDelegateBuilder,
+        exceptionHandler = {}
+      )
+    val componentFactory = ComponentFactory()
+    DefaultComponentsRegistry.register(componentFactory)
+
+    return ReactHostImpl(
+      application,
+      defaultReactHostDelegate,
+      componentFactory,
+      false, /* allowPackagerServerAccess */
+      false
+    )
+  }
+
+  /**
+   * Initializes the ReactNativeController.
+   *
+   * This method:
+   * - Ensures single initialization (thread-safe)
+   * - Registers a global crash handler
+   * - Initializes SoLoader
+   * - Loads New Architecture entry point if enabled
+   * - Creates ReactNativeHost and ReactHost instances
+   * @param application Application instance
+   */
+  fun initialize(application: Application) {
+    try {
+      synchronized(this) {
+        if (isInitialized.get()) return
+
+        Thread.setDefaultUncaughtExceptionHandler(
+          CrashHandler(application, BuildConfig.VERSION_NAME)
+        )
+
+        if (false) {
+          SoLoader.init(application, OpenSourceMergedSoMapping)
+
+          if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+            DefaultNewArchitectureEntryPoint.load()
+          }
+        }
+
+
+
+        reactNativeHost.set(createReactNativeHost(application))
+        // TODO use the proper React Host that fixes the proper developer
+        reactHost.set(
+          createReactHost(application)
+        )
+
+        isInitialized.set(true)
+      }
+    } catch (e: Exception) {
+      HyperLogManager.addLog(
+        HSLog.LogBuilder()
+          .value("Failed to initialize Hyperswitch SDK: ${e.message}")
+          .category(LogCategory.API)
+          .eventName(EventName.CRASH_EVENT)
+          .logType("error")
+          .build()
+      )
+    }
+  }
+}