@juspay-tech/react-native-hyperswitch 0.2.1

package/android/src/main/java/com/hyperswitchsdkreactnative/internal/ReactFragment.kt

@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.hyperswitchsdkreactnative.internal
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.view.KeyEvent
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import com.facebook.react.HyperPackageList
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import com.facebook.react.runtime.hermes.HermesInstance
+import com.facebook.react.shell.MainReactPackage
+import com.hyperswitchsdkreactnative.BuildConfig
+import com.hyperswitchsdkreactnative.R
+import com.hyperswitchsdkreactnative.internal.DefaultReactHost.getDefaultReactHost
+import com.hyperswitchsdkreactnative.provider.HyperProvider
+import `in`.juspay.hyperota.LazyDownloadCallback
+import `in`.juspay.hyperotareact.HyperOTAReact
+import io.hyperswitch.hyperota.HyperOtaLogger
+import io.hyperswitch.react.SDKEnvironment
+import io.hyperswitch.react.Utils.Companion.checkEnvironment
+
+/**
+ * Fragment for creating a React View. This allows the developer to "embed" a React Application
+ * inside native components such as a Drawer, ViewPager, etc.
+ */
+internal open class ReactFragment : Fragment(), PermissionAwareActivity {
+  protected lateinit var reactDelegate: ReactDelegate
+
+  private var disableHostLifecycleEvents = false
+  private var permissionListener: PermissionListener? = null
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    var mainComponentName: String? = null
+    var launchOptions: Bundle? = null
+    var fabricEnabled = false
+    arguments?.let { args ->
+      mainComponentName = args.getString(ARG_COMPONENT_NAME)
+      launchOptions = args.getBundle(ARG_LAUNCH_OPTIONS)
+      fabricEnabled = args.getBoolean(ARG_FABRIC_ENABLED)
+      @Suppress("DEPRECATION")
+      disableHostLifecycleEvents = args.getBoolean(ARG_DISABLE_HOST_LIFECYCLE_EVENTS)
+    }
+    checkNotNull(mainComponentName) { "Cannot loadApp if component name is null" }
+    reactDelegate =
+      if (ReactNativeFeatureFlags.enableBridgelessArchitecture()) {
+        ReactDelegate(requireActivity(), reactHost, mainComponentName, launchOptions)
+      } else {
+        @Suppress("DEPRECATION")
+        (ReactDelegate(
+          requireActivity(),
+          reactNativeHost,
+          mainComponentName,
+          launchOptions,
+          fabricEnabled,
+        ))
+      }
+  }
+
+  /**
+   * Get the [ReactNativeHost] used by this app. By default, assumes [Activity.getApplication] is an
+   * instance of [ReactApplication] and calls [ReactApplication.reactNativeHost]. Override this
+   * method if your application class does not implement `ReactApplication` or you simply have a
+   * different mechanism for storing a `ReactNativeHost`, e.g. as a static field somewhere.
+   */
+  @Suppress("DEPRECATION")
+  @Deprecated(
+    "You should not use ReactNativeHost directly in the New Architecture. Use ReactHost instead.",
+    ReplaceWith("reactHost"),
+  )
+  protected open val reactNativeHost: ReactNativeHost?
+    get() = // (activity?.application as ReactApplication?)?.reactNativeHost
+      object : DefaultReactNativeHost(requireActivity().application) {
+        override fun getPackages(): List<ReactPackage> =
+          HyperPackageList(this).packages.apply {
+          }
+
+        override fun getJSMainModuleName(): String = "index"
+        override fun getBundleAssetName(): String = "hyperswitch.bundle"
+        override fun getJSBundleFile(): String {
+          return try {
+            hyperOTAServices?.getBundlePath()?.takeUnless { it.contains("ios") }
+              ?: "assets://hyperswitch.bundle"
+          } catch (_: Exception) {
+            "assets://hyperswitch.bundle"
+          }
+        }
+
+        override fun getUseDeveloperSupport(): Boolean = false
+        override val isNewArchEnabled: Boolean = true
+        override val isHermesEnabled: Boolean = true
+      }
+
+  /**
+   * Get the [ReactHost] used by this app. By default, assumes [Activity.getApplication] is an
+   * instance of [ReactApplication] and calls [ReactApplication.reactHost]. Override this method if
+   * your application class does not implement `ReactApplication` or you simply have a different
+   * mechanism for storing a `ReactHost`, e.g. as a static field somewhere.
+   *
+   * If you're using Old Architecture/Bridge Mode, this method should return null as [ReactHost] is
+   * a Bridgeless-only concept.
+   */
+  protected open val reactHost: ReactHost?
+    get() = DefaultReactHost.getDefaultReactHost(
+      requireContext(),
+      HyperPackageList(requireContext().applicationContext as Application).packages,
+      "index",
+      "hyperswitch",
+      try {
+        hyperOTAServices?.getBundlePath()?.takeUnless { it.contains("ios") }
+          ?: "assets://hyperswitch.bundle"
+      } catch (_: Exception) {
+        "assets://hyperswitch.bundle"
+      },
+      HermesInstance(),
+      false
+    )
+
+  override fun onCreateView(
+    inflater: LayoutInflater,
+    container: ViewGroup?,
+    savedInstanceState: Bundle?,
+  ): View? {
+    reactDelegate.loadApp()
+    return reactDelegate.reactRootView
+  }
+
+  override fun onResume() {
+    super.onResume()
+    if (!disableHostLifecycleEvents) {
+      reactDelegate.onHostResume()
+    }
+  }
+
+  override fun onPause() {
+    super.onPause()
+    if (!disableHostLifecycleEvents) {
+      reactDelegate.onHostPause()
+    }
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    if (!disableHostLifecycleEvents) {
+      reactDelegate.onHostDestroy()
+    } else {
+      reactDelegate.unloadApp()
+    }
+  }
+
+  @Deprecated("Deprecated in Java")
+  override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+    @Suppress("DEPRECATION") super.onActivityResult(requestCode, resultCode, data)
+    reactDelegate.onActivityResult(requestCode, resultCode, data, false)
+  }
+
+  /**
+   * Helper to forward hardware back presses to our React Native Host.
+   *
+   * This must be called via a forward from your host Activity.
+   */
+  open fun onBackPressed(): Boolean = reactDelegate.onBackPressed()
+
+  /**
+   * Helper to forward onKeyUp commands from our host Activity. This allows [ReactFragment] to
+   * handle double tap reloads and dev menus.
+   *
+   * This must be called via a forward from your host Activity.
+   *
+   * @param keyCode keyCode
+   * @param event event
+   * @return true if we handled onKeyUp
+   */
+  open fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean =
+    reactDelegate.shouldShowDevMenuOrReload(keyCode, event)
+
+  @Deprecated("Deprecated in Java")
+  override fun onRequestPermissionsResult(
+    requestCode: Int,
+    permissions: Array<String>,
+    grantResults: IntArray,
+  ) {
+    @Suppress("DEPRECATION")
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    permissionListener?.let {
+      if (it.onRequestPermissionsResult(requestCode, permissions, grantResults)) {
+        permissionListener = null
+      }
+    }
+  }
+
+  override fun checkPermission(permission: String, pid: Int, uid: Int): Int =
+    activity?.checkPermission(permission, pid, uid) ?: 0
+
+  override fun checkSelfPermission(permission: String): Int =
+    activity?.checkSelfPermission(permission) ?: 0
+
+  @Suppress("DEPRECATION")
+  override fun requestPermissions(
+    permissions: Array<String>,
+    requestCode: Int,
+    listener: PermissionListener?,
+  ) {
+    permissionListener = listener
+    requestPermissions(permissions, requestCode)
+  }
+
+  /** Builder class to help instantiate a ReactFragment. */
+  class Builder {
+    var componentName: String? = null
+    var launchOptions: Bundle? = null
+    var fabricEnabled: Boolean = false
+
+    /**
+     * Set the Component name for our React Native instance.
+     *
+     * @param componentName The name of the component
+     * @return Builder
+     */
+    fun setComponentName(componentName: String): Builder {
+      this.componentName = componentName
+      return this
+    }
+
+    /**
+     * Set the Launch Options for our React Native instance.
+     *
+     * @param launchOptions launchOptions
+     * @return Builder
+     */
+    fun setLaunchOptions(launchOptions: Bundle): Builder {
+      this.launchOptions = launchOptions
+      return this
+    }
+
+    fun build(): ReactFragment = newInstance(componentName, launchOptions, fabricEnabled)
+
+    @Deprecated(
+      "You should not change call ReactFragment.setFabricEnabled. Instead enable the NewArchitecture for the whole application with newArchEnabled=true in your gradle.properties file"
+    )
+    fun setFabricEnabled(fabricEnabled: Boolean): Builder {
+      this.fabricEnabled = fabricEnabled
+      return this
+    }
+  }
+
+  companion object {
+    protected const val ARG_COMPONENT_NAME: String = "arg_component_name"
+    protected const val ARG_LAUNCH_OPTIONS: String = "arg_launch_options"
+    protected const val ARG_FABRIC_ENABLED: String = "arg_fabric_enabled"
+
+    @Deprecated(
+      "We will remove this and use a different solution for handling Fragment lifecycle events."
+    )
+    protected const val ARG_DISABLE_HOST_LIFECYCLE_EVENTS: String =
+      "arg_disable_host_lifecycle_events"
+
+    private var hyperOTAServices: HyperOTAReact? = null
+    private lateinit var tracker: HyperOtaLogger
+
+    fun initOTAServices(
+      context :  Context
+    ) {
+      val environment = checkEnvironment(HyperProvider.publishableKey())
+      val hyperOTAUrl = context.getString(
+          if (environment == SDKEnvironment.SANDBOX)
+            R.string.hyperOTASandBoxEndPoint
+          else
+            R.string.hyperOTAEndPoint
+      )
+      if (hyperOTAUrl != "hyperOTA_END_POINT_") {
+        tracker = HyperOtaLogger()
+        val headers = mapOf(
+          "Content-Encoding" to "br, gzip"
+        )
+        context.applicationContext?.let {
+          HyperOTAReact(
+            it,
+            "hyperswitchRN",
+            "hyperswitch.bundle",
+            BuildConfig.VERSION_NAME,
+            "$hyperOTAUrl/mobile-ota/rn/android/${BuildConfig.VERSION_NAME}/config.json",
+            headers,
+            object : LazyDownloadCallback {
+              override fun fileInstalled(filePath: String, success: Boolean) {
+              }
+
+              override fun lazySplitsInstalled(success: Boolean) {
+              }
+            },
+            tracker,
+          )
+        }.also { hyperOTAServices = it }
+      }
+    }
+
+    /**
+     * @param componentName The name of the react native component
+     * @param launchOptions The launch options for the react native component
+     * @param fabricEnabled Flag to enable Fabric for ReactFragment
+     * @return A new instance of fragment ReactFragment.
+     */
+    private fun newInstance(
+      componentName: String?,
+      launchOptions: Bundle?,
+      fabricEnabled: Boolean,
+    ): ReactFragment {
+      val args =
+        Bundle().apply {
+          putString(ARG_COMPONENT_NAME, componentName)
+          putBundle(ARG_LAUNCH_OPTIONS, launchOptions)
+          putBoolean(ARG_FABRIC_ENABLED, fabricEnabled)
+        }
+      return ReactFragment().apply { setArguments(args) }
+    }
+  }
+}

