react-native-tcp-windows 0.2.0

package/windows/ReactNativeTcpWindows/TcpSocket.cpp

@@ -0,0 +1,565 @@
+#include "pch.h"
+#include "TcpSocket.h"
+#include <sstream>
+
+bool TcpSocket::s_wsaInitialized = false;
+int TcpSocket::s_wsaRefCount = 0;
+std::mutex TcpSocket::s_wsaMutex;
+
+TcpSocket::TcpSocket(const std::string &address, int port, ConnectionType type)
+    : m_address(address), m_port(port), m_type(type), m_socket(INVALID_SOCKET), m_serverSocket(INVALID_SOCKET), m_isRunning(false), m_isConnected(false), m_isServerRunning(false)
+{
+
+    std::lock_guard<std::mutex> lock(s_wsaMutex);
+    if (!s_wsaInitialized)
+    {
+        WSADATA wsaData;
+        if (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0)
+        {
+            s_wsaInitialized = true;
+        }
+    }
+    s_wsaRefCount++;
+}
+
+TcpSocket::~TcpSocket()
+{
+    close();
+
+    std::lock_guard<std::mutex> lock(s_wsaMutex);
+    s_wsaRefCount--;
+    if (s_wsaRefCount == 0 && s_wsaInitialized)
+    {
+        WSACleanup();
+        s_wsaInitialized = false;
+    }
+}
+
+bool TcpSocket::connect()
+{
+    if (m_type != ConnectionType::Client)
+    {
+        return false;
+    }
+
+    if (m_isConnected)
+    {
+        close();
+    }
+
+    m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (m_socket == INVALID_SOCKET)
+    {
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Failed to create socket");
+        }
+        return false;
+    }
+
+    sockaddr_in serverAddr = {};
+    serverAddr.sin_family = AF_INET;
+    serverAddr.sin_port = htons(m_port);
+
+    if (inet_pton(AF_INET, m_address.c_str(), &serverAddr.sin_addr) <= 0)
+    {
+        closesocket(m_socket);
+        m_socket = INVALID_SOCKET;
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Invalid address format");
+        }
+        return false;
+    }
+
+    if (::connect(m_socket, (sockaddr *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
+    {
+        int error = WSAGetLastError();
+        closesocket(m_socket);
+        m_socket = INVALID_SOCKET;
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Connection failed. Error: " + std::to_string(error));
+        }
+        return false;
+    }
+
+    m_isConnected = true;
+    m_isRunning = true;
+    startReading();
+
+    if (m_connectionStatusCallback)
+    {
+        m_connectionStatusCallback(true, "Connected successfully");
+    }
+
+    return true;
+}
+
+bool TcpSocket::startServer()
+{
+    if (m_type != ConnectionType::Server)
+    {
+        return false;
+    }
+
+    if (m_isServerRunning)
+    {
+        close();
+    }
+
+    m_serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (m_serverSocket == INVALID_SOCKET)
+    {
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Failed to create server socket");
+        }
+        return false;
+    }
+
+    // Allow socket reuse
+    BOOL reuseAddr = TRUE;
+    setsockopt(m_serverSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&reuseAddr, sizeof(reuseAddr));
+
+    sockaddr_in serverAddr = {};
+    serverAddr.sin_family = AF_INET;
+    serverAddr.sin_port = htons(m_port);
+    serverAddr.sin_addr.s_addr = INADDR_ANY;
+
+    if (bind(m_serverSocket, (sockaddr *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
+    {
+        int error = WSAGetLastError();
+        closesocket(m_serverSocket);
+        m_serverSocket = INVALID_SOCKET;
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Bind failed. Error: " + std::to_string(error));
+        }
+        return false;
+    }
+
+    if (listen(m_serverSocket, SOMAXCONN) == SOCKET_ERROR)
+    {
+        int error = WSAGetLastError();
+        closesocket(m_serverSocket);
+        m_serverSocket = INVALID_SOCKET;
+        if (m_connectionStatusCallback)
+        {
+            m_connectionStatusCallback(false, "Listen failed. Error: " + std::to_string(error));
+        }
+        return false;
+    }
+
+    m_isServerRunning = true;
+    m_isRunning = true;
+
+    // Start accepting connections
+    m_acceptThread = std::thread(&TcpSocket::serverAcceptThread, this);
+
+    if (m_connectionStatusCallback)
+    {
+        m_connectionStatusCallback(true, "Server started on port " + std::to_string(m_port));
+    }
+
+    return true;
+}
+
+void TcpSocket::close()
+{
+    // STEP 1: Shutdown sockets FIRST to wake up any blocking operations
+    if (m_socket != INVALID_SOCKET) {
+        shutdown(m_socket, SD_BOTH);  // This wakes up recv() calls
+    }
+    
+    if (m_serverSocket != INVALID_SOCKET) {
+        shutdown(m_serverSocket, SD_BOTH);  // This wakes up accept() calls
+    }
+    
+    // Shutdown all client connections
+    {
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        for (SOCKET clientSocket : m_clientSockets) {
+            if (clientSocket != INVALID_SOCKET) {
+                shutdown(clientSocket, SD_BOTH);
+            }
+        }
+    }
+    
+    // STEP 2: Now stopReading should complete quickly since sockets are shutdown
+    stopReading();
+
+    // STEP 3: Close the sockets
+    if (m_socket != INVALID_SOCKET)
+    {
+        closesocket(m_socket);
+        m_socket = INVALID_SOCKET;
+    }
+
+    if (m_serverSocket != INVALID_SOCKET)
+    {
+        closesocket(m_serverSocket);
+        m_serverSocket = INVALID_SOCKET;
+    }
+
+    // Close all client connections
+    {
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        for (SOCKET clientSocket : m_clientSockets)
+        {
+            closesocket(clientSocket);
+        }
+        m_clientSockets.clear();
+    }
+
+    m_isConnected = false;
+    m_isServerRunning = false;
+}
+
+bool TcpSocket::write(const std::vector<uint8_t> &data)
+{
+    if (data.empty())
+    {
+        return false;
+    }
+
+    if (m_type == ConnectionType::Client && m_isConnected)
+    {
+        int result = send(m_socket, (char *)data.data(), static_cast<int>(data.size()), 0);
+        return result != SOCKET_ERROR;
+    }
+    else if (m_type == ConnectionType::Server && m_isServerRunning)
+    {
+        // Send to all connected clients
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        bool success = true;
+        for (SOCKET clientSocket : m_clientSockets)
+        {
+            int result = send(clientSocket, (char *)data.data(), static_cast<int>(data.size()), 0);
+            if (result == SOCKET_ERROR)
+            {
+                success = false;
+            }
+        }
+        return success;
+    }
+
+    return false;
+}
+
+void TcpSocket::setDataReceivedCallback(DataReceivedCallback callback)
+{
+    m_dataCallback = std::move(callback);
+}
+
+void TcpSocket::setClientConnectedCallback(ClientConnectedCallback callback)
+{
+    m_clientConnectedCallback = std::move(callback);
+}
+
+void TcpSocket::setClientDisconnectedCallback(ClientDisconnectedCallback callback)
+{
+    m_clientDisconnectedCallback = std::move(callback);
+}
+
+void TcpSocket::setConnectionStatusCallback(ConnectionStatusCallback callback)
+{
+    m_connectionStatusCallback = std::move(callback);
+}
+
+void TcpSocket::startReading()
+{
+    if (m_type == ConnectionType::Client)
+    {
+        m_readThread = std::thread(&TcpSocket::clientReadThread, this);
+    }
+}
+
+// CHANGE 1: Update clientReadThread() - Add socket timeout
+void TcpSocket::clientReadThread()
+{
+    std::vector<uint8_t> buffer(1024);
+
+    // Set socket timeout to prevent infinite blocking
+    DWORD timeout = 1000; // 1 second
+    setsockopt(m_socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
+
+    while (m_isRunning && m_isConnected)
+    {
+        int bytesReceived = recv(m_socket, (char *)buffer.data(), buffer.size(), 0);
+
+        if (bytesReceived > 0)
+        {
+            if (m_dataCallback)
+            {
+                OutputDebugStringA(("TCP Client received " + std::to_string(bytesReceived) + " bytes\n").c_str());
+                m_dataCallback(std::vector<uint8_t>(buffer.begin(), buffer.begin() + bytesReceived));
+            }
+        }
+        else if (bytesReceived == 0)
+        {
+            // Connection closed by peer
+            m_isConnected = false;
+            if (m_connectionStatusCallback)
+            {
+                m_connectionStatusCallback(false, "Connection closed by peer");
+            }
+            break;
+        }
+        else
+        {
+            // Error occurred
+            int error = WSAGetLastError();
+            if (error == WSAETIMEDOUT)
+            {
+                // Timeout - continue loop to check m_isRunning
+                continue;
+            }
+            else if (error == WSAECONNRESET || error == WSAESHUTDOWN || error == WSAENOTCONN)
+            {
+                // Connection closed/shutdown - exit gracefully
+                m_isConnected = false;
+                OutputDebugStringA("Connection closed during recv\n");
+                break;
+            }
+            else if (error != WSAEWOULDBLOCK)
+            {
+                m_isConnected = false;
+                if (m_connectionStatusCallback)
+                {
+                    m_connectionStatusCallback(false, "Receive error: " + std::to_string(error));
+                }
+                break;
+            }
+        }
+    }
+    OutputDebugStringA("Client read thread exiting\n");
+}
+
+// CHANGE 2: Update serverAcceptThread() - Add socket timeout
+void TcpSocket::serverAcceptThread()
+{
+    // Set socket timeout for accept() to prevent infinite blocking
+    DWORD timeout = 1000; // 1 second
+    setsockopt(m_serverSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
+
+    while (m_isRunning && m_isServerRunning)
+    {
+        sockaddr_in clientAddr = {};
+        int clientAddrLen = sizeof(clientAddr);
+
+        SOCKET clientSocket = accept(m_serverSocket, (sockaddr *)&clientAddr, &clientAddrLen);
+
+        if (clientSocket != INVALID_SOCKET)
+        {
+            std::string clientAddress = getSocketAddress(clientSocket);
+
+            {
+                std::lock_guard<std::mutex> lock(m_clientsMutex);
+                m_clientSockets.push_back(clientSocket);
+                m_clientThreads.emplace_back(&TcpSocket::serverClientReadThread, this, clientSocket, clientAddress);
+            }
+
+            if (m_clientConnectedCallback)
+            {
+                m_clientConnectedCallback(clientAddress);
+            }
+
+            OutputDebugStringA(("Client connected from: " + clientAddress + "\n").c_str());
+        }
+        else if (m_isRunning && m_isServerRunning)
+        {
+            int error = WSAGetLastError();
+            if (error == WSAETIMEDOUT)
+            {
+                // Timeout - continue loop to check m_isRunning
+                continue;
+            }
+            else if (error == WSAECONNRESET || error == WSAESHUTDOWN || error == WSAENOTCONN)
+            {
+                // Server socket closed/shutdown - exit gracefully
+                OutputDebugStringA("Server socket closed during accept\n");
+                break;
+            }
+            else if (error != WSAEINTR)
+            {
+                OutputDebugStringA(("Accept error: " + std::to_string(error) + "\n").c_str());
+            }
+        }
+    }
+    OutputDebugStringA("Server accept thread exiting\n");
+}
+
+// CHANGE 3: Update serverClientReadThread() - Add socket timeout
+void TcpSocket::serverClientReadThread(SOCKET clientSocket, std::string clientAddress)
+{
+    std::vector<uint8_t> buffer(1024);
+
+    // Set socket timeout to prevent infinite blocking
+    DWORD timeout = 1000; // 1 second
+    setsockopt(clientSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
+
+    while (m_isRunning && m_isServerRunning)
+    {
+        int bytesReceived = recv(clientSocket, (char *)buffer.data(), buffer.size(), 0);
+
+        if (bytesReceived > 0)
+        {
+            if (m_dataCallback)
+            {
+                OutputDebugStringA(("TCP Server received " + std::to_string(bytesReceived) + " bytes from " + clientAddress + "\n").c_str());
+                m_dataCallback(std::vector<uint8_t>(buffer.begin(), buffer.begin() + bytesReceived));
+            }
+        }
+        else if (bytesReceived == 0)
+        {
+            // Client disconnected
+            OutputDebugStringA(("Client disconnected normally: " + clientAddress + "\n").c_str());
+            break;
+        }
+        else
+        {
+            // Error occurred
+            int error = WSAGetLastError();
+            if (error == WSAETIMEDOUT)
+            {
+                // Timeout - continue loop to check m_isRunning
+                continue;
+            }
+            else if (error == WSAECONNRESET || error == WSAESHUTDOWN || error == WSAENOTCONN)
+            {
+                // Client connection closed/shutdown - exit gracefully
+                OutputDebugStringA(("Client connection closed during recv: " + clientAddress + "\n").c_str());
+                break;
+            }
+            else if (error != WSAEWOULDBLOCK)
+            {
+                OutputDebugStringA(("Client receive error: " + std::to_string(error) + " for " + clientAddress + "\n").c_str());
+                break;
+            }
+        }
+    }
+
+    // Remove client from list and close socket
+    {
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        auto it = std::find(m_clientSockets.begin(), m_clientSockets.end(), clientSocket);
+        if (it != m_clientSockets.end())
+        {
+            m_clientSockets.erase(it);
+        }
+    }
+
+    closesocket(clientSocket);
+
+    if (m_clientDisconnectedCallback)
+    {
+        m_clientDisconnectedCallback(clientAddress);
+    }
+
+    OutputDebugStringA(("Client thread exiting: " + clientAddress + "\n").c_str());
+}
+
+// CHANGE 4: Simplify stopReading() - Remove async timeout logic (it's causing issues)
+void TcpSocket::stopReading()
+{
+    OutputDebugStringA("stopReading() called\n");
+
+    // 1. Set the stop flag
+    m_isRunning = false;
+    OutputDebugStringA("Set m_isRunning = false\n");
+
+    // 2. WAKE UP blocked threads by shutting down sockets
+    if (m_socket != INVALID_SOCKET)
+    {
+        OutputDebugStringA("Shutting down main socket...\n");
+        shutdown(m_socket, SD_BOTH);
+    }
+
+    if (m_serverSocket != INVALID_SOCKET)
+    {
+        OutputDebugStringA("Shutting down server socket...\n");
+        shutdown(m_serverSocket, SD_BOTH);
+    }
+
+    // Wake up client sockets
+    {
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        OutputDebugStringA(("Shutting down " + std::to_string(m_clientSockets.size()) + " client sockets...\n").c_str());
+        for (SOCKET clientSocket : m_clientSockets)
+        {
+            shutdown(clientSocket, SD_BOTH);
+        }
+    }
+
+    // 3. Join threads with simple timeout
+    OutputDebugStringA("Joining read thread...\n");
+    if (m_readThread.joinable())
+    {
+        try
+        {
+            m_readThread.join();
+            OutputDebugStringA("Read thread joined successfully\n");
+        }
+        catch (...)
+        {
+            OutputDebugStringA("Read thread join failed - detaching\n");
+            m_readThread.detach();
+        }
+    }
+
+    OutputDebugStringA("Joining accept thread...\n");
+    if (m_acceptThread.joinable())
+    {
+        try
+        {
+            m_acceptThread.join();
+            OutputDebugStringA("Accept thread joined successfully\n");
+        }
+        catch (...)
+        {
+            OutputDebugStringA("Accept thread join failed - detaching\n");
+            m_acceptThread.detach();
+        }
+    }
+
+    // Join client threads
+    OutputDebugStringA(("Joining " + std::to_string(m_clientThreads.size()) + " client threads...\n").c_str());
+    for (size_t i = 0; i < m_clientThreads.size(); ++i)
+    {
+        auto &thread = m_clientThreads[i];
+        if (thread.joinable())
+        {
+            try
+            {
+                thread.join();
+                OutputDebugStringA(("Client thread " + std::to_string(i) + " joined successfully\n").c_str());
+            }
+            catch (...)
+            {
+                OutputDebugStringA(("Client thread " + std::to_string(i) + " join failed - detaching\n").c_str());
+                thread.detach();
+            }
+        }
+    }
+    m_clientThreads.clear();
+
+    OutputDebugStringA("stopReading() completed successfully\n");
+}
+
+std::string TcpSocket::getSocketAddress(SOCKET socket)
+{
+    sockaddr_in addr = {};
+    int addrLen = sizeof(addr);
+
+    if (getpeername(socket, (sockaddr *)&addr, &addrLen) == 0)
+    {
+        char ipStr[INET_ADDRSTRLEN];
+        if (inet_ntop(AF_INET, &addr.sin_addr, ipStr, INET_ADDRSTRLEN))
+        {
+            return std::string(ipStr) + ":" + std::to_string(ntohs(addr.sin_port));
+        }
+    }
+
+    return "unknown";
+}

package/windows/ReactNativeTcpWindows/TcpSocket.h

@@ -0,0 +1,69 @@
+#pragma once
+#include "pch.h"
+#include <string>
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#include <functional>
+#include <thread>
+#include <atomic>
+#include <mutex>
+
+#pragma comment(lib, "ws2_32.lib")
+
+class TcpSocket {
+public:
+    enum class ConnectionType { Client = 0, Server = 1 };
+
+    using DataReceivedCallback = std::function<void(const std::vector<uint8_t>&)>;
+    using ClientConnectedCallback = std::function<void(const std::string&)>;
+    using ClientDisconnectedCallback = std::function<void(const std::string&)>;
+    using ConnectionStatusCallback = std::function<void(bool, const std::string&)>;
+
+     TcpSocket(const std::string& address, int port, ConnectionType type);
+    //TcpSocket::TcpSocket(const std::string&, int, TcpSocket::ConnectionType)
+
+    ~TcpSocket();
+
+    bool connect();
+    bool startServer();
+    void close();
+    bool write(const std::vector<uint8_t>& data);
+    void setDataReceivedCallback(DataReceivedCallback callback);
+    void setClientConnectedCallback(ClientConnectedCallback callback);
+    void setClientDisconnectedCallback(ClientDisconnectedCallback callback);
+    void setConnectionStatusCallback(ConnectionStatusCallback callback);
+    bool isConnected() const { return m_isConnected; }
+    bool isServerRunning() const { return m_isServerRunning; }
+
+private:
+    void startReading();
+    void clientReadThread();
+    void serverAcceptThread();
+    void serverClientReadThread(SOCKET clientSocket, std::string clientAddress);
+    void stopReading();
+    void cleanup();
+    std::string getSocketAddress(SOCKET socket);
+
+    std::string m_address;
+    int m_port;
+    ConnectionType m_type;
+    SOCKET m_socket;
+    SOCKET m_serverSocket;
+    std::atomic<bool> m_isRunning;
+    std::atomic<bool> m_isConnected;
+    std::atomic<bool> m_isServerRunning;
+    std::thread m_readThread;
+    std::thread m_acceptThread;
+    std::vector<std::thread> m_clientThreads;
+    std::vector<SOCKET> m_clientSockets;
+    std::mutex m_clientsMutex;
+    
+    DataReceivedCallback m_dataCallback;
+    ClientConnectedCallback m_clientConnectedCallback;
+    ClientDisconnectedCallback m_clientDisconnectedCallback;
+    ConnectionStatusCallback m_connectionStatusCallback;
+    
+    static bool s_wsaInitialized;
+    static int s_wsaRefCount;
+    static std::mutex s_wsaMutex;
+};

package/windows/ReactNativeTcpWindows/codegen/.clang-format

@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false

package/windows/ReactNativeTcpWindows/codegen/NativeReactNativeTcpWindowsSpec.g.h

@@ -0,0 +1,71 @@
+
+/*
+ * This file is auto-generated from a NativeModule spec file in js.
+ *
+ * This is a C++ Spec class that should be used with MakeTurboModuleProvider to register native modules
+ * in a way that also verifies at compile time that the native module matches the interface required
+ * by the TurboModule JS spec.
+ */
+#pragma once
+// clang-format off
+
+#include <NativeModules.h>
+#include <tuple>
+
+namespace ReactNativeTcpWindowsCodegen {
+
+
+struct ReactNativeTcpWindowsSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto methods = std::tuple{
+      Method<void(std::string, double, Promise<std::string>) noexcept>{0, L"connectToServer"},
+      Method<void(double, Promise<std::string>) noexcept>{1, L"startServer"},
+      Method<void(Promise<std::string>) noexcept>{2, L"closeConnection"},
+      Method<void(std::vector<double>, Promise<bool>) noexcept>{3, L"write"},
+      Method<void(Promise<bool>) noexcept>{4, L"getConnectionStatus"},
+      Method<void(std::string) noexcept>{5, L"addListener"},
+      Method<void(double) noexcept>{6, L"removeListeners"},
+  };
+
+  template <class TModule>
+  static constexpr void ValidateModule() noexcept {
+    constexpr auto methodCheckResults = CheckMethods<TModule, ReactNativeTcpWindowsSpec>();
+
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          0,
+          "connectToServer",
+          "    REACT_METHOD(connectToServer) void connectToServer(std::string address, double port, ::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(connectToServer) static void connectToServer(std::string address, double port, ::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          1,
+          "startServer",
+          "    REACT_METHOD(startServer) void startServer(double port, ::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(startServer) static void startServer(double port, ::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          2,
+          "closeConnection",
+          "    REACT_METHOD(closeConnection) void closeConnection(::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(closeConnection) static void closeConnection(::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          3,
+          "write",
+          "    REACT_METHOD(write) void write(std::vector<double> const & data, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(write) static void write(std::vector<double> const & data, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          4,
+          "getConnectionStatus",
+          "    REACT_METHOD(getConnectionStatus) void getConnectionStatus(::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getConnectionStatus) static void getConnectionStatus(::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          5,
+          "addListener",
+          "    REACT_METHOD(addListener) void addListener(std::string eventType) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(addListener) static void addListener(std::string eventType) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          6,
+          "removeListeners",
+          "    REACT_METHOD(removeListeners) void removeListeners(double count) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(removeListeners) static void removeListeners(double count) noexcept { /* implementation */ }\n");
+  }
+};
+
+} // namespace ReactNativeTcpWindowsCodegen