@pigeonmal/react-native-nitro-fetch 0.1.6

package/NitroFetch.podspec

@@ -0,0 +1,30 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroFetch"
+  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 => "http://google.com.git", :tag => "#{s.version}" }
+
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+
+  load 'nitrogen/generated/ios/NitroFetch+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,70 @@
+project(nitrofetch)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME nitrofetch)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/nitrofetch+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+# Allow Gradle to pass a CRONET_ROOT pointing to extracted headers/libs (see build.gradle prepareCronet task)
+if (DEFINED CRONET_ROOT)
+    set(CRONET_ROOT_DIR ${CRONET_ROOT})
+else()
+    set(CRONET_ROOT_DIR ${CMAKE_SOURCE_DIR}/cronet)
+endif()
+
+# Optional: include Cronet headers if present (placed by script under android/cronet/include)
+if (EXISTS ${CRONET_ROOT_DIR}/include)
+    message(STATUS "Cronet headers base: ${CRONET_ROOT_DIR}/include")
+    include_directories(${CRONET_ROOT_DIR}/include)
+    # Some Cronet packages nest headers under include/cronet
+    if (EXISTS ${CRONET_ROOT_DIR}/include/cronet)
+        include_directories(${CRONET_ROOT_DIR}/include/cronet)
+        if (EXISTS ${CRONET_ROOT_DIR}/include/cronet/cronet_c.h)
+            message(STATUS "Found cronet_c.h: ${CRONET_ROOT_DIR}/include/cronet/cronet_c.h")
+        else()
+            message(WARNING "cronet_c.h not found under ${CRONET_ROOT_DIR}/include/cronet")
+        endif()
+        if (EXISTS ${CRONET_ROOT_DIR}/include/cronet/cronet.idl_c.h)
+            message(STATUS "Found cronet.idl_c.h: ${CRONET_ROOT_DIR}/include/cronet/cronet.idl_c.h")
+        else()
+            message(WARNING "cronet.idl_c.h not found under ${CRONET_ROOT_DIR}/include/cronet")
+        endif()
+    else()
+        message(WARNING "Cronet nested include dir not found: ${CRONET_ROOT_DIR}/include/cronet")
+    endif()
+endif()
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)
+
+## Kotlin-based implementation only; no custom C++ headers forced.
+
+# Optional: link Cronet if library file is present (drop-in via prepare script or Gradle task)
+set(CRONET_LIB_DIR ${CRONET_ROOT_DIR}/libs/${ANDROID_ABI})
+if (EXISTS ${CRONET_LIB_DIR})
+    file(GLOB CRONET_LIBS "${CRONET_LIB_DIR}/*cronet*.so")
+    if (CRONET_LIBS)
+        message(STATUS "Linking Cronet from ${CRONET_LIB_DIR}")
+        target_link_libraries(${PACKAGE_NAME} ${CRONET_LIBS})
+        target_compile_definitions(${PACKAGE_NAME} PRIVATE NITROFETCH_LINKS_CRONET=1)
+    else()
+        message(WARNING "Cronet libs not found in ${CRONET_LIB_DIR}")
+    endif()
+endif()

package/android/build.gradle

@@ -0,0 +1,130 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['NitroFetch_' + 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')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/nitrofetch+autolinking.gradle'
+
+// Do not apply React Gradle plugin in library to avoid RN codegen duplicating app classes
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroFetch_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.nitrofetch"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "**/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
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+  // Provide org.chromium.net Java API for CronetEngine in Kotlin
+  // Cronet
+  api "com.google.android.gms:play-services-cronet:18.0.1"
+  implementation("com.squareup.okio:okio:2.9.0")
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
+
+}
+
+configurations {
+  cronetAar
+}
+
+
+// No automatic fetching of Cronet headers/libs; library uses Cronet Java API only.

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroFetch_kotlinVersion=2.0.21
+NitroFetch_minSdkVersion=24
+NitroFetch_targetSdkVersion=34
+NitroFetch_compileSdkVersion=35
+NitroFetch_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/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "nitrofetchOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::nitrofetch::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/nitrofetch/AutoPrefetcher.kt

