react-native-tcp-windows 0.2.0 → 0.2.2

package/windows/ReactNativeTcpWindows/ReactNativeTcpWindows.cpp

@@ -1,206 +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
+#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

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

package/windows/ReactNativeTcpWindows/ReactNativeTcpWindows.h

@@ -1,83 +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
+#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