react-native-nitro-fetch 0.1.7 → 0.2.1

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

@@ -39,8 +39,10 @@ object AutoPrefetcher {
           headers = headerObjs,
           bodyString = null,
           bodyBytes = null,
+          bodyFormData = null,
           timeoutMs = null,
-          followRedirects = null
+          followRedirects = null,
+          requestId = null
         )
 
         // If already pending or fresh, skip starting a new one

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

@@ -0,0 +1,31 @@
+package com.margelo.nitro.nitrofetch
+
+import org.chromium.net.UrlResponseInfo as CronetUrlResponseInfo
+import org.chromium.net.CronetException as CronetNativeException
+
+fun CronetUrlResponseInfo.toNitro(): UrlResponseInfo {
+  val headersMap = mutableMapOf<String, String>()
+  val headersList = mutableListOf<HttpHeader>()
+
+  allHeadersAsList.forEach { header ->
+    headersMap[header.key] = header.value
+    headersList.add(HttpHeader(key = header.key, value = header.value))
+  }
+
+  return UrlResponseInfo(
+    url = url,
+    httpStatusCode = httpStatusCode.toDouble(),
+    httpStatusText = httpStatusText ?: "",
+    allHeaders = headersMap,
+    allHeadersAsList = headersList.toTypedArray(),
+    urlChain = urlChain.toTypedArray(),
+    negotiatedProtocol = negotiatedProtocol,
+    proxyServer = proxyServer,
+    receivedByteCount = receivedByteCount.toDouble(),
+    wasCached = wasCached()
+  )
+}
+
+fun CronetNativeException.toNitro(): RequestException {
+  return RequestException(message = message ?: "Unknown Cronet error")
+}

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

@@ -0,0 +1,89 @@
+package com.margelo.nitro.nitrofetch
+
+import android.app.Application
+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
+
+/**
+ * Streaming-focused Nitro Cronet client.
+ * Manages the Cronet engine and provides URL request building for streaming.
+ */
+@DoNotStrip
+class NitroCronet : HybridNitroCronetSpec() {
+
+  override fun newUrlRequestBuilder(url: String): HybridUrlRequestBuilderSpec {
+    return NitroUrlRequestBuilder(
+      engine = getOrCreateCronetEngine(),
+      url = url,
+      executor = ioExecutor
+    )
+  }
+
+  companion object {
+    @Volatile
+    private var engineRef: CronetEngine? = null
+
+    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 getOrCreateCronetEngine(): CronetEngine {
+      engineRef?.let { return it }
+      synchronized(this) {
+        engineRef?.let { return it }
+
+        val app = currentApplication() ?: initialApplication()
+          ?: throw IllegalStateException("NitroCronet: Application not available")
+
+        val providers = CronetProvider.getAllProviders(app)
+
+        val nativeProvider = providers.firstOrNull {
+          it.name.contains("Native", ignoreCase = true)
+        }
+
+        val cacheDir = File(app.cacheDir, "nitro_cronet_cache").apply { mkdirs() }
+        val builder = (nativeProvider?.createBuilder() ?: CronetEngine.Builder(app))
+          .enableHttp2(true)
+          .enableQuic(true)
+          .enableBrotli(true)
+          .setStoragePath(cacheDir.absolutePath)
+          .setUserAgent("NitroCronet/1.0")
+
+        builder.enableHttpCache(
+          CronetEngine.Builder.HTTP_CACHE_DISK,
+          (50 * 1024 * 1024).toLong()
+        )
+
+        val engine = builder.build()
+        engineRef = engine
+        return engine
+      }
+    }
+
+    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
+    }
+  }
+}

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

@@ -1,14 +1,20 @@
 package com.margelo.nitro.nitrofetch
 
+import android.net.Uri
 import android.util.Log
 import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.Promise
 import org.chromium.net.CronetEngine
 import org.chromium.net.CronetException
 import org.chromium.net.UrlRequest
 import org.chromium.net.UrlResponseInfo
