@onekeyfe/react-native-sni-connect 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 Leon
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,37 @@
+# react-native-sni-connect
+
+onekey sni http client
+
+## Installation
+
+
+```sh
+npm install react-native-sni-connect
+```
+
+
+## Usage
+
+
+```js
+import { multiply } from 'react-native-sni-connect';
+
+// ...
+
+const result = multiply(3, 7);
+```
+
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/SniConnect.podspec

@@ -0,0 +1,36 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "SniConnect"
+  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/OneKeyHQ/react-native-sni-connect.git", :tag => "#{s.version}" }
+
+  s.static_framework = true
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}"
+  ]
+
+  s.dependency 'React-Core'
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  s.dependency 'React-Codegen'
+  s.dependency 'EMASCurl', '1.4.1'
+
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/Headers/Private/React-Core\"",
+    "DEFINES_MODULE" => "YES"
+  }
+
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,89 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['SniConnect_' + name]
+  }
+
+  repositories {
+    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["SniConnect_" + name]).toInteger()
+}
+
+android {
+  namespace "com.sniconnect"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  packagingOptions {
+    excludes = [
+      "META-INF",
+      "META-INF/**",
+      "**/libc++_shared.so",
+      "**/libfbjni.so",
+      "**/libjsi.so",
+      "**/libfolly_json.so",
+      "**/libfolly_runtime.so",
+      "**/libglog.so",
+      "**/libhermes.so",
+      "**/libhermes-executor-debug.so",
+      "**/libhermes_executor.so",
+      "**/libreactnative.so",
+      "**/libreactnativejni.so",
+      "**/libturbomodulejsijni.so",
+      "**/libreact_nativemodule_core.so",
+      "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "com.squareup.okhttp3:okhttp:4.12.0"
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+SniConnect_kotlinVersion=2.0.21
+SniConnect_minSdkVersion=24
+SniConnect_targetSdkVersion=34
+SniConnect_compileSdkVersion=35
+SniConnect_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/sniconnect/SniConnectModule.kt

@@ -0,0 +1,346 @@
+package com.sniconnect
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.module.annotations.ReactModule
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.Dns
+import okhttp3.Headers
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import okhttp3.ResponseBody
+import java.io.IOException
+import java.net.InetAddress
+import java.net.UnknownHostException
+import java.util.Locale
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.TimeUnit
+import javax.net.ssl.HttpsURLConnection
+
+private const val TAG = "SniConnect"
+
+@ReactModule(name = SniConnectModule.NAME)
+class SniConnectModule(reactContext: ReactApplicationContext) :
+  NativeSniConnectSpec(reactContext) {
+
+  companion object {
+    const val NAME = "SniConnect"
+    private const val EVENT_NAME = "SniConnectLog"
+  }
+
+  private data class ClientKey(
+    val ip: String,
+    val hostname: String,
+    val timeoutMillis: Long,
+  )
+
+  private val clientCache = ConcurrentHashMap<ClientKey, OkHttpClient>()
+  private val activeCalls = ConcurrentHashMap<String, Call>()
+  private var listenerCount = 0
+
+  override fun getName(): String = NAME
+
+  // Event emitter methods required for NativeEventEmitter
+  @ReactMethod
+  override fun addListener(eventType: String) {
+    listenerCount += 1
+  }
+
+  @ReactMethod
+  override fun removeListeners(count: Double) {
+    listenerCount -= count.toInt()
+    if (listenerCount < 0) {
+      listenerCount = 0
+    }
+  }
+
+  private fun sendLogEvent(level: String, message: String) {
+    if (listenerCount > 0) {
+      val logData = Arguments.createMap().apply {
+        putString("level", level)
+        putString("message", message)
+        putDouble("timestamp", System.currentTimeMillis().toDouble())
+      }
+
+      reactApplicationContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        ?.emit(EVENT_NAME, logData)
+    }
+  }
+
+  override fun request(config: ReadableMap, promise: Promise) {
+    try {
+      val requestConfig = config.toRequestConfig()
+      // Log module initialization
+      sendLogEvent("info", "SniConnect module initialized successfully")
+      performRequest(requestConfig, promise)
+    } catch (error: Exception) {
+      Log.e(TAG, "[SniConnect] Request failed", error)
+      sendLogEvent("error", "Config parsing failed: ${error.message}")
+      promise.reject("SNI_REQUEST_FAILED", error.message, error)
+    }
+  }
+
+  @ReactMethod
+  override fun cancelRequest(requestId: String, promise: Promise) {
+    val call = activeCalls.remove(requestId)
+    if (call != null) {
+      call.cancel()
+      sendLogEvent("info", "Cancelled request: $requestId")
+      promise.resolve(Arguments.createMap().apply {
+        putBoolean("success", true)
+      })
+    } else {
+      sendLogEvent("info", "Request not found: $requestId")
+      promise.resolve(Arguments.createMap().apply {
+        putBoolean("success", false)
+      })
+    }
+  }
+
+  @ReactMethod
+  override fun cancelAllRequests(promise: Promise) {
+    val count = activeCalls.size
+    activeCalls.forEach { (_, call) ->
+      call.cancel()
+    }
+    activeCalls.clear()
+    sendLogEvent("info", "Cancelled $count active requests")
+    promise.resolve(Arguments.createMap().apply {
+      putBoolean("success", true)
+    })
+  }
+
+  @ReactMethod
+  override fun clearDNSCache(promise: Promise) {
+    clientCache.clear()
+    sendLogEvent("info", "DNS cache cleared")
+    promise.resolve(Arguments.createMap().apply {
+      putBoolean("success", true)
+    })
+  }
+
+  private fun performRequest(config: RequestConfig, promise: Promise) {
+    try {
+      val client = getOrCreateClient(config)
+      val request = buildRequest(config)
+      val call = client.newCall(request)
+
+      // Register the call if requestId is provided
+      config.requestId?.let { requestId ->
+        activeCalls[requestId] = call
+        sendLogEvent("info", "Registered request: $requestId, total active: ${activeCalls.size}")
+      }
+
+      call.enqueue(object : Callback {
+        override fun onFailure(call: Call, e: IOException) {
+          // Unregister the call
+          config.requestId?.let { activeCalls.remove(it) }
+
+          if (call.isCanceled()) {
+            sendLogEvent("info", "Request cancelled")
+            promise.reject("SNI_CANCELLED", "Request cancelled", null)
+          } else {
+            Log.e(TAG, "[SniConnect] Request failed", e)
+            sendLogEvent("error", "Request failed: ${e.message}")
+            promise.reject("SNI_REQUEST_FAILED", e.message, e)
+          }
+        }
+
+        override fun onResponse(call: Call, response: Response) {
+          // Unregister the call
+          config.requestId?.let { activeCalls.remove(it) }
+
+          try {
+            response.use {
+              val bodyString = response.body.safeString()
+              val headerMap = headersToMap(response.headers)
+
+              val result: WritableMap = Arguments.createMap().apply {
+                putString("data", bodyString)
+                putInt("status", response.code)
+                putString("statusText", response.message)
+                putMap("headers", headerMap.toWritableMap())
+              }
+
+              promise.resolve(result)
+            }
+          } catch (error: Exception) {
+            Log.e(TAG, "[SniConnect] Response processing failed", error)
+            sendLogEvent("error", "Response processing failed: ${error.message}")
+            promise.reject("SNI_RESPONSE_FAILED", error.message, error)
+          }
+        }
+      })
+    } catch (error: Exception) {
+      Log.e(TAG, "[SniConnect] Request setup failed", error)
+      sendLogEvent("error", "Request setup failed: ${error.message}")
+      promise.reject("SNI_REQUEST_FAILED", error.message, error)
+    }
+  }
+
+  private fun getOrCreateClient(config: RequestConfig): OkHttpClient {
+    val normalizedHost = config.hostname.lowercase(Locale.US)
+    val key = ClientKey(config.ip, normalizedHost, config.timeoutMillis)
+
+    return clientCache.getOrPut(key) {
+      OkHttpClient.Builder()
+        .connectTimeout(config.timeoutMillis, TimeUnit.MILLISECONDS)
+        .readTimeout(config.timeoutMillis, TimeUnit.MILLISECONDS)
+        .writeTimeout(config.timeoutMillis, TimeUnit.MILLISECONDS)
+        .callTimeout(config.timeoutMillis, TimeUnit.MILLISECONDS)
+        .hostnameVerifier { _, session ->
+          HttpsURLConnection.getDefaultHostnameVerifier().verify(config.hostname, session)
+        }
+        .dns(createPinnedDns(config.ip, config.hostname))
+        .build()
+    }
+  }
+
+  private fun createPinnedDns(ip: String, hostname: String): Dns =
+    object : Dns {
+      private val expectedHost = hostname.lowercase(Locale.US)
+
+      override fun lookup(requestedHost: String): List<InetAddress> {
+        return if (requestedHost.lowercase(Locale.US) == expectedHost) {
+          listOf(resolveIp(ip))
+        } else {
+          Dns.SYSTEM.lookup(requestedHost)
+        }
+      }
+    }
+
+  private fun buildRequest(config: RequestConfig): Request {
+    val normalizedPath = if (config.path.startsWith("http")) {
+      config.path
+    } else {
+      val prefix = if (config.path.startsWith("/")) "" else "/"
+      "https://${config.hostname}$prefix${config.path}"
+    }
+
+    val builder = Request.Builder().url(normalizedPath)
+
+    config.headers.forEach { (key, value) ->
+      if (!key.equals("host", ignoreCase = true)) {
+        builder.addHeader(key, value)
+      }
+    }
+    builder.header("Host", config.hostname)
+
+    val method = config.method.uppercase(Locale.US)
+    val bodyContent = config.body ?: ""
+    val mediaType = config.headers.entries
+      .firstOrNull { it.key.equals("Content-Type", ignoreCase = true) }
+      ?.value
+      ?.toMediaTypeOrNull()
+      ?: "application/json; charset=utf-8".toMediaTypeOrNull()
+
+    when (method) {
+      "GET" -> builder.get()
+      "HEAD" -> builder.head()
+      else -> {
+        val requestBody = bodyContent.toRequestBody(mediaType)
+        when (method) {
+          "POST" -> builder.post(requestBody)
+          "PUT" -> builder.put(requestBody)
+          "PATCH" -> builder.patch(requestBody)
+          "DELETE" -> builder.delete(requestBody)
+          else -> builder.method(method, requestBody)
+        }
+      }
+    }
+
+    return builder.build()
+  }
+
+  private fun ResponseBody?.safeString(): String {
+    if (this == null) {
+      return ""
+    }
+    return try {
+      this.string()
+    } catch (error: IOException) {
+      Log.e(TAG, "[SniConnect] Failed to read response body", error)
+      throw IOException("Failed to read response body", error)
+    }
+  }
+
+  private fun headersToMap(headers: Headers): Map<String, String> {
+    val map = mutableMapOf<String, String>()
+    for (name in headers.names()) {
+      map[name] = headers[name] ?: ""
+    }
+    return map
+  }
+
+  private fun resolveIp(ip: String): InetAddress {
+    return try {
+      InetAddress.getByName(ip)
+    } catch (error: UnknownHostException) {
+      throw IOException("Invalid IP address: $ip", error)
+    }
+  }
+
+  private fun Map<String, String>.toWritableMap(): WritableMap {
+    return Arguments.createMap().apply {
+      forEach { (key, value) ->
+        putString(key, value)
+      }
+    }
+  }
+
+  private fun ReadableMap.toRequestConfig(): RequestConfig {
+    val headersMap = if (hasKey("headers") && !isNull("headers")) {
+      val headersReadable = getMap("headers")
+      headersReadable?.toHashMap()
+        ?.mapValues { (_, value) -> value?.toString() ?: "" }
+        ?: emptyMap()
+    } else {
+      emptyMap()
+    }
+
+    val timeoutMillis = if (hasKey("timeout")) {
+      (getDouble("timeout") * 1.0).toLong()
+    } else {
+      30_000L
+    }
+
+    val requestId = if (hasKey("requestId") && !isNull("requestId")) {
+      getString("requestId")
+    } else {
+      null
+    }
+
+    return RequestConfig(
+      requestId = requestId,
+      ip = getString("ip") ?: throw IllegalArgumentException("ip is required"),
+      hostname = getString("hostname") ?: throw IllegalArgumentException("hostname is required"),
+      method = getString("method") ?: "GET",
+      path = getString("path") ?: "/",
+      headers = headersMap,
+      body = if (hasKey("body") && !isNull("body")) getString("body") else null,
+      timeoutMillis = timeoutMillis,
+    )
+  }
+
+  private data class RequestConfig(
+    val requestId: String?,
+    val ip: String,
+    val hostname: String,
+    val method: String,
+    val path: String,
+    val headers: Map<String, String>,
+    val body: String?,
+    val timeoutMillis: Long,
+  )
+}

package/android/src/main/java/com/sniconnect/SniConnectPackage.kt

@@ -0,0 +1,31 @@
+package com.sniconnect
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+class SniConnectPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    if (name == SniConnectModule.NAME) SniConnectModule(reactContext) else null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider {
+      mapOf(
+        SniConnectModule.NAME to ReactModuleInfo(
+          SniConnectModule.NAME,
+          SniConnectModule.NAME,
+          false,
+          false,
+          true,
+          false,
+          true
+        )
+      )
+    }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    emptyList()
+}

package/ios/SniConnect-Bridging-Header.h

@@ -0,0 +1,13 @@
+//
+//  SniConnect-Bridging-Header.h
+//  SniConnect
+//
+//  Used to import Objective-C headers that should be visible to Swift.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <SniConnectSpec/SniConnectSpec.h>
+#endif