react-native-tcp-windows 0.2.0

package/package.json

@@ -0,0 +1,204 @@
+{
+  "name": "react-native-tcp-windows",
+  "version": "0.2.0",
+  "description": "TCP sockets communication for RNW",
+  "source": "./src/index.tsx",
+  "main": "./lib/commonjs/index.js",
+  "module": "./lib/module/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/typescript/module/src/index.d.ts",
+        "default": "./lib/module/index.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/src/index.d.ts",
+        "default": "./lib/commonjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "cpp",
+    "react-native.config.js",
+    "windows"
+  ],
+  "scripts": {
+    "example": "yarn workspace react-native-tcp-windows-example",
+    "test": "jest",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "codegen": "react-native codegen-windows",
+    "release": "release-it"
+  },
+  "keywords": [
+    "react-native",
+    "react-native-windows",
+    "tcp"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/KGGrande/react-native-tcp-windows.git"
+  },
+  "author": "Kyle Grande <KGGrande@hormel.com> (https://github.com/KGGrande)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/KGGrande/react-native-tcp-windows/issues"
+  },
+  "homepage": "https://github.com/KGGrande/react-native-tcp-windows#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.6.0",
+    "@evilmartians/lefthook": "^1.5.0",
+    "@react-native-community/cli": "18.0.0",
+    "@react-native/eslint-config": "^0.73.1",
+    "@release-it/conventional-changelog": "^9.0.2",
+    "@types/jest": "^29.5.5",
+    "@types/react": "^19.0.0",
+    "commitlint": "^19.6.1",
+    "del-cli": "^5.1.0",
+    "eslint": "^8.51.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "^5.0.1",
+    "jest": "^29.7.0",
+    "prettier": "^3.0.3",
+    "react": "19.0.0",
+    "react-native": "0.79.0",
+    "react-native-builder-bob": "^0.38.3",
+    "react-native-windows": "0.79.0",
+    "release-it": "^17.10.0",
+    "turbo": "^1.10.7",
+    "typescript": "^5.2.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-windows": "*"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@3.6.1",
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "eslintConfig": {
+    "root": true,
+    "extends": [
+      "@react-native",
+      "prettier"
+    ],
+    "rules": {
+      "react/react-in-jsx-scope": "off",
+      "prettier/prettier": [
+        "error",
+        {
+          "quoteProps": "consistent",
+          "singleQuote": true,
+          "tabWidth": 2,
+          "trailingComma": "es5",
+          "useTabs": false
+        }
+      ]
+    }
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/"
+  ],
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "commonjs",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "ReactNativeTcpWindowsSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "outputDir": {
+      "ios": "ios/generated",
+      "android": "android/generated"
+    },
+    "android": {
+      "javaPackageName": "com.tcpwindows"
+    },
+    "includesGeneratedCode": true,
+    "windows": {
+      "namespace": "ReactNativeTcpWindowsCodegen",
+      "outputDirectory": "windows/ReactNativeTcpWindows/codegen",
+      "separateDataTypes": false
+    }
+  },
+  "create-react-native-library": {
+    "type": "turbo-module",
+    "languages": "kotlin-objc",
+    "version": "0.48.9"
+  },
+  "react-native-windows": {
+    "init-windows": {
+      "name": "ReactNativeTcpWindows",
+      "namespace": "ReactNativeTcpWindows",
+      "template": "cpp-lib"
+    }
+  }
+}

package/react-native.config.js

@@ -0,0 +1,12 @@
+/**
+ * @type {import('@react-native-community/cli-types').UserDependencyConfig}
+ */
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        cmakeListsPath: 'generated/jni/CMakeLists.txt',
+      },
+    },
+  },
+};

package/src/ReactNativeTcpWindows.ts