@@ -0,0 +1,72 @@
+package com.margelo.nitro.nitrofetch
+
+import android.app.Application
+import android.content.Context
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.CompletableFuture
+
+
+object AutoPrefetcher {
+  @Volatile private var initialized = false
+  private const val KEY_QUEUE = "nitrofetch_autoprefetch_queue"
+  private const val PREFS_NAME = "nitro_fetch_storage"
+
+  fun prefetchOnStart(app: Application) {
+    if (initialized) return
+    initialized = true
+    try {
+      val prefs = app.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      val raw = prefs.getString(KEY_QUEUE, null) ?: ""
+      if (raw.isEmpty()) return
+      val arr = JSONArray(raw)
+      for (i in 0 until arr.length()) {
+        val o = arr.optJSONObject(i) ?: continue
+        val url = o.optString("url", null) ?: continue
+        val prefetchKey = o.optString("prefetchKey", null) ?: continue
+        val headersObj = o.optJSONObject("headers") ?: JSONObject()
+        val headersList = mutableListOf<Pair<String, String>>()
+        headersObj.keys().forEachRemaining { k ->
+          headersList.add(k to headersObj.optString(k, ""))
+        }
+        // Ensure prefetchKey header is present
+        headersList.add("prefetchKey" to prefetchKey)
+
+        val headerObjs = headersList.map { (k, v) -> NitroHeader(k, v) }.toTypedArray()
+        val req = NitroRequest(
+          url = url,
+          method = null,
+          headers = headerObjs,
+          bodyString = null,
+          bodyBytes = null,
+          timeoutMs = null,
+          followRedirects = null
+        )
+
+        // If already pending or fresh, skip starting a new one
+        if (FetchCache.getPending(prefetchKey) != null) continue
+        if (FetchCache.hasFreshResult(prefetchKey, 5_000L)) continue
+
+        val future = CompletableFuture<NitroResponse>()
+        FetchCache.setPending(prefetchKey, future)
+        NitroFetchClient.fetch(req,
+          onSuccess = { res ->
+            try {
+              FetchCache.complete(prefetchKey, res)
+              future.complete(res)
+            } catch (t: Throwable) {
+              FetchCache.completeExceptionally(prefetchKey, t)
+              future.completeExceptionally(t)
+            }
+          },
+          onFail = { err ->
+            FetchCache.completeExceptionally(prefetchKey, err)
+            future.completeExceptionally(err)
+          }
+        )
+      }
+    } catch (_: Throwable) {
+      // ignore – prefetch-on-start is best-effort
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrofetch/FetchCache.kt

@@ -0,0 +1,58 @@
+package com.margelo.nitro.nitrofetch
+
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.ConcurrentHashMap
+
+data class CachedEntry(val response: NitroResponse, val timestampMs: Long)
+
+object FetchCache {
+  private val pending = ConcurrentHashMap<String, CompletableFuture<NitroResponse>>()
+  private val results = ConcurrentHashMap<String, CachedEntry>()
+
+  fun getPending(key: String): CompletableFuture<NitroResponse>? = pending[key]
+
+  fun setPending(key: String, future: CompletableFuture<NitroResponse>) {
+    pending[key] = future
+    // Cleanup: remove pending entry when completed
+    future.whenComplete { _, _ ->
+      pending.remove(key)
+    }
+  }
+
+  fun complete(key: String, value: NitroResponse) {
+    results[key] = CachedEntry(value, System.currentTimeMillis())
+    pending[key]?.complete(value)
+    pending.remove(key)
+  }
+
+  fun completeExceptionally(key: String, t: Throwable) {
+    pending[key]?.completeExceptionally(t)
+    pending.remove(key)
+  }
+
+  fun getResult(key: String): NitroResponse? {
+    val entry = results.remove(key) ?: return null
+    return entry.response
+  }
+
+  fun getResultIfFresh(key: String, maxAgeMs: Long): NitroResponse? {
+    val entry = results.remove(key) ?: return null
+    val age = System.currentTimeMillis() - entry.timestampMs
+    return if (age <= maxAgeMs) entry.response else null
+  }
+
+  /**
+   * Check if a fresh result exists WITHOUT consuming it.
+   * Used to check if we should skip starting a new prefetch.
+   */
+  fun hasFreshResult(key: String, maxAgeMs: Long): Boolean {
+    val entry = results[key] ?: return false
+    val age = System.currentTimeMillis() - entry.timestampMs
+    return age <= maxAgeMs
+  }
+
+  fun clear() {
+    pending.clear()
+    results.clear()
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrofetch/NativeStorage.kt

@@ -0,0 +1,102 @@
+package com.margelo.nitro.nitrofetch
+
+import android.app.Application
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Log
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+
+
+
+@DoNotStrip
+class NativeStorage : HybridNativeStorageSpec() {
+
+    companion object {
+        private const val TAG = "HybridNativeStorage"
+        private const val PREFS_NAME = "nitro_fetch_storage"
+
+       
+        private val sharedPreferences: SharedPreferences by lazy {
+            val context = NitroModules.applicationContext ?: throw Error("Cannot get Android Context - No Context available!")
+            context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        }
+
+
+    }
+
+    /**
+     * Retrieves a string value for the given key.
+     *
+     * @param key The key to look up in storage
+     * @return The stored string value, or empty string if key doesn't exist
+     * @throws IllegalStateException if SharedPreferences is not available
+     */
+    override fun getString(key: String): String {
+        return try {
+            val value = sharedPreferences.getString(key, null)
+            if (value != null) {
+                Log.d(TAG, "Retrieved value for key: $key")
+                value
+            } else {
+                Log.d(TAG, "Key not found: $key, returning empty string")
+                ""
+            }
+        } catch (t: Throwable) {
+            Log.e(TAG, "Error getting string for key: $key", t)
+            throw RuntimeException("Failed to get string for key: $key", t)
+        }
+    }
+
+    /**
+     * Stores a string value with the given key.
+     *
+     * @param key The key to store the value under
+     * @param value The string value to store
+     * @throws IllegalStateException if SharedPreferences is not available
+     * @throws RuntimeException if the write operation fails
+     */
+    override fun setString(key: String, value: String) {
+        try {
+            val editor = sharedPreferences.edit()
+            editor.putString(key, value)
+            val success = editor.commit() // commit() is synchronous and returns boolean
+            if (success) {
+                Log.d(TAG, "Successfully stored value for key: $key")
+            } else {
+                Log.e(TAG, "Failed to commit value for key: $key")
+                throw RuntimeException("Failed to store value for key: $key")
+            }
+        } catch (t: Throwable) {
+            Log.e(TAG, "Error setting string for key: $key", t)
+            throw RuntimeException("Failed to set string for key: $key", t)
+        }
+    }
+
+    /**
+     * Deletes the value associated with the given key.
+     * If the key doesn't exist, this is a no-op.
+     *
+     * @param key The key to delete from storage
+     * @throws IllegalStateException if SharedPreferences is not available
+     * @throws RuntimeException if the delete operation fails
+     */
+    override fun removeString(key: String) {
+        try {
+            val editor = sharedPreferences.edit()
+            editor.remove(key)
+            val success = editor.commit() // commit() is synchronous and returns boolean
+            if (success) {
+                Log.d(TAG, "Successfully deleted key: $key")
+            } else {
+                Log.e(TAG, "Failed to commit deletion for key: $key")
+                throw RuntimeException("Failed to delete key: $key")
+            }
+        } catch (t: Throwable) {
+            Log.e(TAG, "Error deleting key: $key", t)
+            throw RuntimeException("Failed to delete key: $key", t)
+        }
+    }
+}
+
+

package/android/src/main/java/com/margelo/nitro/nitrofetch/NitroFetch.kt

@@ -0,0 +1,94 @@
+package com.margelo.nitro.nitrofetch
+
+import android.app.Application
+import android.util.Log
+import com.facebook.proguard.annotations.DoNotStrip
+import org.chromium.net.CronetEngine
+import org.chromium.net.CronetProvider
+import java.io.File
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
+
+@DoNotStrip
+class NitroFetch : HybridNitroFetchSpec() {
+  // Generated base may expect env-less createClient.
+  override fun createClient(): NitroFetchClient {
+    return NitroFetchClient(getEngine(), ioExecutor)
+  }
+
+  companion object {
+    @Volatile private var engineRef: CronetEngine? = null
+
+    // Simpler & safer for callbacks than a pool (avoid reentrancy races in glue code).
+    val ioExecutor: Executor by lazy {
+      val cores = Runtime.getRuntime().availableProcessors().coerceAtLeast(2)
+      Executors.newFixedThreadPool(cores) { r ->
+        Thread(r, "NitroCronet-io").apply {
+          isDaemon = true
+          priority = Thread.NORM_PRIORITY
+        }
+      }
+    }
+
+    fun getEngine(): CronetEngine {
+      engineRef?.let { return it }
+      synchronized(this) {
+        engineRef?.let { return it }
+
+        val app = currentApplication() ?: initialApplication()
+        ?: throw IllegalStateException("NitroFetch: Application not available")
+
+        // Log available providers and prefer the Native one (avoids Play-Services DNS quirks)
+        val providers = CronetProvider.getAllProviders(app)
+        providers.forEach { Log.i("NitroFetch", "Cronet provider: ${it.name} v=${it.version}") }
+        val nativeProvider = providers.firstOrNull { it.name.contains("Native", ignoreCase = true) }
+
+        val cacheDir = File(app.cacheDir, "nitrofetch_cronet_cache").apply { mkdirs() }
+        val builder = (nativeProvider?.createBuilder() ?: CronetEngine.Builder(app))
+          .enableHttp2(true)
+          .enableQuic(true)
+          .enableBrotli(true)
+          .setStoragePath(cacheDir.absolutePath)
+          .enableHttpCache(CronetEngine.Builder.HTTP_CACHE_DISK_NO_HTTP, 10 * 1024 * 1024)
+          .setUserAgent("NitroFetch/0.1")
+
+
+        // --- Optional debugging knobs (uncomment temporarily) ---
+        // Enable NetLog-like tracing in NetworkService:
+        // builder.setExperimentalOptions("""{"NetworkService":{"enable_network_logging":true}}""")
+        //
+        // Prove DNS issues by mapping a host (TESTING ONLY, remove in prod):
+        // builder.setExperimentalOptions("""{"HostResolverRules":{"host_resolver_rules":"MAP httpbin.org 54.167.17.38"}}""")
+
+        val engine = builder.build()
+        Log.i("NitroFetch", "CronetEngine initialized. Provider=${nativeProvider?.name ?: "Default"} Cache=${cacheDir.absolutePath}")
+        engineRef = engine
+        return engine
+      }
+    }
+
+    fun shutdown() {
+      synchronized(this) {
+        try {
+          engineRef?.shutdown()
+        } catch (_: Throwable) {
+          // ignore – shutdown is best-effort
+        } finally {
+          engineRef = null
+        }
+      }
+    }
+
+    private fun currentApplication(): Application? = try {
+      val cls = Class.forName("android.app.ActivityThread")
+      val m = cls.getMethod("currentApplication")
+      m.invoke(null) as? Application
+    } catch (_: Throwable) { null }
+
+    private fun initialApplication(): Application? = try {
+      val cls = Class.forName("android.app.AppGlobals")
+      val m = cls.getMethod("getInitialApplication")
+      m.invoke(null) as? Application
+    } catch (_: Throwable) { null }
+  }
+}