package/android/src/main/java/com/hyperswitchsdkreactnative/modules/HyperswitchSdkNativeModule.kt

@@ -0,0 +1,143 @@
+package com.hyperswitchsdkreactnative.modules
+
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import org.json.JSONException
+import com.hyperswitchsdkreactnative.NativeHyperswitchSdkNativeSpec
+import com.hyperswitchsdkreactnative.modules.HyperswitchSdkReactNativeModule.Companion.resetView
+import com.hyperswitchsdkreactnative.modules.HyperswitchSdkReactNativeModule.Companion.resolvePromise
+import io.hyperswitch.payments.GooglePayCallbackManager
+/**
+ * HyperModules TurboModule implementation that bridges the bundle's expectations
+ * with the existing HyperswitchSdkModule functionality
+ */
+class HyperswitchSdkNativeModule(reactContext: ReactApplicationContext) :
+  NativeHyperswitchSdkNativeSpec(reactContext) {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod
+  override fun sendMessageToNative(message: String) {
+//    Log.d(NAME, "sendMessageToNative called with: $message")
+    // Forward to HyperswitchSdkModule if needed
+  }
+
+  @ReactMethod
+  override fun launchApplePay(requestObj: String, callback: Callback) {
+//    Log.d(NAME, "launchApplePay called")
+    // Implementation for Apple Pay
+    callback.invoke("Apple Pay not implemented")
+  }
+
+
+  @ReactMethod
+  override fun launchGPay(requestObj: String, callback: Callback) {
+    Log.i("Manideep", "called gpay here")
+    currentActivity?.let {
+      GooglePayCallbackManager.setCallback(
+        it,
+        requestObj,
+        fun(data: Map<String, Any?>) {
+          callback.invoke(mapToWritableMap(data))
+        },
+      )
+    } ?: run {
+      GooglePayCallbackManager.setCallback(
+        reactApplicationContext,
+        requestObj,
+        fun(data: Map<String, Any?>) {
+          callback.invoke(mapToWritableMap(data))
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  override fun exitPaymentsheet(rootTag: Double, result: String, reset: Boolean) {
+    try {
+      resetView()
+      resolvePromise(result)
+    } catch (e: JSONException) {
+      // Log.e(NAME, "Failed to parse JSON result: $result", e)
+      resolvePromise(result)
+    }
+
+  }
+
+  @ReactMethod
+  override fun exitPaymentMethodManagement(rootTag: Double, result: String, reset: Boolean) {
+//    Log.d(NAME, "exitPaymentMethodManagement called $result")
+    resolvePromise(result)
+
+    // Implementation for exiting payment method management
+  }
+
+  @ReactMethod
+  override fun exitWidget(result: String, widgetType: String) {
+//    Log.d(NAME, "exitWidget called with result: $result, widgetType: $widgetType")
+    resolvePromise(result)
+
+    // Implementation for exiting widget
+  }
+
+  @ReactMethod
+  override fun exitCardForm(result: String) {
+//    Log.d(NAME, "exitCardForm called with result: $result")
+    resolvePromise(result)
+
+    // Implementation for exiting card form
+  }
+
+  @ReactMethod
+  override fun exitWidgetPaymentsheet(rootTag: Double, result: String, reset: Boolean) {
+//    Log.d(NAME, "exitWidgetPaymentsheet called")
+    resolvePromise(result)
+
+    // Implementation for exiting widget payment sheet
+  }
+
+  @ReactMethod
+  override fun launchWidgetPaymentSheet(requestObj: String, callback: Callback) {
+//    Log.d(NAME, "launchWidgetPaymentSheet called")
+    // Implementation for launching widget payment sheet
+    callback.invoke("Widget payment sheet not implemented")
+  }
+
+  @ReactMethod
+  override fun updateWidgetHeight(height: Double) {
+//    Log.d(NAME, "updateWidgetHeight called with height: $height")
+    // Implementation for updating widget height
+  }
+
+  @ReactMethod
+  override fun onAddPaymentMethod(data: String) {
+//    Log.d(NAME, "onAddPaymentMethod called with data: $data")
+    // Implementation for adding payment method
+  }
+
+  private fun mapToWritableMap(map: Map<String, Any?>): WritableMap {
+    val writableMap = WritableNativeMap()
+    for ((key, value) in map) {
+      when (value) {
+        null -> writableMap.putNull(key)
+        is Boolean -> writableMap.putBoolean(key, value)
+        is Double -> writableMap.putDouble(key, value)
+        is Int -> writableMap.putInt(key, value)
+        is String -> writableMap.putString(key, value)
+        is Map<*, *> -> writableMap.putMap(key, mapToWritableMap(value as Map<String, Any?>))
+        else -> writableMap.putString(key, value.toString())
+      }
+    }
+    return writableMap
+  }
+
+  companion object {
+    const val NAME = "HyperModules"
+  }
+}

package/android/src/main/java/com/hyperswitchsdkreactnative/modules/HyperswitchSdkReactNativeModule.kt

@@ -0,0 +1,92 @@
+package com.hyperswitchsdkreactnative.modules
+
+
+import android.R.attr.id
+import androidx.fragment.app.FragmentActivity
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+import com.hyperswitchsdkreactnative.NativeHyperswitchSdkReactNativeSpec
+import com.hyperswitchsdkreactnative.provider.HyperProvider
+import io.hyperswitch.react.Utils
+
+@ReactModule(name = HyperswitchSdkReactNativeModule.NAME)
+class HyperswitchSdkReactNativeModule(reactContext: ReactApplicationContext) :
+  NativeHyperswitchSdkReactNativeSpec(reactContext) {
+
+  private var hyperProvider: HyperProvider? = null
+
+  init {
+    currentInstance = this
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun initialise(
+    publishableKey: String,
+    customBackendUrl: String?,
+    customLogUrl: String?,
+    customParams: ReadableMap?,
+    promise: Promise?
+  ) {
+    try {
+      currentActivity?.let { activity ->
+        hyperProvider = HyperProvider(activity)
+        hyperProvider!!.initialise(publishableKey, customBackendUrl, customLogUrl, customParams)
+        promise?.resolve(null)
+      } ?: run {
+        promise?.reject("INITIALIZATION_ERROR", "Current activity is null")
+      }
+    } catch (e: Exception) {
+      promise?.reject("INITIALIZATION_ERROR", "Failed to initialize Hyperswitch SDK: ${e.message}")
+    }
+  }
+
+  override fun initPaymentSession(paymentIntentClientSecret: String, promise: Promise?) {
+    try {
+      hyperProvider?.let { provider ->
+        provider.initPaymentSession(clientSecret = paymentIntentClientSecret)
+        promise?.resolve(null)
+      } ?: run {
+        promise?.reject("INIT_ERROR", "HyperProvider not initialized")
+      }
+    } catch (e: Exception) {
+      promise?.reject("INIT_ERROR", "Failed to initialize payment sheet: ${e.message}")
+    }
+  }
+
+  override fun presentPaymentSheet(readableMap: ReadableMap, promise: Promise?) {
+    try {
+      hyperProvider?.let { provider ->
+        sheetPromise = promise
+        provider.presentPaymentSheet(readableMap)
+      }
+    } catch (e: Exception) {
+      promise?.reject("PRESENT_ERROR", "Failed to present payment sheet: ${e.message}")
+    }
+  }
+
+  fun resetView() {
+    hyperProvider?.removeSheetView(true)
+  }
+
+  companion object {
+    const val NAME = "HyperswitchSdkReactNative"
+    private var sheetPromise: Promise? = null
+    private var currentInstance: HyperswitchSdkReactNativeModule? = null
+
+    fun resolvePromise(data: Any?) {
+      try {
+        sheetPromise?.resolve(data)
+      } catch (e: Exception) {
+      }
+    }
+
+    fun resetView() {
+      currentInstance?.resetView()
+    }
+  }
+}