+import java.io.ByteArrayOutputStream
+import java.io.File
 import java.nio.ByteBuffer
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.Executor
 
 fun ByteBuffer.toByteArray(): ByteArray {
@@ -22,6 +28,13 @@ fun ByteBuffer.toByteArray(): ByteArray {
 
 @DoNotStrip
 class NitroFetchClient(private val engine: CronetEngine, private val executor: Executor) : HybridNitroFetchClientSpec() {
+  
+  private val activeRequests = ConcurrentHashMap<String, UrlRequest>()
+
+  override fun cancelRequest(requestId: String) {
+    // https://developer.android.com/develop/connectivity/cronet/reference/org/chromium/net/UrlRequest#cancel() 
+    activeRequests.remove(requestId)?.cancel()
+  }
 
   private fun findPrefetchKey(req: NitroRequest): String? {
     val h = req.headers ?: return null
@@ -39,13 +52,14 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       req: NitroRequest,
       onSuccess: (NitroResponse) -> Unit,
       onFail: (Throwable) -> Unit
-    ) {
-      try {
+    ): UrlRequest? {
+      return try {
         val engine = NitroFetch.getEngine()
         val executor = NitroFetch.ioExecutor
         startCronet(engine, executor, req, onSuccess, onFail)
       } catch (t: Throwable) {
         onFail(t)
+        null
       }
     }
 
@@ -55,7 +69,7 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       req: NitroRequest,
       onSuccess: (NitroResponse) -> Unit,
       onFail: (Throwable) -> Unit
-    ) {
+    ): UrlRequest {
       val url = req.url
       val callback = object : UrlRequest.Callback() {
         private val buffer = ByteBuffer.allocateDirect(16 * 1024)
@@ -125,33 +139,94 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       val method = req.method?.name ?: "GET"
       builder.setHttpMethod(method)
       req.headers?.forEach { (k, v) -> builder.addHeader(k, v) }
-      val bodyBytes = req.bodyBytes
-      val bodyStr = req.bodyString
-      if ((bodyBytes != null) || !bodyStr.isNullOrEmpty()) {
-        val body: ByteArray = when {
-          bodyBytes != null -> ByteArray(1);//bodyBytes.getBuffer(true).toByteArray()
-          !bodyStr.isNullOrEmpty() -> bodyStr!!.toByteArray(Charsets.UTF_8)
-          else -> ByteArray(0)
-        }
-        val provider = object : org.chromium.net.UploadDataProvider() {
-          private var pos = 0
-          override fun getLength(): Long = body.size.toLong()
-          override fun read(uploadDataSink: org.chromium.net.UploadDataSink, byteBuffer: ByteBuffer) {
-            val remaining = body.size - pos
-            val toWrite = minOf(byteBuffer.remaining(), remaining)
-            byteBuffer.put(body, pos, toWrite)
-            pos += toWrite
-            uploadDataSink.onReadSucceeded(false)
-          }
-          override fun rewind(uploadDataSink: org.chromium.net.UploadDataSink) {
-            pos = 0
-            uploadDataSink.onRewindSucceeded()
+
+      val formParts = req.bodyFormData
+      if (formParts != null && formParts.isNotEmpty()) {
+        val (multipartBody, contentType) = buildMultipartBody(formParts)
+        builder.addHeader("Content-Type", contentType)
+        val provider = createUploadProvider(multipartBody)
+        builder.setUploadDataProvider(provider, executor)
+      } else {
+        val bodyBytes = req.bodyBytes
+        val bodyStr = req.bodyString
+        if ((bodyBytes != null) || !bodyStr.isNullOrEmpty()) {
+          val body: ByteArray = when {
+            bodyBytes != null -> ByteArray(1)
+            !bodyStr.isNullOrEmpty() -> bodyStr!!.toByteArray(Charsets.UTF_8)
+            else -> ByteArray(0)
           }
+          val provider = createUploadProvider(body)
+          builder.setUploadDataProvider(provider, executor)
         }
-        builder.setUploadDataProvider(provider, executor)
       }
+
       val request = builder.build()
       request.start()
+      return request
+    }
+
+    private fun createUploadProvider(body: ByteArray): org.chromium.net.UploadDataProvider {
+      return object : org.chromium.net.UploadDataProvider() {
+        private var pos = 0
+        override fun getLength(): Long = body.size.toLong()
+        override fun read(uploadDataSink: org.chromium.net.UploadDataSink, byteBuffer: ByteBuffer) {
+          val remaining = body.size - pos
+          val toWrite = minOf(byteBuffer.remaining(), remaining)
+          byteBuffer.put(body, pos, toWrite)
+          pos += toWrite
+          uploadDataSink.onReadSucceeded(false)
+        }
+        override fun rewind(uploadDataSink: org.chromium.net.UploadDataSink) {
+          pos = 0
+          uploadDataSink.onRewindSucceeded()
+        }
+      }
+    }
+
+    private fun buildMultipartBody(parts: Array<NitroFormDataPart>): Pair<ByteArray, String> {
+      val boundary = "NitroFetch-${UUID.randomUUID()}"
+      val out = ByteArrayOutputStream()
+      val crlf = "\r\n".toByteArray()
+
+      for (part in parts) {
+        out.write("--$boundary\r\n".toByteArray())
+
+        val fileUri = part.fileUri
+        if (fileUri != null) {
+          val fileName = part.fileName ?: "file"
+          val mimeType = part.mimeType ?: "application/octet-stream"
+          out.write("Content-Disposition: form-data; name=\"${part.name}\"; filename=\"$fileName\"\r\n".toByteArray())
+          out.write("Content-Type: $mimeType\r\n\r\n".toByteArray())
+
+          val fileData = readFileBytes(fileUri)
+          out.write(fileData)
+        } else {
+          val value = part.value ?: ""
+          out.write("Content-Disposition: form-data; name=\"${part.name}\"\r\n\r\n".toByteArray())
+          out.write(value.toByteArray(Charsets.UTF_8))
+        }
+
+        out.write(crlf)
+      }
+
+      out.write("--$boundary--\r\n".toByteArray())
+      return Pair(out.toByteArray(), "multipart/form-data; boundary=$boundary")
+    }
+
+    private fun readFileBytes(uri: String): ByteArray {
+      if (uri.startsWith("http://") || uri.startsWith("https://")) {
+        val url = java.net.URL(uri)
+        return url.openStream().use { it.readBytes() }
+      }
+      if (uri.startsWith("content://")) {
+        val context = NitroModules.applicationContext
+          ?: throw IllegalStateException("Cannot read content:// URI - no Android Context")
+        val inputStream = context.contentResolver.openInputStream(Uri.parse(uri))
+          ?: throw IllegalArgumentException("Cannot open content URI: $uri")
+        return inputStream.use { it.readBytes() }
+      }
+      val path = if (uri.startsWith("file://")) uri.removePrefix("file://") else uri
+      return File(path).readBytes()
     }
   }
 
@@ -229,11 +304,23 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
         return promise
       }
     }
-    fetch(
+    val requestId = req.requestId
+    val urlRequest = fetch(
       req,
-      onSuccess = { promise.resolve(it) },
-      onFail = { promise.reject(it) }
+      onSuccess = { res ->
+        if (requestId != null) activeRequests.remove(requestId)
+        promise.resolve(res)
+      },
+      onFail = { err ->
+        if (requestId != null) activeRequests.remove(requestId)
+        promise.reject(err)
+      }
     )
+    // Store after start() — if cancelRequest races and misses, the JS
+    // catch block checks signal.aborted and throws AbortError anyway.
+    if (requestId != null && urlRequest != null) {
+      activeRequests[requestId] = urlRequest
+    }
     return promise
   }
 

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

@@ -0,0 +1,35 @@
+package com.margelo.nitro.nitrofetch
+
+import com.facebook.proguard.annotations.DoNotStrip
+import org.chromium.net.UrlRequest as CronetUrlRequest
+import java.nio.ByteBuffer
+
+@DoNotStrip
+class NitroUrlRequest(
+  private val cronetRequest: CronetUrlRequest,
+  private val byteBuffer: ByteBuffer
+) : HybridUrlRequestSpec() {
+
+  override fun start() {
+    cronetRequest.start()
+  }
+
+  override fun followRedirect() {
+    cronetRequest.followRedirect()
+  }
+
+  override fun read() {
+    // Prepare buffer for writing (position=0, limit=capacity)
+    byteBuffer.clear()
+    // Pass to Cronet to fill
+    cronetRequest.read(byteBuffer)
+  }
+
+  override fun cancel() {
+    cronetRequest.cancel()
+  }
+
+  override fun isDone(): Boolean {
+    return cronetRequest.isDone
+  }
+}

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

@@ -0,0 +1,181 @@
+package com.margelo.nitro.nitrofetch
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
+import org.chromium.net.CronetEngine
+import org.chromium.net.UrlRequest as CronetUrlRequest
+import org.chromium.net.UrlResponseInfo as CronetUrlResponseInfo
+import org.chromium.net.CronetException as CronetNativeException
+import java.nio.ByteBuffer
+import java.util.concurrent.Executor as JavaExecutor
+
+@DoNotStrip
+class NitroUrlRequestBuilder(
+  private val engine: CronetEngine,
+  private val url: String,
+  private val executor: JavaExecutor
+) : HybridUrlRequestBuilderSpec() {
+
+  // Callbacks stored as optionals and set via setter methods
+  private var onRedirectReceivedCallback: ((info: UrlResponseInfo, newLocationUrl: String) -> Unit)? = null
+  private var onResponseStartedCallback: ((info: UrlResponseInfo) -> Unit)? = null
+  private var onReadCompletedCallback: ((info: UrlResponseInfo, byteBuffer: ArrayBuffer, bytesRead: Double) -> Unit)? = null
+  private var onSucceededCallback: ((info: UrlResponseInfo) -> Unit)? = null
+  private var onFailedCallback: ((info: UrlResponseInfo?, error: RequestException) -> Unit)? = null
+  private var onCanceledCallback: ((info: UrlResponseInfo?) -> Unit)? = null
+
+  private val builder: CronetUrlRequest.Builder
+  private val byteBuffer: ByteBuffer
+
+  init {
+    // Allocate ONE reusable owning buffer for all reads (64KB)
+    val reusableBuffer = ArrayBuffer.allocate(65536)
+    byteBuffer = reusableBuffer.getBuffer(false)
+
+    val cronetCallback = object : CronetUrlRequest.Callback() {
+
+      override fun onRedirectReceived(
+        request: CronetUrlRequest,
+        info: CronetUrlResponseInfo,
+        newLocationUrl: String
+      ) {
+        onRedirectReceivedCallback?.let { callback ->
+          val nitroInfo = info.toNitro()
+          callback(nitroInfo, newLocationUrl)
+        }
+      }
+
+      override fun onResponseStarted(
+        request: CronetUrlRequest,
+        info: CronetUrlResponseInfo
+      ) {
+        onResponseStartedCallback?.let { callback ->
+          val nitroInfo = info.toNitro()
+          callback(nitroInfo)
+        }
+      }
+
+      override fun onReadCompleted(
+        request: CronetUrlRequest,
+        info: CronetUrlResponseInfo,
+        receivedBuffer: ByteBuffer
+      ) {
+        onReadCompletedCallback?.let { callback ->
+          val bytesRead = receivedBuffer.position()
+          val nitroInfo = info.toNitro()
+          callback(nitroInfo, reusableBuffer, bytesRead.toDouble())
+        }
+      }
+
+      override fun onSucceeded(
+        request: CronetUrlRequest,
+        info: CronetUrlResponseInfo
+      ) {
+        onSucceededCallback?.let { callback ->
+          val nitroInfo = info.toNitro()
+          callback(nitroInfo)
+        }
+      }
+
+      override fun onFailed(
+        request: CronetUrlRequest,
+        info: CronetUrlResponseInfo?,
+        error: CronetNativeException
+      ) {
+        onFailedCallback?.let { callback ->
+          val nitroInfo = info?.toNitro()
+          val nitroError = error.toNitro()
+          callback(nitroInfo, nitroError)
+        }
+      }
+
+      override fun onCanceled(
+        request: CronetUrlRequest,
+        info: CronetUrlResponseInfo?
+      ) {
+        onCanceledCallback?.let { callback ->
+          val nitroInfo = info?.toNitro()
+          callback(nitroInfo)
+        }
+      }
+    }
+
+    builder = engine.newUrlRequestBuilder(url, cronetCallback, executor)
+  }
+
+  override fun setHttpMethod(httpMethod: String) {
+    builder.setHttpMethod(httpMethod)
+  }
+
+  override fun addHeader(name: String, value: String) {
+    builder.addHeader(name, value)  
+  }
+
+  override fun setUploadBody(body: Variant_ArrayBuffer_String) {
+    val bodyBytes: ByteArray = when (body) {
+      is Variant_ArrayBuffer_String.First -> {
+        val buffer = body.value.getBuffer(true)
+        val bytes = ByteArray(buffer.remaining())
+        buffer.get(bytes)
+        bytes
+      }
+      is Variant_ArrayBuffer_String.Second -> body.value.toByteArray(Charsets.UTF_8)
+    }
+
+    val provider = object : org.chromium.net.UploadDataProvider() {
+      private var position = 0
+
+      override fun getLength(): Long = bodyBytes.size.toLong()
+
+      override fun read(uploadDataSink: org.chromium.net.UploadDataSink, byteBuffer: ByteBuffer) {
+        val remaining = bodyBytes.size - position
+        val toWrite = minOf(byteBuffer.remaining(), remaining)
+        if (toWrite > 0) {
+          byteBuffer.put(bodyBytes, position, toWrite)
+          position += toWrite
+        }
+        uploadDataSink.onReadSucceeded(false)
+      }
+
+      override fun rewind(uploadDataSink: org.chromium.net.UploadDataSink) {
+        position = 0
+        uploadDataSink.onRewindSucceeded()
+      }
+    }
+
+    builder.setUploadDataProvider(provider, executor)
+  }
+
+  override fun disableCache() {
+    builder.disableCache()
+  }
+
+  override fun onSucceeded(callback: (info: UrlResponseInfo) -> Unit) {
+    this.onSucceededCallback = callback
+  }
+
+  override fun onFailed(callback: (info: UrlResponseInfo?, error: RequestException) -> Unit) {
+    this.onFailedCallback = callback
+  }
+
+  override fun onCanceled(callback: (info: UrlResponseInfo?) -> Unit) {
+    this.onCanceledCallback = callback
+  }
+
+  override fun onRedirectReceived(callback: (info: UrlResponseInfo, newLocationUrl: String) -> Unit) {
+    this.onRedirectReceivedCallback = callback
+  }
+
+  override fun onResponseStarted(callback: (info: UrlResponseInfo) -> Unit) {
+    this.onResponseStartedCallback = callback
+  }
+
+  override fun onReadCompleted(callback: (info: UrlResponseInfo, byteBuffer: ArrayBuffer, bytesRead: Double) -> Unit) {
+    this.onReadCompletedCallback = callback
+  }
+
+  override fun build(): HybridUrlRequestSpec {
+    val cronetRequest = builder.build()
+    return NitroUrlRequest(cronetRequest, byteBuffer)
+  }
+}

package/ios/HybridNitroCronet.swift

@@ -0,0 +1,31 @@
+import Foundation
+import NitroModules
+
+class HybridNitroCronet: HybridNitroCronetSpec {
+  // Shared URLSession for all streaming requests
+  private static let session: URLSession = {
+    let config = URLSessionConfiguration.default
+    config.requestCachePolicy = .useProtocolCachePolicy
+    config.urlCache = URLCache(
+      memoryCapacity: 32 * 1024 * 1024,
+      diskCapacity: 100 * 1024 * 1024,
+      diskPath: "nitrofetch_urlcache"
+    )
+    return URLSession(configuration: config)
+  }()
+
+  // Shared executor queue
+  private static let executorQueue = DispatchQueue(
+    label: "com.nitrofetch.executor",
+    qos: .userInitiated,
+    attributes: .concurrent
+  )
+
+  func newUrlRequestBuilder(url: String) throws -> any HybridUrlRequestBuilderSpec {
+    return HybridUrlRequestBuilder(
+      url: url,
+      session: HybridNitroCronet.session,
+      executor: HybridNitroCronet.executorQueue
+    )
+  }
+}

package/ios/HybridUrlRequest.swift

@@ -0,0 +1,41 @@
+import Foundation
+import NitroModules
+
+class HybridUrlRequest: HybridUrlRequestSpec {
+  private weak var task: URLSessionDataTask?
+  private weak var delegate: URLSessionDelegate?
+  private var isDoneFlag = false
+
+  init(task: URLSessionDataTask, delegate: URLSessionDelegate) {
+    self.task = task
+    self.delegate = delegate
+    super.init()
+  }
+
+  func start() throws {
+    task?.resume()
+  }
+
+  func followRedirect() throws {
+    // Redirects are handled automatically by URLSession
+    // This is a no-op on iOS but required for API compatibility
+  }
+
+  func read() throws {
+    // Reading is handled automatically by URLSession delegate
+    // This is a no-op on iOS but required for API compatibility
+  }
+
+  func cancel() throws {
+    task?.cancel()
+    isDoneFlag = true
+  }
+
+  func isDone() throws -> Bool {
+    return isDoneFlag
+  }
+
+  func markDone() {
+    isDoneFlag = true
+  }
+}