it works

BasaltPresenter/Presenter/command_client.cpp

@@ -1,77 +1,68 @@
 #include "command_client.hpp"
+#include <basalt/char_types.hpp>
 #include <stdexcept>
 
 namespace Basalt::Presenter {
 
-    CommandClient::CommandClient(const std::basic_string_view<BSCHAR> pipe_name)
-        : m_PipeOperator(pipe_name) {
-    }
+    CommandClient::CommandClient() : m_PipeOperator(BSTEXT("ed0e3f1f-d214-4880-9562-640bce15e72e")), m_Status(ClientStatus::Ready) {}
 
-    CommandClient::~CommandClient() {
-    }
+    CommandClient::~CommandClient() {}
 
-    void CommandClient::WaitHandshake(std::uint8_t pixel_kind, std::uint32_t width, std::uint32_t height) {
-        if (m_Handshaked) {
-            throw std::runtime_error("Handshake already completed");
+    HandshakePayload CommandClient::WaitHandshake() {
+        if (m_Status != ClientStatus::Ready) {
+            throw std::runtime_error("unexcpected client status");
         }
 
         // Wait for handshake request from Trainer (code 0x61)
-        std::uint8_t received_code;
-        m_PipeOperator.Read(&received_code, sizeof(received_code));
-
-        if (received_code != HANDSHAKE_CODE_REQUEST) {
-            throw std::runtime_error("Expected handshake code 0x61, got 0x" + 
-                                   std::to_string(static_cast<int>(received_code)));
+        ProtocolCode request_code;
+        m_PipeOperator.Read(&request_code, sizeof(request_code));
+        if (request_code != ProtocolCode::HANDSHAKE_REQUEST) {
+            throw std::runtime_error("unexpcted handshake code");
         }
+        // Accept payload
+        HandshakePayload handshake_payload;
+        m_PipeOperator.Read(&handshake_payload, sizeof(HandshakePayload));
 
         // Send handshake response (code 0x62) back to Trainer
-        std::uint8_t handshake_response = HANDSHAKE_CODE_RESPONSE;
-        m_PipeOperator.Write(&handshake_response, sizeof(handshake_response));
+        ProtocolCode response_code = ProtocolCode::HANDSHAKE_RESPONSE;
+        m_PipeOperator.Write(&response_code, sizeof(response_code));
 
-        // Send data properties after handshake
-        m_PipeOperator.Write(&pixel_kind, sizeof(pixel_kind));
-        m_PipeOperator.Write(&width, sizeof(width));
-        m_PipeOperator.Write(&height, sizeof(height));
-
-        m_Handshaked = true;
+        // Set status and return
+        m_Status = ClientStatus::Running;
+        return handshake_payload;
     }
 
     bool CommandClient::Tick(bool actively_stop) {
-        if (!m_Handshaked) {
-            throw std::runtime_error("Handshake must be completed before calling Tick");
+        if (m_Status != ClientStatus::Running) {
+            throw std::runtime_error("unexcpected client status");
         }
 
-        // If actively_stop is true, send actively stop code to Trainer
+        // If actively stop, send actively stop code to Trainer first
         if (actively_stop) {
-            std::uint8_t stop_code = ACTIVELY_STOP_CODE;
-            m_PipeOperator.Write(&stop_code, sizeof(stop_code));
+            ProtocolCode sent_code = ProtocolCode::STOP_REQUEST;
+            m_PipeOperator.Write(&sent_code, sizeof(sent_code));
         }
 
         // Send data ready code to Trainer
-        std::uint8_t data_ready_code = DATA_READY_CODE;
-        m_PipeOperator.Write(&data_ready_code, sizeof(data_ready_code));
+        ProtocolCode sent_code = ProtocolCode::DATA_READY;
+        m_PipeOperator.Write(&sent_code, sizeof(sent_code));
 
-        // Wait for response from Trainer
-        std::uint8_t received_code;
-        m_PipeOperator.Read(&received_code, sizeof(received_code));
+        // Process the response from Trainer
+        while (true) {
+            ProtocolCode recv_code;
+            m_PipeOperator.Read(&recv_code, sizeof(recv_code));
 
-        // Handle the received code
-        if (received_code == DATA_RECEIVED_CODE) {
-            // Normal response, continue processing
-            return false; // Not stopping
-        } else if (received_code == STOP_CODE) {
-            // Trainer wants to stop
-            return true; // Should stop
-        } else if (received_code == HANDSHAKE_CODE_REQUEST || received_code == HANDSHAKE_CODE_RESPONSE) {
-            // Unexpected handshake code during Tick
-            throw std::runtime_error("Unexpected handshake code 0x" + 
-                                   std::to_string(static_cast<int>(received_code)) + 
-                                   " received during Tick operation");
-        } else {
-            // Unknown code
-            throw std::runtime_error("Unknown code 0x" + 
-                                   std::to_string(static_cast<int>(received_code)) + 
-                                   " received during Tick operation");
+            switch (recv_code) {
+                case ProtocolCode::DATA_RECEIVED:
+                    // Normal response, continue processing
+                    return false; // Not stopping
+                case Basalt::Presenter::ProtocolCode::STOP:
+                    // Trainer wants to stop
+                    m_Status = ClientStatus::Stop;
+                    return true; // Should stop
+                default:
+                    throw std::runtime_error("unexpected code when running");
+            }
         }
     }