Add sendBinary() to WebSocketClient (#162)

* feat: add sendBinaryDataFor to WebSocketClient for binary frame support

Adds sendBinaryDataFor/sendBinary API across iOS (Starscream write(data:)),
Android (OkHttp ByteString), and TypeScript layers. Data is passed as
base64-encoded string over the bridge and decoded natively before sending.

Needed by mattermost-mobile calls WebSocket to send binary SDP frames
(msgpack-encoded) over a URLSession-backed connection, enabling TLS 1.3
support on iOS (SocketRocket/CFStream is capped at TLS 1.2).

* test: add tests for sendBinary WebSocketClient feature

- TypeScript: WebSocketClient.test.ts verifies sendBinary() delegates to
  NativeWebSocketClient.sendBinaryDataFor() with the correct url and data.
  Adds transformIgnorePatterns to jest config for validator ESM package.
- Kotlin: WebSocketClientModuleImplTest covers the invalid-URL error path
  (URISyntaxException → promise.reject). Happy-path binary send requires
  android.util.Base64 and a live WebSocket, which are only available in
  instrumented (on-device) tests.

* fix linter errors

Author: bgardner8008

android/src/main/java/com/mattermost/networkclient/WebSocketClientModuleImpl.kt

@@ -6,6 +6,7 @@ import com.facebook.react.bridge.ReadableMap
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import java.net.URI
+import java.net.URISyntaxException
 
 class WebSocketClientModuleImpl(reactApplicationContext: ReactApplicationContext) {
     private val clients = mutableMapOf<URI, NetworkClient>()
@@ -138,6 +139,23 @@ class WebSocketClientModuleImpl(reactApplicationContext: ReactApplicationContext
         }
     }
 
+    fun sendBinaryDataFor(wsUrl: String, data: String, promise: Promise) {
+        val wsUri: URI
+        try {
+            wsUri = URI(wsUrl)
+        } catch (error: URISyntaxException) {
+            return promise.reject(error)
+        }
+
+        try {
+            val bytes = android.util.Base64.decode(data, android.util.Base64.DEFAULT)
+            clients[wsUri]!!.webSocket!!.send(okio.ByteString.of(*bytes))
+            promise.resolve(null)
+        } catch (error: Exception) {
+            promise.reject(error)
+        }
+    }
+
     /**
      * Creates an HttpUrl from a URI by replacing the scheme with `http` or `https`
      *

android/src/newarch/java/com/WebSocketClientModule.kt

@@ -71,4 +71,12 @@ internal class WebSocketClientModule(reactContext: ReactApplicationContext) : Na
         implementation.invalidateClientFor(url, promise)
     }
 
+    override fun sendBinaryDataFor(url: String?, data: String?, promise: Promise?) {
+        if (url.isNullOrEmpty() || data.isNullOrEmpty() || promise == null) {
+            promise?.reject(Exception("missing parameter to send binary data"))
+            return
+        }
+        implementation.sendBinaryDataFor(url, data, promise)
+    }
+
 }

android/src/oldarch/java/com/WebSocketClientModule.kt

@@ -46,6 +46,11 @@ internal class WebSocketClientModule(reactContext: ReactApplicationContext) : Re
         implementation.sendDataFor(wsUrl, data, promise)
     }
 
+    @ReactMethod
+    fun sendBinaryDataFor(wsUrl: String, data: String, promise: Promise) {
+        implementation.sendBinaryDataFor(wsUrl, data, promise)
+    }
+
     @ReactMethod
     fun addListener(eventName: String) {
         // Keep: Required for RN built in Event Emitter Calls

android/src/test/java/com/mattermost/networkclient/WebSocketClientModuleImplTest.kt

@@ -0,0 +1,35 @@
+package com.mattermost.networkclient
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import org.junit.Before
+import org.junit.Test
+import org.mockito.ArgumentCaptor
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.verify
+import java.net.URISyntaxException
+
+class WebSocketClientModuleImplTest {
+    private lateinit var impl: WebSocketClientModuleImpl
+    private lateinit var promise: Promise
+
+    @Before
+    fun setUp() {
+        val mockContext = mock(ReactApplicationContext::class.java)
+        impl = WebSocketClientModuleImpl(mockContext)
+        promise = mock(Promise::class.java)
+    }
+
+    // Happy-path binary sends require a live WebSocket connection and android.util.Base64,
+    // which are only available in instrumented (on-device) tests. The base64 encoding and
+    // binary frame delivery are covered end-to-end by the mattermost-mobile test suite.
+
+    @Test
+    fun `sendBinaryDataFor rejects promise for malformed URL`() {
+        impl.sendBinaryDataFor("not a valid uri", "dGVzdA==", promise)
+
+        val captor = ArgumentCaptor.forClass(Throwable::class.java)
+        verify(promise).reject(captor.capture())
+        assert(captor.value is URISyntaxException)
+    }
+}

ios/WebSocket/WebSocketClientImpl.mm

@@ -67,6 +67,10 @@ -(void)stopObserving {
     [wrapper sendDataForUrlString:url data:data resolve:resolve reject:reject];
 }
 
+RCT_EXPORT_METHOD(sendBinaryDataFor:(NSString *)url withData:(NSString *)data withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject) {
+    [wrapper sendBinaryDataForUrlString:url data:data resolve:resolve reject:reject];
+}
+
 RCT_EXPORT_METHOD(invalidateClientFor:(NSString *)url withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject) {
     [wrapper invalidateClientForUrlString:url resolve:resolve reject:reject];
 }
@@ -164,8 +168,12 @@ - (void)invalidateClientFor:(NSString *)url resolve:(RCTPromiseResolveBlock)reso
     [wrapper invalidateClientForUrlString:url resolve:resolve reject:reject];
 }
 
-- (void)sendDataFor:(NSString *)url data:(NSString *)data resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { 
+- (void)sendDataFor:(NSString *)url data:(NSString *)data resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
     [wrapper sendDataForUrlString:url data:data resolve:resolve reject:reject];
 }
 
+- (void)sendBinaryDataFor:(NSString *)url data:(NSString *)data resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+    [wrapper sendBinaryDataForUrlString:url data:data resolve:resolve reject:reject];
+}
+
 @end

ios/WebSocket/WebSocketWrapper.swift

@@ -107,6 +107,28 @@ var READY_STATE = [
         resolve(webSocket.write(string: data))    
     }
 
+    @objc public func sendBinaryDataFor(urlString: String, data: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
+        guard let url = URL(string: urlString) else {
+            rejectMalformed(url: urlString, withRejecter: reject)
+            return
+        }
+
+        guard let webSocket = WebSocketManager.default.getWebSocket(for: url) else {
+            rejectInvalidWebSocket(for: url, withRejecter: reject)
+            return
+        }
+
+        guard let binaryData = Data(base64Encoded: data) else {
+            let err = NSError(domain: NSCocoaErrorDomain, code: NSCoderValueNotFoundError,
+                              userInfo: [NSLocalizedDescriptionKey: "Invalid base64 data"])
+            reject("\(err.code)", "Invalid base64 data", err)
+            return
+        }
+
+        webSocket.write(data: binaryData)
+        resolve(nil)
+    }
+
     @objc public func invalidateClientFor(urlString: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
         guard let url = URL(string: urlString) else {
             rejectMalformed(url: urlString, withRejecter: reject)

package.json

@@ -94,6 +94,9 @@
     "modulePathIgnorePatterns": [
       "<rootDir>/example/node_modules",
       "<rootDir>/lib/"
+    ],
+    "transformIgnorePatterns": [
+      "node_modules/(?!(@react-native|react-native|validator)/)"
     ]
   },
   "commitlint": {

src/WebSocketClient/NativeWebSocketClient.ts

@@ -48,6 +48,7 @@ export interface Spec extends TurboModule {
     connectFor: (url: string) => Promise<void>;
     disconnectFor(url: string): Promise<void>;
     sendDataFor(url: string, data: string): Promise<void>;
+    sendBinaryDataFor(url: string, data: string): Promise<void>;
     invalidateClientFor(url: string): Promise<void>;
 }
 

src/WebSocketClient/__tests__/WebSocketClient.test.ts

@@ -0,0 +1,78 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import { getOrCreateWebSocketClient } from "../index";
+import NativeWebSocketClient from "../NativeWebSocketClient";
+
+const mockNativeClient = NativeWebSocketClient as jest.Mocked<
+    typeof NativeWebSocketClient
+>;
+
+jest.mock("../NativeWebSocketClient", () => ({
+    __esModule: true,
+    default: {
+        addListener: jest.fn(),
+        removeListeners: jest.fn(),
+        ensureClientFor: jest.fn().mockResolvedValue(undefined),
+        connectFor: jest.fn().mockResolvedValue(undefined),
+        disconnectFor: jest.fn().mockResolvedValue(undefined),
+        sendDataFor: jest.fn().mockResolvedValue(undefined),
+        sendBinaryDataFor: jest.fn().mockResolvedValue(undefined),
+        invalidateClientFor: jest.fn().mockResolvedValue(undefined),
+    },
+    WebSocketReadyState: { CONNECTING: 0, OPEN: 1, CLOSING: 2, CLOSED: 3 },
+    WebSocketEvents: {
+        OPEN_EVENT: "WebSocketClient-Open",
+        CLOSE_EVENT: "WebSocketClient-Close",
+        ERROR_EVENT: "WebSocketClient-Error",
+        MESSAGE_EVENT: "WebSocketClient-Message",
+        READY_STATE_EVENT: "WebSocketClient-ReadyState",
+    },
+}));
+
+// Each test uses a unique URL to avoid the module-level CLIENTS singleton state.
+let urlCounter = 0;
+const nextUrl = () =>
+    `ws://mattermost.example.com/api/v4/websocket?t=${++urlCounter}`;
+
+describe("WebSocketClient", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it("should call sendDataFor when send() is invoked", async () => {
+        const url = nextUrl();
+        const { client } = await getOrCreateWebSocketClient(url);
+
+        client.send("hello");
+
+        expect(mockNativeClient.sendDataFor).toHaveBeenCalledWith(url, "hello");
+    });
+
+    it("should call sendBinaryDataFor when sendBinary() is invoked", async () => {
+        const url = nextUrl();
+        const { client } = await getOrCreateWebSocketClient(url);
+        const base64Data = "SGVsbG8gV29ybGQ=";
+
+        client.sendBinary(base64Data);
+
+        expect(mockNativeClient.sendBinaryDataFor).toHaveBeenCalledWith(
+            url,
+            base64Data,
+        );
+    });
+
+    it("should pass the exact url and data to sendBinaryDataFor", async () => {
+        const url = nextUrl();
+        const { client } = await getOrCreateWebSocketClient(url);
+        const encoded = "dGVzdA==";
+
+        client.sendBinary(encoded);
+
+        expect(mockNativeClient.sendBinaryDataFor).toHaveBeenCalledTimes(1);
+        expect(mockNativeClient.sendBinaryDataFor).toHaveBeenCalledWith(
+            url,
+            encoded,
+        );
+    });
+});

src/WebSocketClient/index.tsx

@@ -54,6 +54,8 @@ class WebSocketClient implements WebSocketClientInterface {
         return NativeWebSocketClient.disconnectFor(this.url);
     };
     send = (data: string) => NativeWebSocketClient.sendDataFor(this.url, data);
+    sendBinary = (data: string) =>
+        NativeWebSocketClient.sendBinaryDataFor(this.url, data);
 
     onOpen = (callback: WebSocketEventHandler) => {
         if (this.onWebSocketOpenSubscription) {