Implemented new C++ logic

Client/streamhub/WSClient.h

@@ -0,0 +1,100 @@
+/**
+ * @file WSClient.h
+ * @brief RFC 6455 WebSocket client (POSIX sockets, background receive thread).
+ *
+ * The receive thread continuously reads frames and places them in a queue.
+ * The main (ImGui) thread drains the queue each frame and also sends frames.
+ *
+ * Reuses WSFrame.h / SHA1.h / Base64.h from Source/Applications/StreamHub/.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <queue>
+#include <mutex>
+#include <thread>
+#include <functional>
+#include <atomic>
+#include <cstdint>
+
+namespace StreamHubClient {
+
+/**
+ * @brief A received WebSocket frame.
+ */
+struct WSMessage {
+    bool   isBinary;
+    std::vector<uint8_t> data;   ///< Payload bytes (text frames are also stored here)
+};
+
+/**
+ * @brief Minimal RFC 6455 WebSocket client.
+ *
+ * Usage:
+ *   WSClient ws;
+ *   ws.connect("127.0.0.1", 8090);
+ *   // main loop:
+ *   ws.poll(handler);        // drain received messages
+ *   ws.sendText(json);       // send a JSON command
+ *   ws.disconnect();
+ */
+class WSClient {
+public:
+    WSClient();
+    ~WSClient();
+
+    /**
+     * @brief (Re)connect to host:port in the background.
+     * Non-blocking — sets a reconnect target; the receive thread handles the actual
+     * connect/reconnect loop.
+     */
+    void connect(const std::string& host, uint16_t port);
+
+    /** @brief Gracefully close the WebSocket connection and stop the receive thread. */
+    void disconnect();
+
+    /**
+     * @brief Non-blocking reconnect to a (possibly new) host:port.
+     * Closes the current socket so the background thread detects the drop and
+     * reconnects immediately. Does NOT join the thread — safe to call from the UI.
+     */
+    void reconnect(const std::string& host, uint16_t port);
+
+    /** @return true if the WebSocket handshake completed and the connection is open. */
+    bool isConnected() const;
+
+    /**
+     * @brief Drain all pending received messages and pass each to `handler`.
+     * Must be called from the main thread.
+     */
+    void poll(const std::function<void(const WSMessage&)>& handler);
+
+    /** @brief Send a JSON text frame. Thread-safe. */
+    void sendText(const std::string& json);
+
+    /** @brief Send a binary frame. Thread-safe. */
+    void sendBinary(const uint8_t* data, size_t len);
+
+private:
+    void recvLoop();
+    bool doConnect();
+    bool doHandshake();
+    bool recvExact(uint8_t* buf, size_t len);
+    bool sendRaw(const uint8_t* buf, size_t len);
+
+    std::string   host_;
+    uint16_t      port_       = 0;
+    int           sock_       = -1;
+    std::atomic<bool> connected_   {false};
+    std::atomic<bool> stopThread_  {false};
+    std::atomic<bool> reconnect_   {false};
+
+    std::thread           recvThread_;
+    mutable std::mutex    sendMutex_;
+    mutable std::mutex    queueMutex_;
+    std::queue<WSMessage> recvQueue_;
+};
+
+} /* namespace StreamHubClient */