tmp

Author: grabbou

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

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

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

@@ -2,29 +2,35 @@ package com.margelo.nitro.fastio
 
 import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 import java.io.InputStream
 
 class HybridInputStream(val stream: InputStream) : HybridInputStreamSpec() {
     override fun read(): Promise<ArrayBuffer> {
         return Promise.async {
-            val bytes = ByteArray(HybridStreamFactory.BUFFER_SIZE)
-            val bytesRead = stream.read(bytes, 0, bytes.size)
+            withContext(Dispatchers.IO) {
+                val bytes = ByteArray(HybridStreamFactory.BUFFER_SIZE)
+                val bytesRead = stream.read(bytes, 0, bytes.size)
 
-            when {
-                bytesRead == -1 -> {
-                    val emptyBuffer = ArrayBuffer.allocate(0)
-                    emptyBuffer
-                }
-                bytesRead > 0 -> {
-                    val arrayBuffer = ArrayBuffer.allocate(bytesRead)
+                when {
+                    bytesRead == -1 -> {
+                        val emptyBuffer = ArrayBuffer.allocate(0)
+                        emptyBuffer
+                    }
 
-                    val destBuffer = arrayBuffer.getBuffer(false)
-                    destBuffer.put(bytes, 0, bytesRead)
+                    bytesRead > 0 -> {
+                        val arrayBuffer = ArrayBuffer.allocate(bytesRead)
 
-                    arrayBuffer
-                }
-                else -> {
-                    throw Error("Unexpected error reading stream")
+                        val destBuffer = arrayBuffer.getBuffer(false)
+                        destBuffer.put(bytes, 0, bytesRead)
+
+                        arrayBuffer
+                    }
+
+                    else -> {
+                        throw Error("Unexpected error reading stream")
+                    }
                 }
             }
         }

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

@@ -3,45 +3,33 @@ package com.margelo.nitro.fastio
 import com.margelo.nitro.core.Promise
 import java.net.HttpURLConnection
 import java.net.URL
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 
 class HybridNetwork : HybridNetworkSpec() {
     override fun request(opts: RequestOptions): Promise<Unit> {
         return Promise.async {
-            val connection = URL(opts.url).openConnection() as HttpURLConnection
+            withContext(Dispatchers.IO) {
+                val connection = URL(opts.url).openConnection() as HttpURLConnection
 
-            try {
                 connection.apply {
                     requestMethod = opts.method.name.uppercase()
                     doInput = true
                     doOutput = opts.body != null
 
-                    connect()
-
-                    opts.body?.let { hybridStream ->
-                        (hybridStream as HybridInputStream).stream.use { input ->
-                            outputStream.buffered().use { output ->
-                                val buffer = ByteArray(HybridStreamFactory.BUFFER_SIZE)
-                                var bytesRead: Int
-                                var totalBytes = 0
-
-                                while (input.read(buffer).also { bytesRead = it } != -1) {
-                                    output.write(buffer, 0, bytesRead)
-                                    output.flush()
-                                    totalBytes += bytesRead
-                                }
-                            }
-                        }
-                    }
+//                    opts.body?.let { hybridStream ->
+//                        (hybridStream as HybridInputStream).stream.use { input ->
+//                            outputStream.buffered().use { output ->
+//                                input.copyTo(output, HybridStreamFactory.BUFFER_SIZE)
+//                            }
+//                        }
+//                    }
 
                     val code = responseCode
-
                     if (code !in 200..299) {
-                        val errorBody = errorStream?.bufferedReader()?.readText() ?: "Unknown error"
-                        throw Error("HTTP Error $code: $errorBody")
+                        throw Error("HTTP Error: $code")
                     }
                 }
-            } finally {
-                connection.disconnect()
             }
         }
     }

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

@@ -2,6 +2,8 @@ package com.margelo.nitro.fastio
 
 import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 import java.io.OutputStream
 
 class HybridOutputStream(private val stream: OutputStream) : HybridOutputStreamSpec() {
@@ -11,7 +13,9 @@ class HybridOutputStream(private val stream: OutputStream) : HybridOutputStreamS
         byteBuffer.get(bytes)
 
         return Promise.async {
-            stream.write(bytes)
+            withContext(Dispatchers.IO) {
+                stream.write(bytes)
+            }
         }
     }