wip

Author: grabbou

example/tests/benchmark.tsx

@@ -76,7 +76,7 @@ const TESTS = [
   },
 ]
 
-const BASE_URL = Platform.OS === 'android' ? 'ws://10.0.2.2' : 'ws://localhost'
+export const BASE_URL = Platform.OS === 'android' ? '10.0.2.2' : 'localhost'
 
 export function BenchmarkUI() {
   return (
@@ -278,7 +278,7 @@ async function runSingleTest(opts: TestCase): Promise<TestResult> {
   const { Ws, port, messageCount, testCase, payload } = opts
 
   return new Promise((resolve) => {
-    const ws = new Ws(`${BASE_URL}:${port}`)
+    const ws = new Ws(`ws://${BASE_URL}:${port}`)
     let outgoingTime: number
     let incomingTime: number
     let received = 0

example/tests/filesystem.tsx

@@ -7,6 +7,8 @@ import {
   showOpenFilePicker,
 } from 'react-native-fast-io'
 
+import { BASE_URL } from './benchmark'
+
 export function FileSystemUI() {
   const [file, setFile] = useState<File | null>(null)
 
@@ -24,7 +26,7 @@ export function FileSystemUI() {
 
     const body = compression ? file.stream().pipeThrough(new CompressionStream(compression)) : file
 
-    await fetch('http://localhost:3002/upload', {
+    await fetch(`http://${BASE_URL}:3002/upload`, {
       method: 'POST',
       body,
     })

packages/react-native-fast-io/android/src/main/java/com/margelo/nitro/fastio/HybridDuplexStream.kt

@@ -1,14 +1,24 @@
 package com.margelo.nitro.fastio
 
-class HybridDuplexStream : HybridDuplexStreamSpec() {
-    override var inputStream: HybridInputStreamSpec
-        get() = throw NotImplementedError("HybridDuplexStream.inputStream getter not implemented")
-        set(_) = throw NotImplementedError("HybridDuplexStream.inputStream setter not implemented")
+import java.io.PipedInputStream
+import java.io.PipedOutputStream
 
-    override var outputStream: HybridOutputStreamSpec
-        get() = throw NotImplementedError("HybridDuplexStream.outputStream getter not implemented")
-        set(_) = throw NotImplementedError("HybridDuplexStream.outputStream setter not implemented")
+class HybridDuplexStream : HybridDuplexStreamSpec() {
+    private val pipedInputStream = PipedInputStream(HybridStreamFactory.BUFFER_SIZE)
+    private val pipedOutputStream = PipedOutputStream(pipedInputStream)
 
+    override var inputStream = HybridInputStream(pipedInputStream) as HybridInputStreamSpec
+    override var outputStream = HybridOutputStream(pipedOutputStream) as HybridOutputStreamSpec
+    
     override val memorySize: Long
-        get() = 0L
+        get() = inputStream.memorySize + outputStream.memorySize
+
+    fun close() {
+        try {
+            outputStream.close()
+            inputStream.close()
+        } catch (e: Exception) {
+            println("Error closing duplex stream: ${e.message}")
+        }
+    }
 } 

packages/react-native-fast-io/android/src/main/java/com/margelo/nitro/fastio/HybridNetwork.kt

@@ -1,10 +1,44 @@
 package com.margelo.nitro.fastio
 
+import android.util.Log
 import com.margelo.nitro.core.Promise
+import java.net.HttpURLConnection
+import java.net.URL
 
 class HybridNetwork : HybridNetworkSpec() {
     override fun request(opts: RequestOptions): Promise<Unit> {
-        throw NotImplementedError("HybridNetwork.request() not implemented")
+         return Promise.async {
+             val connection = URL(opts.url).openConnection() as HttpURLConnection
+
+             connection.apply {
+                 requestMethod = opts.method.name.uppercase()
+                 doInput = true
+
+                 opts.body?.let { hybridStream ->
+                     (hybridStream as HybridInputStream).stream.use { input ->
+                         outputStream.use { output ->
+                             val buffer = ByteArray(HybridStreamFactory.BUFFER_SIZE)
+                             var bytesRead: Int
+                            
+                             while (input.read(buffer).also { bytesRead = it } != -1) {
+                                 output.write(buffer, 0, bytesRead)
+                                 output.flush()  // Important: flush each chunk
+                             }
+                         }
+                     }
+                 }
+
+                 connect()
+
+                 if (responseCode in 200..299) {
+                     // tbd
+                 } else {
+                     throw Error("HTTP Error: $responseCode")
+                 }
+             }
+
+             connection.disconnect()
+         }
     }
 
     override val memorySize: Long