feat: implement HybridWebSocket on Android

README.md

@@ -17,7 +17,6 @@ npm install react-native-fast-ws --save
 
 ### TODOs
 
-- Provide Android support
 - Document things not implemented in spec, or different from spec
 - Fix outstanding (and known) issues
 - Figure out a better name and logo

example/App.tsx

@@ -1,5 +1,5 @@
 import { useCallback, useState } from 'react'
-import { ActivityIndicator, Button, StyleSheet, Text, View } from 'react-native'
+import { ActivityIndicator, Button, Platform, StyleSheet, Text, View } from 'react-native'
 import { WebSocket as FastWebSocket } from 'react-native-fast-ws'
 
 type Result = {
@@ -122,7 +122,9 @@ const testWebsocketMessages = async (opts: {
   incomingTime: number
 }> =>
   new Promise((resolve) => {
-    const inst = new opts.Ws('ws://localhost:3000')
+    const inst = new opts.Ws(
+      Platform.OS === 'android' ? 'ws://10.0.2.2:3000' : 'ws://localhost:3000'
+    )
 
     let outgoingTime: number
     let incomingTime: number

packages/react-native-fast-ws/android/build.gradle

@@ -126,6 +126,9 @@ dependencies {
 
   // Add a dependency on NitroModules
   implementation project(":react-native-nitro-modules")
+
+  // Let's use whatever React Native uses right now to avoid duplicates
+  implementation "com.squareup.okhttp3:okhttp:+"
 }
 
 if (isNewArchitectureEnabled()) {

packages/react-native-fast-ws/android/src/main/java/com/margelo/nitro/websocket/HybridWebSocket.kt

@@ -1,49 +1,99 @@
 package com.margelo.nitro.websocket
 
 import com.margelo.nitro.core.ArrayBuffer
+import okhttp3.*
+import okio.ByteString
+import okio.ByteString.Companion.toByteString
+import java.util.concurrent.TimeUnit
 
 class HybridWebSocket(url: String, protocols: Array<String>) : HybridWebSocketSpec() {
-    override fun send(message: String) {
-       TODO("Not implemented")
-    }
+    private var onOpenCallback: ((String) -> Unit)? = null
+    private var onCloseCallback: ((Double, String) -> Unit)? = null
+    private var onErrorCallback: ((String) -> Unit)? = null
+    private var onMessageCallback: ((String) -> Unit)? = null
+    private var onArrayBufferCallback: ((ArrayBuffer) -> Unit)? = null
 
-    override fun sendArrayBuffer(buffer: ArrayBuffer) {
-        TODO("Not implemented")
+    private val client = OkHttpClient.Builder()
+        .readTimeout(0, TimeUnit.MILLISECONDS) // Disable timeouts
+        .build()
+
+    private var webSocket: WebSocket? = null
+
+    private val listener = object : WebSocketListener() {
+        override fun onOpen(webSocket: WebSocket, response: Response) {
+            val protocol = response.header("Sec-WebSocket-Protocol") ?: ""
+            onOpenCallback?.invoke(protocol)
+        }
+
+        override fun onMessage(webSocket: WebSocket, text: String) {
+            onMessageCallback?.invoke(text)
+        }
+
+        override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
+            val buffer = ArrayBuffer.allocate(bytes.size)
+            buffer.getBuffer(false).put(bytes.toByteArray())
+            onArrayBufferCallback?.invoke(buffer)
+        }
+
+        override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
+            onCloseCallback?.invoke(code.toDouble(), reason)
+            webSocket.close(code, reason)
+        }
+
+        override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+            onErrorCallback?.invoke(t.message ?: "WebSocket error")
+        }
     }
 
+    private val request = Request.Builder()
+        .url(url)
+        .apply {
+            if (protocols.isNotEmpty()) {
+                header("Sec-WebSocket-Protocol", protocols.joinToString(", "))
+            }
+        }
+        .build()
+
     override fun connect() {
-        TODO("Not implemented")
+        webSocket = client.newWebSocket(request, listener)
     }
 
     override fun close() {
-        TODO("Not implemented")
+        webSocket?.close(1000, null)
+    }
+
+    override fun send(message: String) {
+        webSocket?.send(message)
+    }
+
+    override fun sendArrayBuffer(buffer: ArrayBuffer) {
+        webSocket?.send(buffer.getBuffer(false).toByteString())
     }
 
     override fun ping() {
-        TODO("Not implemented")
+        webSocket?.send(ByteString.EMPTY)
     }
 
     override fun onOpen(callback: (selectedProtocol: String) -> Unit) {
-        TODO("Not implemented")
+        onOpenCallback = callback
     }
 
     override fun onClose(callback: (code: Double, reason: String) -> Unit) {
-        TODO("Not implemented")
+        onCloseCallback = callback
     }
 
     override fun onError(callback: (error: String) -> Unit) {
-        TODO("Not implemented")
+        onErrorCallback = callback
     }
 
     override fun onMessage(callback: (message: String) -> Unit) {
-        TODO("Not implemented")
+        onMessageCallback = callback
     }
 
     override fun onArrayBuffer(callback: (buffer: ArrayBuffer) -> Unit) {
-        TODO("Not implemented")
+        onArrayBufferCallback = callback
     }
 
     override val memorySize: Long
-        get() = 0L
-
+        get() = 0L // Implement proper memory calculation if needed
 }

packages/react-native-fast-ws/src/index.ts

@@ -7,7 +7,7 @@ import {
 import { NitroModules } from 'react-native-nitro-modules'
 
 import { Blob } from './blob'
-import { WebSocket as HybridWebSocket, WebSocketManager } from './WebSocket.nitro'
+import { WebSocket as HybridWebSocket, WebSocketManager } from './spec.nitro'
 
 const manager = NitroModules.createHybridObject<WebSocketManager>('WebSocketManager')