@@ -0,0 +1,14 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  connectToServer(address: string, port: number): Promise<string>;
+  startServer(port: number): Promise<string>;
+  closeConnection(): Promise<string>;
+  write(data: Array<number>): Promise<boolean>;
+  getConnectionStatus(): Promise<boolean>;
+  addListener(eventType: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('ReactNativeTcpWindows');

package/src/__tests__/index.test.tsx

@@ -0,0 +1 @@
+it.todo('write a test');

package/src/index.tsx

@@ -0,0 +1,124 @@
+import { NativeEventEmitter } from 'react-native';
+import TcpSocketWindows from './ReactNativeTcpWindows';
+
+export const eventEmitter = new NativeEventEmitter(TcpSocketWindows);
+export { TcpSocketWindows };
+// Event types for better type safety
+export const TCP_SOCKET_EVENTS = {
+  DATA_RECEIVED: 'TcpSocketDataReceived',
+  CLIENT_CONNECTED: 'TcpSocketClientConnected',
+  CLIENT_DISCONNECTED: 'TcpSocketClientDisconnected',
+  CONNECTION_STATUS_CHANGED: 'TcpSocketConnectionStatusChanged',
+} as const;
+
+export type TcpSocketEvent =
+  (typeof TCP_SOCKET_EVENTS)[keyof typeof TCP_SOCKET_EVENTS];
+
+// Event data interfaces
+export interface DataReceivedEvent {
+  data: number[];
+}
+
+export interface ClientConnectedEvent {
+  clientAddress: string;
+}
+
+export interface ClientDisconnectedEvent {
+  clientAddress: string;
+}
+
+export interface ConnectionStatusChangedEvent {
+  connected: boolean;
+  message: string;
+}
+
+/**
+ * Connect to a TCP server as a client
+ * @param address Server IP address (e.g., "192.168.1.100")
+ * @param port Server port number
+ * @returns Promise that resolves with success message
+ */
+export function connectToServer(
+  address: string,
+  port: number
+): Promise<string> {
+  return TcpSocketWindows.connectToServer(address, port);
+}
+
+/**
+ * Start a TCP server to accept client connections
+ * @param port Port number to listen on
+ * @returns Promise that resolves with success message
+ */
+export function startServer(port: number): Promise<string> {
+  return TcpSocketWindows.startServer(port);
+}
+
+/**
+ * Close the current connection (client or server)
+ * @returns Promise that resolves with success message
+ */
+export function closeConnection(): Promise<string> {
+  return TcpSocketWindows.closeConnection();
+}
+
+/**
+ * Write data to the TCP connection
+ * For clients: sends to the connected server
+ * For servers: sends to all connected clients
+ * @param data Array of bytes to send (0-255)
+ * @returns Promise that resolves with success status
+ */
+export function write(data: number[]): Promise<boolean> {
+  return TcpSocketWindows.write(data);
+}
+
+/**
+ * Get the current connection status
+ * @returns Promise that resolves with connection status object
+ */
+export function getConnectionStatus(): Promise<boolean> {
+  return TcpSocketWindows.getConnectionStatus();
+}
+
+/**
+ * Write a string as UTF-8 bytes
+ * @param text String to send
+ * @returns Promise that resolves with success status
+ */
+export function writeString(text: string): Promise<boolean> {
+  const encoder = new TextEncoder();
+  const bytes = Array.from(encoder.encode(text));
+  return write(bytes);
+}
+
+/**
+ * Write JSON data as UTF-8 bytes
+ * @param data Object to serialize and send
+ * @returns Promise that resolves with success status
+ */
+export function writeJson(data: any): Promise<boolean> {
+  const jsonString = JSON.stringify(data);
+  return writeString(jsonString);
+}
+
+/**
+ * Convenience function to convert received byte array to string
+ * @param data Byte array from DataReceivedEvent
+ * @returns Decoded UTF-8 string
+ */
+export function bytesToString(data: number[]): string {
+  const uint8Array = new Uint8Array(data);
+  const decoder = new TextDecoder();
+  return decoder.decode(uint8Array);
+}
+
+/**
+ * Convenience function to convert received byte array to JSON
+ * @param data Byte array from DataReceivedEvent
+ * @returns Parsed JSON object
+ */
+export function bytesToJson(data: number[]): any {
+  const jsonString = bytesToString(data);
+  return JSON.parse(jsonString);
+}

package/windows/ExperimentalFeatures.props

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <PropertyGroup Label="Microsoft.ReactNative Experimental Features">
+    <!--
+      Required for building a New Architecture project.
+
+      Library projects can change this value to test against Old and New
+      Architectures when building the library project's local sln file.
+      
+      Otherwise this value will be decided by the consuming RNW app.
+
+      See https://microsoft.github.io/react-native-windows/docs/new-architecture
+    -->
+    <RnwNewArch>true</RnwNewArch>
+
+    <!--
+      Changes compilation to assume use of Microsoft.ReactNative NuGet packages
+      instead of building the framework from source. Defaults to true.
+
+      This is set during library project creation and is used when building
+      the library project's local sln file.
+
+      Otherwise this value will be decided by the consuming RNW app.
+
+      See https://microsoft.github.io/react-native-windows/docs/nuget
+    -->
+    <UseExperimentalNuget>true</UseExperimentalNuget>
+
+    <ReactExperimentalFeaturesSet>true</ReactExperimentalFeaturesSet>
+  </PropertyGroup>
+
+</Project>

package/windows/ReactNativeTcpWindows/ReactNativeTcpWindows.cpp

@@ -0,0 +1,206 @@
+#include "pch.h"
+#include "ReactNativeTcpWindows.h"
+#include "TcpSocket.h"
+namespace winrt::ReactNativeTcpWindows
+{
+
+// See https://microsoft.github.io/react-native-windows/docs/native-platform for help writing native modules
+
+void ReactNativeTcpWindows::Initialize(React::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
+  OutputDebugStringA("ReactNativeTcpWindows::Initialize called\n");
+//   m_tcpSocket = std::make_unique<TcpSocket>("127.0.0.1", 1234, TcpSocket::ConnectionType::Client);
+  if (m_tcpSocket) {
+    m_tcpSocket->close();
+    m_tcpSocket.reset();
+    OutputDebugStringA("Existing TcpSocket instance closed during Initialize\n");
+  }
+}
+
+ReactNativeTcpWindows::~ReactNativeTcpWindows() {
+  OutputDebugStringA("ReactNativeTcpWindows destructor called\n");
+
+  if (m_tcpSocket) {
+    m_tcpSocket->close(); // Calls TcpSocket::close
+    m_tcpSocket.reset();  // Triggers TcpSocket destructor
+  }
+}
+
+// double ReactNativeTcpWindows::multiply(double a, double b) noexcept {
+//   return a * b;
+// }
+void ReactNativeTcpWindows::connectToServer(std::string address, double port,
+    React::ReactPromise<std::string> &&promise) noexcept {
+    try {
+        OutputDebugStringA(("Connecting to TCP server:\n"
+            "Address: " + address + "\n"
+            "Port: " + std::to_string(static_cast<int>(port)) + "\n").c_str());
+
+        // Close existing connection if any
+        if (m_tcpSocket) {
+            m_tcpSocket->close();
+            m_tcpSocket.reset();
+        }
+
+        m_tcpSocket = std::make_unique<TcpSocket>(address, static_cast<int>(port), TcpSocket::ConnectionType::Client);
+        
+        // Set up callbacks
+        m_tcpSocket->setDataReceivedCallback([this](const std::vector<uint8_t>& data) {
+            OnDataReceived(data);
+        });
+        
+        m_tcpSocket->setConnectionStatusCallback([this, promise](bool connected, const std::string& message) {
+            OnConnectionStatusChanged(connected, message);
+            if (connected) {
+                promise.Resolve("Connected to server successfully");
+            } else {
+                promise.Reject(React::ReactError{"Error", message});
+            }
+        });
+
+        // Attempt connection
+        if (!m_tcpSocket->connect()) {
+            promise.Reject(React::ReactError{"Error", "Failed to initiate connection"});
+        }
+        // Note: Promise will be resolved/rejected in the connection status callback
+        
+    } catch (const std::exception& e) {
+        promise.Reject(React::ReactError{"Error", e.what()});
+    }
+}
+
+void ReactNativeTcpWindows::startServer(double port,
+    React::ReactPromise<std::string> &&promise) noexcept {
+    try {
+        OutputDebugStringA(("Starting TCP server on port: " + std::to_string(static_cast<int>(port)) + "\n").c_str());
+
+        // Close existing connection if any
+        if (m_tcpSocket) {
+            m_tcpSocket->close();
+            m_tcpSocket.reset();
+        }
+
+        m_tcpSocket = std::make_unique<TcpSocket>("0.0.0.0", static_cast<int>(port), TcpSocket::ConnectionType::Server);
+        
+        // Set up callbacks
+        m_tcpSocket->setDataReceivedCallback([this](const std::vector<uint8_t>& data) {
+            OnDataReceived(data);
+        });
+        
+        m_tcpSocket->setClientConnectedCallback([this](const std::string& clientAddress) {
+            OnClientConnected(clientAddress);
+        });
+        
+        m_tcpSocket->setClientDisconnectedCallback([this](const std::string& clientAddress) {
+            OnClientDisconnected(clientAddress);
+        });
+        
+        m_tcpSocket->setConnectionStatusCallback([this](bool connected, const std::string& message) {
+            OnConnectionStatusChanged(connected, message);
+        });
+
+        if (m_tcpSocket->startServer()) {
+            promise.Resolve("TCP server started successfully on port " + std::to_string(static_cast<int>(port)));
+        } else {
+            promise.Reject(React::ReactError{"Error", "Failed to start TCP server"});
+        }
+        
+    } catch (const std::exception& e) {
+        promise.Reject(React::ReactError{"Error", e.what()});
+    }
+}
+
+void ReactNativeTcpWindows::closeConnection(React::ReactPromise<std::string> &&promise) noexcept {
+try {
+    OutputDebugStringA("Called Close Connection for TCP socket...\n");
+    if (m_tcpSocket) {
+      OutputDebugStringA("Closing TCP socket...\n");
+      m_tcpSocket->close();
+      m_tcpSocket.reset();
+      promise.Resolve("Connection closed successfully");
+    } else {
+      OutputDebugStringA("No active TCP socket to close.\n");
+      promise.Reject(React::ReactError{ "Error", "No connection open" });
+    }
+  } catch (const std::exception& e) {
+    std::string errorMsg = std::string("Exception in closeConnection: ") + e.what();
+    OutputDebugStringA(errorMsg.c_str());
+    promise.Reject(React::ReactError{"Exception", errorMsg});
+  } catch (...) {
+    OutputDebugStringA("Unknown exception in closeConnection\n");
+    promise.Reject(React::ReactError{"Exception", "Unknown exception in closeConnection"});
+  }
+}
+
+void ReactNativeTcpWindows::write(std::vector<double> const& data, 
+    React::ReactPromise<bool> &&promise) noexcept {
+    if (!m_tcpSocket) {
+        promise.Reject("No connection open");
+        return;
+    }
+
+    std::vector<uint8_t> byteData;
+    byteData.reserve(data.size());
+    for (const auto& value : data) {
+        byteData.push_back(static_cast<uint8_t>(value));
+    }
+
+    promise.Resolve(m_tcpSocket->write(byteData));
+}
+
+void ReactNativeTcpWindows::getConnectionStatus(
+    React::ReactPromise<bool> &&promise
+) noexcept {
+    bool isConnected = m_tcpSocket ? m_tcpSocket->isConnected() : false;
+        promise.Resolve(isConnected);
+}
+void ReactNativeTcpWindows::OnDataReceived(const std::vector<uint8_t>& data) {
+    if (m_context) {
+        auto eventData = winrt::Microsoft::ReactNative::JSValueObject();
+        winrt::Microsoft::ReactNative::JSValueArray jsDataArray;
+        for (auto byte : data) {
+            jsDataArray.push_back(static_cast<int>(byte));
+        }
+
+        eventData["data"] = std::move(jsDataArray);
+
+        m_context.EmitJSEvent(L"RCTDeviceEventEmitter", L"TcpSocketDataReceived", eventData);
+    }
+}
+
+void ReactNativeTcpWindows::OnClientConnected(const std::string& clientAddress) {
+    if (m_context) {
+        auto eventData = winrt::Microsoft::ReactNative::JSValueObject();
+        eventData["clientAddress"] = clientAddress;
+
+        m_context.EmitJSEvent(L"RCTDeviceEventEmitter", L"TcpSocketClientConnected", eventData);
+    }
+}
+
+void ReactNativeTcpWindows::OnClientDisconnected(const std::string& clientAddress) {
+    if (m_context) {
+        auto eventData = winrt::Microsoft::ReactNative::JSValueObject();
+        eventData["clientAddress"] = clientAddress;
+
+        m_context.EmitJSEvent(L"RCTDeviceEventEmitter", L"TcpSocketClientDisconnected", eventData);
+    }
+}
+
+void ReactNativeTcpWindows::OnConnectionStatusChanged(bool connected, const std::string& message) {
+    if (m_context) {
+        auto eventData = winrt::Microsoft::ReactNative::JSValueObject();
+        eventData["connected"] = connected;
+        eventData["message"] = message;
+
+        m_context.EmitJSEvent(L"RCTDeviceEventEmitter", L"TcpSocketConnectionStatusChanged", eventData);
+    }
+}
+
+void ReactNativeTcpWindows::addListener(std::string eventType) noexcept {
+    // Event listener management - can be implemented if needed
+}
+
+void ReactNativeTcpWindows::removeListeners(double count) noexcept {
+    // Event listener management - can be implemented if needed
+}
+} // namespace winrt::ReactNativeTcpWindows

package/windows/ReactNativeTcpWindows/ReactNativeTcpWindows.def

@@ -0,0 +1,3 @@
+EXPORTS
+DllCanUnloadNow = WINRT_CanUnloadNow                    PRIVATE
+DllGetActivationFactory = WINRT_GetActivationFactory    PRIVATE

package/windows/ReactNativeTcpWindows/ReactNativeTcpWindows.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include "pch.h"
+#include "resource.h"
+#include "TcpSocket.h"
+
+#if __has_include("codegen/NativeReactNativeTcpWindowsDataTypes.g.h")
+  #include "codegen/NativeReactNativeTcpWindowsDataTypes.g.h"
+#endif
+#include "codegen/NativeReactNativeTcpWindowsSpec.g.h"
+
+#include "NativeModules.h"
+
+
+namespace winrt::ReactNativeTcpWindows
+{
+
+// See https://microsoft.github.io/react-native-windows/docs/native-platform for help writing native modules
+
+REACT_MODULE(ReactNativeTcpWindows)
+
+struct ReactNativeTcpWindows
+{
+  using ModuleSpec = ReactNativeTcpWindowsCodegen::ReactNativeTcpWindowsSpec;
+
+  REACT_INIT(Initialize)
+  void Initialize(React::ReactContext const &reactContext) noexcept;
+
+  ~ReactNativeTcpWindows(); // Add this to the struct
+
+  // REACT_SYNC_METHOD(multiply)
+  // double multiply(double a, double b) noexcept;
+
+  REACT_METHOD(connectToServer)
+  void connectToServer(std::string address, double port,
+                      React::ReactPromise<std::string> &&promise) noexcept;
+
+  REACT_METHOD(startServer)
+  void startServer(double port,
+                  React::ReactPromise<std::string> &&promise) noexcept;
+
+  REACT_METHOD(closeConnection)
+  void closeConnection(React::ReactPromise<std::string> &&promise) noexcept;
+
+  REACT_METHOD(write)
+  void write(std::vector<double> const& data, React::ReactPromise<bool> &&promise) noexcept;
+
+  // REACT_METHOD(getConnectionStatus)
+  // void getConnectionStatus(React::ReactPromise<winrt::Microsoft::ReactNative::JSValueObject> &&promise) noexcept;
+
+
+  REACT_METHOD(getConnectionStatus)
+  void getConnectionStatus(React::ReactPromise<bool> &&promise) noexcept;
+
+  REACT_METHOD(addListener)
+  void addListener(std::string eventType) noexcept;
+
+  REACT_METHOD(removeListeners)
+  void removeListeners(double count) noexcept;
+
+  void OnDataReceived(const std::vector<uint8_t>& data);
+  void OnClientConnected(const std::string& clientAddress);
+  void OnClientDisconnected(const std::string& clientAddress);
+  void OnConnectionStatusChanged(bool connected, const std::string& message);
+
+private:
+  React::ReactContext m_context;
+  std::unique_ptr<TcpSocket> m_tcpSocket;
+};
+// {
+//   using ModuleSpec = ReactNativeTcpWindowsCodegen::ReactNativeTcpWindowsSpec;
+
+//   REACT_INIT(Initialize)
+//   void Initialize(React::ReactContext const &reactContext) noexcept;
+
+//   REACT_SYNC_METHOD(multiply)
+//   double multiply(double a, double b) noexcept;
+
+// private:
+//   React::ReactContext m_context;
+// };
+
+} // namespace winrt::ReactNativeTcpWindows