@juspay-tech/react-native-hyperswitch 0.2.1

package/HyperswitchSdkReactNative.podspec

@@ -0,0 +1,31 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "HyperswitchSdkReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/juspay/@juspay-tech/react-native-hyperswitch.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,cpp,swift}"
+  s.private_header_files = "ios/**/*.h"
+  s.resources = ["ios/hyperswitchSDK/Core/Resources/*"]
+  
+  s.dependency 'HyperOTA', '0.0.8'
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'OTHER_SWIFT_FLAGS' => "-enable-experimental-feature AccessLevelOnImport"
+  }
+
+  s.dependency 'ReactAppDependencyProvider'
+  add_dependency(s, "React-RCTAppDelegate")
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,119 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['HyperswitchSdkReactNative_' + name]
+  }
+
+  repositories {
+    mavenLocal()
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["HyperswitchSdkReactNative_" + name]).toInteger()
+}
+
+def isNewArchitectureEnabled() {
+  return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+android {
+  namespace "com.hyperswitchsdkreactnative"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    versionCode 1
+    versionName "1.0"
+    buildConfigField "String", "VERSION_NAME", "\"${version}\""
+    buildConfigField "boolean", "IS_HERMES_ENABLED", hermesEnabled
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", newArchEnabled
+  }
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+      proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+    }
+    debug {
+      debuggable true
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+    abortOnError false
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = '17'
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni",
+        "build/generated/source/packagelist"
+      ]
+    }
+  }
+
+  packagingOptions {
+    pickFirst '**/libc++_shared.so'
+    pickFirst '**/libfbjni.so'
+    pickFirst '**/libreactnativejni.so'
+  }
+}
+rootProject.allprojects {
+  repositories {
+    mavenCentral()
+    google()
+    maven { url "https://maven.juspay.in/hyper-sdk/" }
+    mavenLocal()
+    maven {
+      url("/Users/shivam.shashank/Documents/repositories/hyperswitch-client-core/android/maven")
+    }
+  }
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+apply from: "./hyperswitch_autolinking.gradle"
+applyHyperswitchAutolinking(project)
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "com.google.android.gms:play-services-wallet:19.4.0"
+  implementation 'androidx.activity:activity-ktx:1.10.1'
+  implementation("org.greenrobot:eventbus")
+  implementation "in.juspay:hyperotareact:0.0.1-xota.10"
+  implementation "io.hyperswitch:hyperswitch-sdk-android-common:1.0.0"
+  // implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.8.7'
+  // implementation 'androidx.lifecycle:lifecycle-common-java8:2.8.7'
+  // implementation 'androidx.fragment:fragment-ktx:1.8.5'
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+HyperswitchSdkReactNative_kotlinVersion=2.0.21
+HyperswitchSdkReactNative_minSdkVersion=24
+HyperswitchSdkReactNative_targetSdkVersion=34
+HyperswitchSdkReactNative_compileSdkVersion=35
+HyperswitchSdkReactNative_ndkVersion=27.1.12297006

package/android/hyperswitch_autolinking.gradle

@@ -0,0 +1,378 @@
+import groovy.json.JsonSlurper
+import groovy.text.SimpleTemplateEngine
+
+def generatedClassName = "HyperPackageList"
+def generatedFilePackage = "com.facebook.react"
+
+def generatedFileContentsTemplate = """
+package $generatedFilePackage;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.res.Resources;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.shell.MainPackageConfig;
+import com.facebook.react.shell.MainReactPackage;
+import java.util.Arrays;
+import java.util.ArrayList;
+
+{{ packageImports }}
+
+public class $generatedClassName {
+  private Application application;
+  private ReactNativeHost reactNativeHost;
+  private MainPackageConfig mConfig;
+
+  public $generatedClassName(ReactNativeHost reactNativeHost) {
+    this(reactNativeHost, null);
+  }
+
+  public $generatedClassName(Application application) {
+    this(application, null);
+  }
+
+  public $generatedClassName(ReactNativeHost reactNativeHost, MainPackageConfig config) {
+    this.reactNativeHost = reactNativeHost;
+    mConfig = config;
+  }
+
+  public $generatedClassName(Application application, MainPackageConfig config) {
+    this.reactNativeHost = null;
+    this.application = application;
+    mConfig = config;
+  }
+
+  private ReactNativeHost getReactNativeHost() {
+    return this.reactNativeHost;
+  }
+
+  private Resources getResources() {
+    return this.getApplication().getResources();
+  }
+
+  private Application getApplication() {
+    if (this.reactNativeHost == null) return this.application;
+    return this.reactNativeHost.getApplication();
+  }
+
+  private Context getApplicationContext() {
+    return this.getApplication().getApplicationContext();
+  }
+
+  public ArrayList<ReactPackage> getPackages() {
+    return new ArrayList<>(Arrays.<ReactPackage>asList(
+      new MainReactPackage(mConfig){{ packageClassInstances }}
+    ));
+  }
+}
+"""
+
+class HyperswitchAutolinking {
+  private Logger logger
+  private String packageName
+  private File root
+  private Project rootProject
+  private ArrayList<HashMap<String, String>> reactNativeModules
+  private HashMap<String, ArrayList> reactNativeModulesBuildVariants
+  private static String LOG_PREFIX = ":HyperswitchSDK:"
+
+  HyperswitchAutolinking(Logger logger, File root, Project rootProject) {
+    this.logger = logger
+    this.root = root
+    this.rootProject = rootProject
+    this.packageName = "com.hyperswitchsdkreactnative"
+
+    def (nativeModules, reactNativeModulesBuildVariants) = this.loadAutolinkingData()
+    this.reactNativeModules = nativeModules
+    this.reactNativeModulesBuildVariants = reactNativeModulesBuildVariants
+  }
+
+  /**
+   * Load autolinking data with primary/fallback strategy
+   * Primary: autolinking.json from rootProject build directory
+   * Fallback: React Native CLI (for RN < 0.76)
+   */
+  private ArrayList loadAutolinkingData() {
+    try {
+      return loadFromAutolinkingJson()
+    } catch (Exception e) {
+      this.logger.warn("${LOG_PREFIX}Failed to load autolinking.json: ${e.message}")
+      this.logger.info("${LOG_PREFIX}Falling back to React Native CLI approach")
+      return loadFromReactNativeCli()
+    }
+  }
+
+  /**
+   * Primary: Load from autolinking.json (RN >= 0.76)
+   */
+  private ArrayList loadFromAutolinkingJson() {
+    def autolinkingFile = new File(rootProject.layout.buildDirectory.get().asFile, "generated/autolinking/autolinking.json")
+
+    if (!autolinkingFile.exists()) {
+      throw new FileNotFoundException("autolinking.json not found at: ${autolinkingFile.absolutePath}")
+    }
+
+    this.logger.info("${LOG_PREFIX}Reading autolinking configuration from: ${autolinkingFile.absolutePath}")
+
+    def json = new JsonSlurper().parse(autolinkingFile)
+    def dependencies = json["dependencies"]
+
+    if (!dependencies) {
+      throw new IllegalStateException("No dependencies found in autolinking.json")
+    }
+
+    ArrayList<HashMap<String, String>> reactNativeModules = new ArrayList<HashMap<String, String>>()
+    HashMap<String, ArrayList> reactNativeModulesBuildVariants = new HashMap<String, ArrayList>()
+
+    dependencies.each { name, value ->
+      def platformsConfig = value["platforms"]
+      def androidConfig = platformsConfig["android"]
+
+      if (androidConfig != null && androidConfig["sourceDir"] != null && !androidConfig["isPureCxxDependency"]) {
+        this.logger.info("${LOG_PREFIX}Adding native module '${name}' from autolinking.json")
+
+        HashMap reactNativeModuleConfig = new HashMap<String, String>()
+        def nameCleansed = name.replaceAll('[~*!\'()]+', '_').replaceAll('^@([\\w-.]+)/', '$1_')
+
+        reactNativeModuleConfig.put("name", name)
+        reactNativeModuleConfig.put("nameCleansed", nameCleansed)
+        reactNativeModuleConfig.put("androidSourceDir", androidConfig["sourceDir"])
+        reactNativeModuleConfig.put("packageInstance", androidConfig["packageInstance"])
+        reactNativeModuleConfig.put("packageImportPath", androidConfig["packageImportPath"])
+        reactNativeModuleConfig.put("libraryName", androidConfig["libraryName"])
+        reactNativeModuleConfig.put("componentDescriptors", androidConfig["componentDescriptors"])
+
+        if (androidConfig["buildTypes"] && !androidConfig["buildTypes"].isEmpty()) {
+          reactNativeModulesBuildVariants.put(nameCleansed, androidConfig["buildTypes"])
+        }
+
+        if (androidConfig.containsKey("dependencyConfiguration")) {
+          reactNativeModuleConfig.put("dependencyConfiguration", androidConfig["dependencyConfiguration"])
+        }
+
+        reactNativeModules.add(reactNativeModuleConfig)
+      } else {
+        this.logger.debug("${LOG_PREFIX}Skipping native module '${name}' (no Android config or pure C++)")
+      }
+    }
+
+    this.logger.info("${LOG_PREFIX}Loaded ${reactNativeModules.size()} modules from autolinking.json")
+    return [reactNativeModules, reactNativeModulesBuildVariants]
+  }
+
+  /**
+   * Fallback: Load from React Native CLI (RN < 0.76)
+   */
+  private ArrayList loadFromReactNativeCli() {
+    this.logger.info("${LOG_PREFIX}Using React Native CLI fallback")
+
+    ArrayList<HashMap<String, String>> reactNativeModules = new ArrayList<HashMap<String, String>>()
+    HashMap<String, ArrayList> reactNativeModulesBuildVariants = new HashMap<String, ArrayList>()
+
+    try {
+      def cliResolveScript = "try {console.log(require('@react-native-community/cli').bin);} catch (e) {console.log(require('react-native/cli').bin);}"
+      String[] nodeCommand = ["node", "-e", cliResolveScript]
+      def cliPath = this.getCommandOutput(nodeCommand, this.root)
+
+      String[] reactNativeConfigCommand = ["node", cliPath, "config"]
+      def reactNativeConfigOutput = this.getCommandOutput(reactNativeConfigCommand, this.root)
+
+      def json = new JsonSlurper().parseText(reactNativeConfigOutput)
+      def dependencies = json["dependencies"]
+      def project = json["project"]["android"]
+
+      if (project == null) {
+        throw new Exception("React Native CLI failed to determine Android project configuration")
+      }
+
+      def engine = new SimpleTemplateEngine()
+
+      dependencies.each { name, value ->
+        def platformsConfig = value["platforms"]
+        def androidConfig = platformsConfig["android"]
+
+        if (androidConfig != null && androidConfig["sourceDir"] != null) {
+          this.logger.info("${LOG_PREFIX}Adding native module '${name}' from CLI")
+
+          HashMap reactNativeModuleConfig = new HashMap<String, String>()
+          def nameCleansed = name.replaceAll('[~*!\'()]+', '_').replaceAll('^@([\\w-.]+)/', '$1_')
+
+          reactNativeModuleConfig.put("name", name)
+          reactNativeModuleConfig.put("nameCleansed", nameCleansed)
+          reactNativeModuleConfig.put("androidSourceDir", androidConfig["sourceDir"])
+          reactNativeModuleConfig.put("packageInstance", androidConfig["packageInstance"])
+          reactNativeModuleConfig.put("packageImportPath", androidConfig["packageImportPath"])
+          reactNativeModuleConfig.put("libraryName", androidConfig["libraryName"])
+          reactNativeModuleConfig.put("componentDescriptors", androidConfig["componentDescriptors"])
+
+          if (androidConfig["buildTypes"] && !androidConfig["buildTypes"].isEmpty()) {
+            reactNativeModulesBuildVariants.put(nameCleansed, androidConfig["buildTypes"])
+          }
+
+          if (androidConfig.containsKey("dependencyConfiguration")) {
+            reactNativeModuleConfig.put("dependencyConfiguration", androidConfig["dependencyConfiguration"])
+          } else if (project.containsKey("dependencyConfiguration")) {
+            def bindings = ["dependencyName": nameCleansed]
+            def template = engine.createTemplate(project["dependencyConfiguration"]).make(bindings)
+            reactNativeModuleConfig.put("dependencyConfiguration", template.toString())
+          }
+
+          reactNativeModules.add(reactNativeModuleConfig)
+        }
+      }
+
+      this.logger.info("${LOG_PREFIX}Loaded ${reactNativeModules.size()} modules from React Native CLI")
+      return [reactNativeModules, reactNativeModulesBuildVariants]
+
+    } catch (Exception e) {
+      this.logger.error("${LOG_PREFIX}React Native CLI fallback failed: ${e.message}")
+      throw new Exception("Both autolinking.json and React Native CLI failed. Please ensure React Native is properly configured.")
+    }
+  }
+
+  /**
+   * Add dynamic dependencies to the project
+   */
+  void addReactNativeModuleDependencies(Project project) {
+    this.logger.info("${LOG_PREFIX}Adding ${reactNativeModules.size()} dynamic dependencies")
+
+    reactNativeModules.forEach { reactNativeModule ->
+      def nameCleansed = reactNativeModule["nameCleansed"]
+      def dependencyConfiguration = reactNativeModule["dependencyConfiguration"]
+
+      project.dependencies {
+        if (reactNativeModulesBuildVariants.containsKey(nameCleansed)) {
+          reactNativeModulesBuildVariants
+            .get(nameCleansed)
+            .forEach { buildVariant ->
+              if (dependencyConfiguration != null) {
+                add("${buildVariant}${dependencyConfiguration}", project.project(":${nameCleansed}"))
+              } else {
+                add("${buildVariant}Implementation", project.project(":${nameCleansed}"))
+              }
+            }
+        } else {
+          if(nameCleansed != "juspay-tech_react-native-hyperswitch") {
+            if (dependencyConfiguration != null) {
+              add("${dependencyConfiguration}", project.project(":${nameCleansed}"))
+            } else {
+              implementation project.project(":${nameCleansed}")
+            }
+          }
+        }
+      }
+
+      this.logger.debug("${LOG_PREFIX}Added dependency: ${nameCleansed}")
+    }
+  }
+
+  /**
+   * Generate PackageList.java file
+   */
+  void generatePackagesFile(File outputDir, String generatedFileName, String generatedFileContentsTemplate) {
+    ArrayList<HashMap<String, String>> packages = this.reactNativeModules
+    String packageName = this.packageName
+    String packageImports = ""
+    String packageClassInstances = ""
+
+    if (packages.size() > 0) {
+      def interpolateDynamicValues = { input ->
+        input.replaceAll(~/([^.\w])(BuildConfig|R)([^\w])/) { wholeString, prefix, className, suffix ->
+          "${prefix}${packageName}.${className}${suffix}"
+        }
+      }
+
+      packageImports = packages.collect {
+        "// ${it.name}\n${interpolateDynamicValues(it.packageImportPath)}"
+      }.join('\n')
+
+      packageClassInstances = ",\n      " + packages.collect {
+        interpolateDynamicValues(it.packageInstance)
+      }.join(",\n      ")
+    }
+
+    String generatedFileContents = generatedFileContentsTemplate
+      .replace("{{ packageImports }}", packageImports)
+      .replace("{{ packageClassInstances }}", packageClassInstances)
+
+    outputDir.mkdirs()
+    final FileTreeBuilder treeBuilder = new FileTreeBuilder(outputDir)
+    treeBuilder.file(generatedFileName).newWriter().withWriter { w ->
+      w << generatedFileContents
+    }
+
+    this.logger.info("${LOG_PREFIX}Generated PackageList.java with ${packages.size()} packages")
+  }
+
+  /**
+   * Execute command and return output
+   */
+  private String getCommandOutput(String[] command, File directory) {
+    try {
+      def cmdProcess = Runtime.getRuntime().exec(command, null, directory)
+      def bufferedReader = new BufferedReader(new InputStreamReader(cmdProcess.getInputStream()))
+      def readBuffer = new StringBuffer()
+      def buff = ""
+
+      while ((buff = bufferedReader.readLine()) != null) {
+        readBuffer.append(buff)
+      }
+
+      def output = readBuffer.toString()
+      if (!output) {
+        def bufferedErrorReader = new BufferedReader(new InputStreamReader(cmdProcess.getErrorStream()))
+        def readErrorBuffer = new StringBuffer()
+        def errBuff = ""
+
+        while ((errBuff = bufferedErrorReader.readLine()) != null) {
+          readErrorBuffer.append(errBuff)
+        }
+
+        throw new Exception("Command failed: ${readErrorBuffer.toString()}")
+      }
+
+      return output
+    } catch (Exception exception) {
+      this.logger.error("${LOG_PREFIX}Command execution failed: ${exception.message}")
+      throw exception
+    }
+  }
+}
+
+def projectRoot = rootProject.projectDir
+def hyperswitchAutolinking = new HyperswitchAutolinking(logger, projectRoot, rootProject)
+
+ext.applyHyperswitchAutolinking = { Project project ->
+  // Add dynamic dependencies
+  hyperswitchAutolinking.addReactNativeModuleDependencies(project)
+
+  // Setup generation paths
+  def generatedSrcDir = new File(project.layout.buildDirectory.get().asFile, "generated/source/packagelist")
+  def generatedCodeDir = new File(generatedSrcDir, generatedFilePackage.replace('.', '/'))
+
+  // Create the generation task
+  project.tasks.register('generatePackageList') {
+    group = "hyperswitch"
+    description = "Generates PackageList.java for Hyperswitch SDK"
+
+    outputs.dir(generatedCodeDir)
+    outputs.upToDateWhen { false }
+
+    doLast {
+      hyperswitchAutolinking.generatePackagesFile(generatedCodeDir, "${generatedClassName}.java", generatedFileContentsTemplate)
+    }
+  }
+
+  project.preBuild.dependsOn project.generatePackageList
+
+  project.android {
+    sourceSets {
+      main {
+        java {
+          srcDirs += generatedSrcDir
+        }
+      }
+    }
+  }
+}

package/android/proguard-rules.pro

@@ -0,0 +1,72 @@
+# Hyperswitch SDK ProGuard Rules
+
+# Keep public classes and methods that are part of the SDK API
+-keep public class com.hyperswitchsdkreactnative.** {
+    public *;
+}
+
+# Keep React Native module classes
+-keep class com.hyperswitchsdkreactnative.modules.** { *; }
+-keep class com.hyperswitchsdkreactnative.provider.** { *; }
+-keep class com.hyperswitchsdkreactnative.gpay.** { *; }
+-keep class com.hyperswitchsdkreactnative.utils.** { *; }
+
+# Keep annotation classes
+-keepattributes *Annotation*
+-keepattributes RuntimeVisibleAnnotations
+-keepattributes RuntimeInvisibleAnnotations
+
+# Keep Kotlin metadata
+-keep class kotlin.Metadata { *; }
+-keep class kotlin.jvm.internal.Intrinsics { *; }
+
+# Keep React Native classes
+-keep class com.facebook.react.** { *; }
+-keep class com.facebook.react.bridge.** { *; }
+-keep class com.facebook.react.uimanager.** { *; }
+
+# Keep Google Pay classes
+-keep class com.google.android.gms.wallet.** { *; }
+-keep class com.google.android.gms.common.api.** { *; }
+
+# Keep AndroidX classes that are commonly used
+-keep class androidx.lifecycle.** { *; }
+-keep class androidx.fragment.** { *; }
+-keep class androidx.activity.** { *; }
+
+# Keep enum classes
+-keepclassmembers enum * {
+    public static **[] values();
+    public static ** valueOf(java.lang.String);
+}
+
+# Keep serializable classes
+-keepnames class * implements java.io.Serializable
+-keepclassmembers class * implements java.io.Serializable {
+    static final long serialVersionUID;
+    private static final java.io.ObjectStreamField[] serialPersistentFields;
+    !static !transient <fields>;
+    !private <methods>;
+    private void writeObject(java.io.ObjectOutputStream);
+    private void readObject(java.io.ObjectInputStream);
+    java.lang.Object writeReplace();
+    java.lang.Object readResolve();
+}
+
+# Keep callback methods
+-keepclassmembers class * {
+    @android.webkit.JavascriptInterface <methods>;
+}
+
+# Keep promise-related classes
+-keep class com.facebook.react.bridge.Promise { *; }
+-keep class com.facebook.react.bridge.WritableMap { *; }
+-keep class com.facebook.react.bridge.ReadableMap { *; }
+
+# Optimization settings
+-optimizationpasses 5
+-dontusemixedcaseclassnames
+-dontskipnonpubliclibraryclasses
+-dontpreverify
+-verbose
+-optimizations !code/simplification/arithmetic,!field/*,!class/merging/*

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,25 @@
+<manifest xmlns:tools="http://schemas.android.com/tools"
+  xmlns:android="http://schemas.android.com/apk/res/android">
+  <application android:enableOnBackInvokedCallback="true"
+    tools:targetApi="33">
+    <meta-data android:name="com.google.android.gms.wallet.api.enabled" android:value="true" />
+    <activity android:enableOnBackInvokedCallback="true"
+      tools:targetApi="33" android:name="com.hyperswitchsdkreactnative.gpay.GooglePayActivity" android:exported="false">
+    </activity>
+    <activity
+      android:name=".activity.RedirectActivity"
+      android:exported="true"
+      android:launchMode="singleTask"
+      >
+      <intent-filter android:autoVerify="true">
+        <action android:name="android.intent.action.VIEW" />
+
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.BROWSABLE" />
+
+        <data android:scheme="${applicationId}.hyperswitch" />
+        <data android:host="" tools:ignore="AppLinkUrlError" />
+      </intent-filter>
+    </activity>
+  </application>
+</manifest>