From d8ffab7338ad050f59037a951d89cbfa0f7dd056 Mon Sep 17 00:00:00 2001
From: womendoushihaoyin <xyliu_leo@163.com>
Date: Mon, 13 Jan 2025 09:10:58 +0800
Subject: [PATCH] add the moonraker_mqtt

---
 resources/web/flutter/index.html              |  51 ++++
 resources/web/flutter0/index.html             |  17 ++
 src/libslic3r/PrintConfig.cpp                 |   3 +-
 src/libslic3r/PrintConfig.hpp                 |   2 +-
 src/mqtt/externals/paho-mqtt-c/src/SHA1.c     |  20 +-
 src/mqtt/externals/paho-mqtt-c/src/SHA1.h     |  12 +-
 .../externals/paho-mqtt-c/src/WebSocket.c     |   6 +-
 src/slic3r/CMakeLists.txt                     |   2 +
 src/slic3r/GUI/SSWCP.cpp                      | 170 ++++++++---
 src/slic3r/GUI/SSWCP.hpp                      |  14 +
 src/slic3r/Utils/MQTT.cpp                     | 168 +++++++++++
 src/slic3r/Utils/MQTT.hpp                     |  92 ++++++
 src/slic3r/Utils/MoonRaker.cpp                | 264 +++++++++++++++++-
 src/slic3r/Utils/MoonRaker.hpp                |  63 ++++-
 src/slic3r/Utils/PrintHost.cpp                |   3 +-
 src/slic3r/Utils/PrintHost.hpp                |  10 +-
 16 files changed, 832 insertions(+), 65 deletions(-)
 create mode 100644 src/slic3r/Utils/MQTT.cpp
 create mode 100644 src/slic3r/Utils/MQTT.hpp

diff --git a/resources/web/flutter/index.html b/resources/web/flutter/index.html
index 562dc60d2e4..af28f10bf13 100644
--- a/resources/web/flutter/index.html
+++ b/resources/web/flutter/index.html
@@ -36,6 +36,57 @@
   <script src="flutter_bootstrap.js" async></script>
 
   <script>
+    function test_mqtt_subscribe() {
+      body = {
+        header:{
+          swquenceId: 202503,
+        },
+        payload:{
+          cmd: "sw_SubscribeMachineState",
+          params: {},
+          event_id: "subscribe1",
+        }
+      };
+
+      window.wx.postMessage(JSON.stringify(body));
+    }
+
+    function test_mqtt_machine_info(){
+      body  = {
+        header:{
+          sequenceId: 202502,
+        },
+        payload:{
+          cmd: "sw_GetMachineState",
+          params: {
+            "targets":{
+              "gcode_move": null,
+              "toolhead": ["position", "status"]
+            }
+          }
+        }
+      };
+      window.wx.postMessage(JSON.stringify(body));
+    }
+
+
+    function test_mqtt_connect() {
+      body = {
+        header:{
+          sequenceId: 202501,
+        },
+        payload:{
+          cmd: "sw_Connect",
+          params: {
+            ip: "172.18.1.46",
+            port: 1883,
+            sn: "61BC45A47ED2BE8E",
+          }
+        }
+      }
+      window.wx.postMessage(JSON.stringify(body));
+    }
+
 
     function getDeviceData() {
       var devices = { 
diff --git a/resources/web/flutter0/index.html b/resources/web/flutter0/index.html
index 7c7083499c9..f07b9c7889f 100644
--- a/resources/web/flutter0/index.html
+++ b/resources/web/flutter0/index.html
@@ -36,6 +36,23 @@
   <script src="flutter_bootstrap.js" async></script>
 
   <script>
+    function test_mqtt_connect() {
+      body = {
+        header:{
+          sequenceId: 202501,
+        },
+        payload:{
+          cmd: "sw_Connect",
+          params: {
+            ip: "172.18.1.46",
+            port: 1883,
+            sn: "61BC45A47ED2BE8E",
+          }
+        }
+      }
+      window.wx.postMessage(JSON.stringify(body));
+    }
+
     // 接收来自于 Flutter 的消息
     function on_machine_list_arrived(response){
       console.log(response);
diff --git a/src/libslic3r/PrintConfig.cpp b/src/libslic3r/PrintConfig.cpp
index 2d75a4b847a..8e40a1a68c3 100644
--- a/src/libslic3r/PrintConfig.cpp
+++ b/src/libslic3r/PrintConfig.cpp
@@ -75,6 +75,7 @@ static t_config_enum_values s_keys_map_PrinterTechnology {
 CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(PrinterTechnology)
 
 static t_config_enum_values s_keys_map_PrintHostType {
+    { "moonraker_mqtt", htMoonRaker_mqtt},
     { "moonraker",      htMoonRaker},
     { "prusalink",      htPrusaLink },
     { "prusaconnect",   htPrusaConnect },
@@ -3424,7 +3425,7 @@ void PrintConfigDef::init_fff_params()
     def->enum_labels.push_back("SimplyPrint");
     def->mode = comAdvanced;
     def->cli = ConfigOptionDef::nocli;
-    def->set_default_value(new ConfigOptionEnum<PrintHostType>(htOctoPrint));
+    def->set_default_value(new ConfigOptionEnum<PrintHostType>(htMoonRaker_mqtt));
     
 
     def = this->add("nozzle_volume", coFloat);
diff --git a/src/libslic3r/PrintConfig.hpp b/src/libslic3r/PrintConfig.hpp
index 8aa90ac617c..6648bb28c03 100644
--- a/src/libslic3r/PrintConfig.hpp
+++ b/src/libslic3r/PrintConfig.hpp
@@ -42,7 +42,7 @@ enum class FuzzySkinType {
 };
 
 enum PrintHostType {
-    htMoonRaker, htPrusaLink, htPrusaConnect, htOctoPrint, htDuet, htFlashAir, htAstroBox, htRepetier, htMKS, htESP3D, htCrealityPrint, htObico, htFlashforge, htSimplyPrint
+    htMoonRaker_mqtt, htMoonRaker, htPrusaLink, htPrusaConnect, htOctoPrint, htDuet, htFlashAir, htAstroBox, htRepetier, htMKS, htESP3D, htCrealityPrint, htObico, htFlashforge, htSimplyPrint
 };
 
 enum AuthorizationType {
diff --git a/src/mqtt/externals/paho-mqtt-c/src/SHA1.c b/src/mqtt/externals/paho-mqtt-c/src/SHA1.c
index 3ef07d920d2..136b12227f1 100644
--- a/src/mqtt/externals/paho-mqtt-c/src/SHA1.c
+++ b/src/mqtt/externals/paho-mqtt-c/src/SHA1.c
@@ -20,7 +20,7 @@
 #if defined(_WIN32) || defined(_WIN64)
 #pragma comment(lib, "crypt32.lib")
 
-int SHA1_Init(SHA_CTX *c)
+int SHA1_Init_mqtt(SHA_CTX *c)
 {
 	if (!CryptAcquireContext(&c->hProv, NULL, NULL,
 		PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
@@ -33,7 +33,7 @@ int SHA1_Init(SHA_CTX *c)
 	return 1;
 }
 
-int SHA1_Update(SHA_CTX *c, const void *data, size_t len)
+int SHA1_Update_mqtt(SHA_CTX *c, const void *data, size_t len)
 {
 	int rv = 1;
 	if (!CryptHashData(c->hHash, data, (DWORD)len, 0))
@@ -41,7 +41,7 @@ int SHA1_Update(SHA_CTX *c, const void *data, size_t len)
 	return rv;
 }
 
-int SHA1_Final(unsigned char *md, SHA_CTX *c)
+int SHA1_Final_mqtt(unsigned char *md, SHA_CTX *c)
 {
 	int rv = 0;
 	DWORD md_len = SHA1_DIGEST_LENGTH;
@@ -74,7 +74,7 @@ static unsigned char pad[64] = {
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 
-int SHA1_Init(SHA_CTX *ctx)
+int SHA1_Init_mqtt(SHA_CTX *ctx)
 {
 	int ret = 0;
 	if ( ctx )
@@ -136,7 +136,7 @@ static void SHA1_ProcessBlock(SHA_CTX *ctx)
 		ctx->h[i] += blks[i];
 }
 
-int SHA1_Final(unsigned char *md, SHA_CTX *ctx)
+int SHA1_Final_mqtt(unsigned char *md, SHA_CTX *ctx)
 {
 	int i;
 	int ret = 0;
@@ -151,7 +151,7 @@ int SHA1_Final(unsigned char *md, SHA_CTX *ctx)
 	else
 		pad_amount = 64 + 56 - ctx->size;
 
-	SHA1_Update(ctx, pad, pad_amount);
+	SHA1_Update_mqtt(ctx, pad, pad_amount);
 
 	ctx->w[14] = htobe32((uint32_t)(total >> 32));
 	ctx->w[15] = htobe32((uint32_t)total);
@@ -170,7 +170,7 @@ int SHA1_Final(unsigned char *md, SHA_CTX *ctx)
 	return ret;
 }
 
-int SHA1_Update(SHA_CTX *ctx, const void *data, size_t len)
+int SHA1_Update_mqtt(SHA_CTX *ctx, const void *data, size_t len)
 {
 	while ( len > 0 )
 	{
@@ -229,9 +229,9 @@ int main(int argc, char *argv[])
 		char out[SHA1_DIGEST_LENGTH * 2 + 1];
 		SHA_CTX c;
 		int j;
-		r[0] = SHA1_Init( &c );
-		r[1] = SHA1_Update( &c, test_data[i].in, strlen(test_data[i].in));
-		r[2] = SHA1_Final( sha_out, &c );
+		r[0] = SHA1_Init_mqtt( &c );
+		r[1] = SHA1_Update_mqtt( &c, test_data[i].in, strlen(test_data[i].in));
+		r[2] = SHA1_Final_mqtt( sha_out, &c );
 		for ( j = 0u; j < SHA1_DIGEST_LENGTH; ++j )
 			snprintf( &out[j*2], 3u, "%02x", sha_out[j] );
 		out[SHA1_DIGEST_LENGTH * 2] = '\0';
diff --git a/src/mqtt/externals/paho-mqtt-c/src/SHA1.h b/src/mqtt/externals/paho-mqtt-c/src/SHA1.h
index 3ae2f0a3f44..9de34b57e05 100644
--- a/src/mqtt/externals/paho-mqtt-c/src/SHA1.h
+++ b/src/mqtt/externals/paho-mqtt-c/src/SHA1.h
@@ -57,10 +57,10 @@ typedef struct SHA_CTX_S {
  *
  * @param[in,out]  ctx                 hashing context structure
  *
- * @see SHA1_Update
+ * @see SHA1_Update_mqtt
  * @see SHA1_Final
  */
-int SHA1_Init(SHA_CTX *ctx);
+int SHA1_Init_mqtt(SHA_CTX *ctx);
 
 /**
  * Updates a block to the SHA1 hash
@@ -69,10 +69,10 @@ int SHA1_Init(SHA_CTX *ctx);
  * @param[in]      data                block of data to hash
  * @param[in]      len                 length of block to hash
  *
- * @see SHA1_Init
+ * @see SHA1_Init_mqtt
  * @see SHA1_Final
  */
-int SHA1_Update(SHA_CTX *ctx, const void *data, size_t len);
+int SHA1_Update_mqtt(SHA_CTX *ctx, const void *data, size_t len);
 
 /**
  * Produce final SHA1 hash
@@ -81,10 +81,10 @@ int SHA1_Update(SHA_CTX *ctx, const void *data, size_t len);
  *                                     @p SHA1_DIGEST_LENGTH in length)
  * @param[in,out]  ctx                 hashing context structure
  *
- * @see SHA1_Init
+ * @see SHA1_Init_mqtt
  * @see SHA1_Final
  */
-int SHA1_Final(unsigned char *md, SHA_CTX *ctx);
+int SHA1_Final_mqtt(unsigned char *md, SHA_CTX *ctx);
 
 #endif /* if defined(OPENSSL) */
 #endif /* SHA1_H */
diff --git a/src/mqtt/externals/paho-mqtt-c/src/WebSocket.c b/src/mqtt/externals/paho-mqtt-c/src/WebSocket.c
index c57ae7de905..239eae7ba5c 100644
--- a/src/mqtt/externals/paho-mqtt-c/src/WebSocket.c
+++ b/src/mqtt/externals/paho-mqtt-c/src/WebSocket.c
@@ -1321,9 +1321,9 @@ int WebSocket_upgrade( networkHandles *net )
 
 		/* calculate the expected websocket key, expected from server */
 		snprintf( ws_key, sizeof(ws_key), "%s%s", net->websocket_key, ws_guid );
-		SHA1_Init( &ctx );
-		SHA1_Update( &ctx, ws_key, strlen(ws_key));
-		SHA1_Final( sha_hash, &ctx );
+		SHA1_Init_mqtt( &ctx );
+		SHA1_Update_mqtt( &ctx, ws_key, strlen(ws_key));
+		SHA1_Final_mqtt( sha_hash, &ctx );
 		Base64_encode( ws_key, sizeof(ws_key), sha_hash, SHA1_DIGEST_LENGTH );
 
 		read_buf = WebSocket_getRawSocketData( net, 12u, &rcv, &rc);
diff --git a/src/slic3r/CMakeLists.txt b/src/slic3r/CMakeLists.txt
index 89b58c7c34e..2f914d18f2c 100644
--- a/src/slic3r/CMakeLists.txt
+++ b/src/slic3r/CMakeLists.txt
@@ -494,6 +494,8 @@ set(SLIC3R_GUI_SOURCES
     GUI/TaskManager.hpp
     Utils/Http.cpp
     Utils/Http.hpp
+    Utils/MQTT.hpp
+    Utils/MQTT.cpp
     Utils/FixModelByWin10.cpp
     Utils/FixModelByWin10.hpp
     Utils/EmbossStyleManager.cpp
diff --git a/src/slic3r/GUI/SSWCP.cpp b/src/slic3r/GUI/SSWCP.cpp
index d648d9df27e..fde759f0e85 100644
--- a/src/slic3r/GUI/SSWCP.cpp
+++ b/src/slic3r/GUI/SSWCP.cpp
@@ -39,32 +39,28 @@ void SSWCP_Instance::process() {
 
 
 void SSWCP_Instance::send_to_js() {
+    try {
+        json response, payload;
+        response["header"] = m_header;
 
-    json response, payload;
-    response["header"]     = m_header;
-    
-    
+        payload["code"] = m_status;
+        payload["msg"]  = m_msg;
+        payload["data"] = m_res_data;
 
-    payload["code"]     = m_status;
-    payload["msg"]        = m_msg;
-    payload["data"]       = m_res_data;
+        response["payload"] = payload;
 
-    response["payload"] = payload;
+        std::string str_res = "window.postMessage(JSON.stringify(" + response.dump() + "), '*');";
 
-    std::string str_res = "window.postMessage(JSON.stringify(" + response.dump() + "), '*');";
-    
-    // std::string str_res = "test(" + response.dump() + ");";
-
-    if (m_webview) {
-        wxGetApp().CallAfter([this, str_res]() {
-            try {
-                WebView::RunScript(this->m_webview, str_res);
-            } 
-            catch (std::exception& e) {
-                
-            }
-        });
-    }
+        // std::string str_res = "test(" + response.dump() + ");";
+
+        if (m_webview) {
+            wxGetApp().CallAfter([this, str_res]() {
+                try {
+                    WebView::RunScript(this->m_webview, str_res);
+                } catch (std::exception& e) {}
+            });
+        }
+    } catch (std::exception& e) {}
 }
 
 void SSWCP_Instance::finish_job() {
@@ -279,36 +275,87 @@ void SSWCP_MachineOption_Instance::process()
     }
     else if (m_cmd == "sw_GetMachineState") {
         sw_GetMachineState();
+    } else if (m_cmd == "sw_SubscribeMachineState") {
+        sw_SubscribeMachineState();
     }
 }
 
+void SSWCP_MachineOption_Instance::sw_SubscribeMachineState() {
+    try {
+        std::shared_ptr<PrintHost> host(PrintHost::get_print_host(&wxGetApp().preset_bundle->printers.get_edited_preset().config));
+
+        if (!host) {
+            m_status = 1;
+            m_msg    = "failure";
+            send_to_js();
+            finish_job();
+        }
+
+        host->async_subscribe_machine_info([this](const json& response) {
+            if (response.is_null() || response.empty()) {
+                m_status = -1;
+                m_msg    = "failure";
+                send_to_js();
+            } else {
+                m_res_data = response;
+                send_to_js();
+            }
+        });
+
+    } catch (std::exception& e) {}
+}
+
 void SSWCP_MachineOption_Instance::sw_GetMachineState() {
     try {
         if (m_param_data.count("targets")) {
             std::shared_ptr<PrintHost> host(PrintHost::get_print_host(&wxGetApp().preset_bundle->printers.get_edited_preset().config));
-            std::vector<std::pair<std::string, std::string>> targets;
+            std::vector<std::pair<std::string, std::vector<std::string>>> targets;
 
             json items = m_param_data["targets"];
             for (auto& [key, value] : items.items()) {
                 if (value.is_null()) {
-                    targets.push_back({key, ""});
+                    targets.push_back({key, {}});
                 } else {
-                    targets.push_back({key, value.get<std::string>()});
+                    std::vector<std::string> items;
+                    if (value.is_array()) {
+                        for (size_t i = 0; i < value.size(); ++i) {
+                            items.push_back(value[i].get<std::string>());
+                        }
+                    } else {
+                        items.push_back(value.get<std::string>());
+                    }
+                    targets.push_back({key, items});
                 }
             }
 
             if (!host) {
                 // 错误处理
+                m_status = -1;
+                m_msg    = "failure";
+                send_to_js();
                 finish_job();
             } else {
-                m_work_thread = std::thread([this, targets, host]() {
-                    json response;
-                    bool        res      = host->get_machine_info(targets, response);
-                    if (res) {
-                        m_res_data = response;
+                //m_work_thread = std::thread([this, targets, host]() {
+                //    json response;
+                //    bool        res      = host->get_machine_info(targets, response);
+                //    if (res) {
+                //        m_res_data = response;
+                //        send_to_js();
+                //    } else {
+                //        // 错误处理
+                //    }
+                //});
+
+                host->async_get_machine_info(targets, [this](const json& response) {
+                    if (response.is_null() || response.empty()) {
+                        m_status = -1;
+                        m_msg    = "failure";
                         send_to_js();
+                        finish_job();
                     } else {
-                        // 错误处理
+                        m_res_data = response;
+                        send_to_js();
+                        finish_job();
                     }
                 });
             }
@@ -388,6 +435,7 @@ void SSWCP_MachineConnect_Instance::sw_test_connect() {
 
             auto p_config = &(wxGetApp().preset_bundle->printers.get_edited_preset().config);
 
+
             PrintHostType type = PrintHostType::htMoonRaker;
             // todo : 增加输入与type的映射
             
@@ -412,6 +460,8 @@ void SSWCP_MachineConnect_Instance::sw_test_connect() {
                         m_msg    = msg.c_str();
                         send_to_js();
                     }
+
+                    finish_job();
                 });
             }
         } else {
@@ -438,31 +488,59 @@ void SSWCP_MachineConnect_Instance::sw_connect() {
 
             auto p_config = &(wxGetApp().preset_bundle->printers.get_edited_preset().config);
 
-            PrintHostType type = PrintHostType::htMoonRaker;
+            PrintHostType type = PrintHostType::htMoonRaker_mqtt;
             // todo : 增加输入与type的映射
 
             p_config->option<ConfigOptionEnum<PrintHostType>>("host_type")->value = type;
 
-            p_config->set("print_host", ip + (port == -1 ? "" : std::to_string(port)));
+            p_config->set("print_host", ip + (port == -1 ? "" : ":" + std::to_string(port)));
 
             std::shared_ptr<PrintHost> host(PrintHost::get_print_host(&wxGetApp().preset_bundle->printers.get_edited_preset().config));
 
+            json connect_params;
+            if (m_param_data.count("sn") && m_param_data["sn"].is_string()) {
+                connect_params["sn"] = m_param_data["sn"].get<std::string>();
+            }
+
             if (!host) {
                 // 错误处理
                 finish_job();
             } else {
-                m_work_thread = std::thread([this, host] {
+                m_work_thread = std::thread([this, host, connect_params] {
+                    // moonraker_mqtt 如果没有sn码，需要http请求获取sn码
+
+                    //wxString msg = "";
+                    //bool     res = host->test(msg);
+
+                    //if (res) {
+                    //    wxGetApp().mainframe->load_printer_url("http://"+  host->get_host());
+                    //    // wxGetApp().mainframe->load_printer_url(host->, wxString apikey)
+                    //} else {
+                    //    m_status = 1;
+                    //    m_msg    = msg.c_str();
+                    //    send_to_js();
+                    //}
+
                     wxString msg = "";
-                    bool     res = host->test(msg);
+                    json     params;
+                    bool res = host->connect(msg, connect_params);
 
                     if (res) {
-                        wxGetApp().mainframe->load_printer_url("http://"+  host->get_host());
-                        // wxGetApp().mainframe->load_printer_url(host->, wxString apikey)
+                        // 后续应改成机器交互页的本地web服务器地址
+                        std::string ip_port = host->get_host();
+                        int         pos     = ip_port.find(':');
+                        if (pos != std::string::npos) {
+                            ip_port = ip_port.substr(0, pos);
+                        }
+                        wxGetApp().mainframe->load_printer_url("http://" + ip_port);
                     } else {
                         m_status = 1;
                         m_msg    = msg.c_str();
-                        send_to_js();
                     }
+
+                    send_to_js();
+                    finish_job();
+
                 });
             }
 
@@ -474,7 +552,22 @@ void SSWCP_MachineConnect_Instance::sw_connect() {
 }
 
 void SSWCP_MachineConnect_Instance::sw_disconnect() {
+    m_work_thread = std::thread([this](){
+        std::shared_ptr<PrintHost> host(PrintHost::get_print_host(&wxGetApp().preset_bundle->printers.get_edited_preset().config));
+
+        wxString msg = "";
+        bool res = host->disconnect(msg, {});
 
+        if (res) {
+            // todo: 交互页面删除
+        } else {
+            m_status = 1;
+            m_msg    = msg.c_str();
+        }
+
+        send_to_js();
+        finish_job();
+    });
 }
 
 
@@ -490,6 +583,7 @@ std::unordered_set<std::string> SSWCP::m_machine_find_cmd_list = {
 std::unordered_set<std::string> SSWCP::m_machine_option_cmd_list = {
     "sw_SendGCodes",
     "sw_GetMachineState",
+    "sw_SubscribeMachineState",
 };
 
 std::unordered_set<std::string> SSWCP::m_machine_connect_cmd_list = {
diff --git a/src/slic3r/GUI/SSWCP.hpp b/src/slic3r/GUI/SSWCP.hpp
index a7edf3d07b0..aaef83d9451 100644
--- a/src/slic3r/GUI/SSWCP.hpp
+++ b/src/slic3r/GUI/SSWCP.hpp
@@ -72,6 +72,12 @@ class SSWCP_MachineConnect_Instance : public SSWCP_Instance
         m_type = MACHINE_CONNECT;
     }
 
+    ~SSWCP_MachineConnect_Instance()
+    {
+        if (m_work_thread.joinable())
+            m_work_thread.detach();
+    }
+
     void process() override;
 
 private:
@@ -130,6 +136,12 @@ class SSWCP_MachineOption_Instance : public SSWCP_Instance
         m_type = MACHINE_OPTION;
     }
 
+    ~SSWCP_MachineOption_Instance()
+    {
+        if (m_work_thread.joinable())
+            m_work_thread.detach();
+    }
+
     void process() override;
 
 private:
@@ -137,6 +149,8 @@ class SSWCP_MachineOption_Instance : public SSWCP_Instance
 
     void sw_GetMachineState();
 
+    void sw_SubscribeMachineState();
+
 private:
     std::thread m_work_thread;
 };
diff --git a/src/slic3r/Utils/MQTT.cpp b/src/slic3r/Utils/MQTT.cpp
new file mode 100644
index 00000000000..f16dd9f2cb9
--- /dev/null
+++ b/src/slic3r/Utils/MQTT.cpp
@@ -0,0 +1,168 @@
+#include "MQTT.hpp"
+#include <iostream>
+#include <thread>
+
+// 构造函数，初始化MQTT客户端
+MqttClient::MqttClient(const std::string& server_address, const std::string& client_id, bool clean_session)
+    : server_address_(server_address), client_id_(client_id), client_(server_address_, client_id_), connOpts_(), subListener_("Subscription"), connected_(false)
+{
+    // 设置连接选项
+    connOpts_.set_clean_session(clean_session);
+    connOpts_.set_keep_alive_interval(20);
+
+    // 设置回调
+    client_.set_callback(*this);
+}
+
+// 连接到MQTT服务器
+bool MqttClient::Connect()
+{
+    try {
+        std::cout << "Connecting to the MQTT server..." << std::flush;
+        mqtt::token_ptr conntok = client_.connect(connOpts_, nullptr, *this);
+        conntok->wait();
+        connected_ = true;
+        std::cout << "Connected" << std::endl;
+        return true;
+    } catch (const mqtt::exception& exc) {
+        connected_ = false;
+        std::cerr << "\nERROR: Unable to connect to MQTT server: '" << server_address_ << "'\n" << exc.what() << std::endl;
+        return false;
+    }
+}
+
+// 断开与MQTT服务器的连接
+bool MqttClient::Disconnect()
+{
+    if (!connected_) {
+        std::cerr << "Already disconnected" << std::endl;
+        return false;
+    }
+
+    try {
+        std::cout << "\nDisconnecting from the MQTT server..." << std::flush;
+        mqtt::token_ptr disctok = client_.disconnect();
+        disctok->wait();
+        connected_ = false;
+        std::cout << "OK" << std::endl;
+        return true;
+    } catch (const mqtt::exception& exc) {
+        std::cerr << "Error on disconnect: " << exc.what() << std::endl;
+        return false;
+    }
+}
+
+// 检查客户端是否已连接
+bool MqttClient::CheckConnected()
+{
+    if (!connected_) {
+        std::cerr << "Error: Client is not connected to the MQTT server" << std::endl;
+        return false;
+    }
+    return true;
+}
+
+// 订阅某个话题
+bool MqttClient::Subscribe(const std::string& topic, int qos)
+{
+    if (!CheckConnected()) {
+        return false;
+    }
+
+    try {
+        std::cout << "Subscribing to topic '" << topic << "' with QoS " << qos << std::endl;
+        mqtt::token_ptr subtok = client_.subscribe(topic, qos, nullptr, subListener_);
+        subtok->wait();
+        return true;
+    } catch (const mqtt::exception& exc) {
+        std::cerr << "Error on subscribe: " << exc.what() << std::endl;
+        return false;
+    }
+}
+
+// 解除对某个话题的订阅
+bool MqttClient::Unsubscribe(const std::string& topic)
+{
+    if (!CheckConnected()) {
+        return false;
+    }
+
+    try {
+        std::cout << "Unsubscribing from topic '" << topic << "'" << std::endl;
+        mqtt::token_ptr unsubtok = client_.unsubscribe(topic);
+        unsubtok->wait();
+        return true;
+    } catch (const mqtt::exception& exc) {
+        std::cerr << "Error on unsubscribe: " << exc.what() << std::endl;
+        return false;
+    }
+}
+
+// 发布消息到某个话题
+bool MqttClient::Publish(const std::string& topic, const std::string& payload, int qos)
+{
+    if (!CheckConnected()) {
+        return false;
+    }
+
+    mqtt::message_ptr pubmsg = mqtt::make_message(topic, payload);
+    pubmsg->set_qos(qos);
+
+    try {
+        std::cout << "Publishing message '" << payload << "' to topic '" << topic << "' with QoS " << qos << std::endl;
+        mqtt::token_ptr pubtok = client_.publish(pubmsg);
+        pubtok->wait();
+        return true;
+    } catch (const mqtt::exception& exc) {
+        std::cerr << "Error on publish: " << exc.what() << std::endl;
+        return false;
+    }
+}
+
+// 设置消息到达的回调
+void MqttClient::SetMessageCallback(std::function<void(const std::string& topic, const std::string& payload)> callback)
+{
+    message_callback_ = callback;
+}
+
+// 实现mqtt::callback接口的方法
+void MqttClient::connection_lost(const std::string& cause)
+{
+    connected_ = false;
+    std::cout << "\nConnection lost" << std::endl;
+    if (!cause.empty())
+        std::cout << "\tcause: " << cause << std::endl;
+
+    Connect();
+}
+
+void MqttClient::message_arrived(mqtt::const_message_ptr msg)
+{
+    if (message_callback_) {
+        message_callback_(msg->get_topic(), msg->to_string());
+    }
+}
+
+void MqttClient::delivery_complete(mqtt::delivery_token_ptr token)
+{
+    std::cout << "Delivery complete for token: " << (token ? token->get_message_id() : -1) << std::endl;
+}
+
+// 实现mqtt::iaction_listener接口的方法
+void MqttClient::on_failure(const mqtt::token& tok)
+{
+    std::cout << "Failure in token: " << tok.get_message_id() << std::endl;
+    if (tok.get_reason_code() != 0)
+        std::cout << "\treason_code: " << tok.get_reason_code() << std::endl;
+
+    // connected_ = false;
+}
+
+void MqttClient::on_success(const mqtt::token& tok)
+{
+    std::cout << "Success in token: " << tok.get_message_id() << std::endl;
+    auto top = tok.get_topics();
+    if (top && !top->empty())
+        std::cout << "\ttoken topic: '" << (*top)[0] << "', ..." << std::endl;
+    std::cout << std::endl;
+}
diff --git a/src/slic3r/Utils/MQTT.hpp b/src/slic3r/Utils/MQTT.hpp
new file mode 100644
index 00000000000..21822541d17
--- /dev/null
+++ b/src/slic3r/Utils/MQTT.hpp
@@ -0,0 +1,92 @@
+#ifndef MQTT_H
+#define MQTT_H
+
+#include <functional>
+#include <string>
+#include <map>
+#include <mqtt/async_client.h>
+
+#define CONNECT_RETRY_TIME 3
+#define SUBSCRIBE_RETRY_TIME 3
+
+// 定义 action_listener 类
+class action_listener : public virtual mqtt::iaction_listener
+{
+private:
+    std::string name_;
+
+public:
+    action_listener(const std::string& name) : name_(name) {}
+
+    void on_failure(const mqtt::token& tok) override
+    {
+        std::cout << name_ << " failure";
+        if (tok.get_message_id() != 0)
+            std::cout << " for token: [" << tok.get_message_id() << "]" << std::endl;
+        std::cout << std::endl;
+    }
+
+    void on_success(const mqtt::token& tok) override
+    {
+        std::cout << name_ << " success";
+        if (tok.get_message_id() != 0)
+            std::cout << " for token: [" << tok.get_message_id() << "]" << std::endl;
+        auto top = tok.get_topics();
+        if (top && !top->empty())
+            std::cout << "\ttoken topic: '" << (*top)[0] << "', ..." << std::endl;
+        std::cout << std::endl;
+    }
+};
+
+class MqttClient : public virtual mqtt::callback, public virtual mqtt::iaction_listener
+{
+public:
+    // 构造函数，初始化MQTT客户端
+    MqttClient(const std::string& server_address, const std::string& client_id, bool clean_session);
+
+    // 连接到MQTT服务器
+    bool Connect();
+
+    // 断开与MQTT服务器的连接
+    bool Disconnect();
+
+    // 订阅某个话题
+    bool Subscribe(const std::string& topic, int qos);
+
+    // 解除对某个话题的订阅
+    bool Unsubscribe(const std::string& topic);
+
+    // 发布消息到某个话题
+    bool Publish(const std::string& topic, const std::string& payload, int qos);
+
+    // 设置消息到达的回调
+    void SetMessageCallback(std::function<void(const std::string& topic, const std::string& payload)> callback);
+
+    // 实现mqtt::callback接口的方法
+    void connection_lost(const std::string& cause) override;
+    void message_arrived(mqtt::const_message_ptr msg) override;
+    void delivery_complete(mqtt::delivery_token_ptr token) override;
+
+    // 实现mqtt::iaction_listener接口的方法
+    void on_failure(const mqtt::token& tok) override;
+    void on_success(const mqtt::token& tok) override;
+
+    // 检查客户端是否已连接
+    bool CheckConnected();
+
+private:
+    std::string                                                               server_address_;
+    std::string                                                               client_id_;
+    mqtt::async_client                                                        client_;
+    std::function<void(const std::string& topic, const std::string& payload)> message_callback_;
+    mqtt::connect_options                                                     connOpts_;
+    bool                                                                      connected_ = false;
+    std::map<std::string, int>                                                topics_to_resubscribe_;
+    action_listener                                                           subListener_;
+    int                                                                       connect_retry_time_;
+    int                                                                       subscribe_retry_time_;
+
+    
+};
+
+#endif // MQTT_H
diff --git a/src/slic3r/Utils/MoonRaker.cpp b/src/slic3r/Utils/MoonRaker.cpp
index aa84ff2c1dd..4fc1fe2cd6a 100644
--- a/src/slic3r/Utils/MoonRaker.cpp
+++ b/src/slic3r/Utils/MoonRaker.cpp
@@ -1,4 +1,5 @@
 #include "MoonRaker.hpp"
+#include "MQTT.hpp"
 
 #include <algorithm>
 #include <sstream>
@@ -11,7 +12,6 @@
 #include <boost/asio.hpp>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/nowide/convert.hpp>
-
 #include <curl/curl.h>
 
 #include <wx/progdlg.h>
@@ -229,14 +229,21 @@ bool Moonraker::test_with_resolved_ip(wxString& msg) const
 }
 #endif // WIN32
 
-bool Moonraker::get_machine_info(const std::vector<std::pair<std::string, std::string>>& targets, json& response) {
+bool Moonraker::get_machine_info(const std::vector<std::pair<std::string, std::vector<std::string>>>& targets, json& response) {
     bool res = true;
 
     auto url = make_url("printer/objects/query");
     auto http = Http::post(std::move(url));
 
     for (const auto pair : targets) {
-        http.form_add(pair.first, pair.second);
+        std::string value = "";
+        for (size_t i = 0; i < pair.second.size(); ++i) {
+            if (i != 0) {
+                value += ",";
+            }
+            value += pair.second[i];
+        }
+        http.form_add(pair.first, value);
     }
 
     http.on_error([&](std::string body, std::string error, unsigned status) {
@@ -280,6 +287,17 @@ bool Moonraker::send_gcodes(const std::vector<std::string>& codes, std::string&
 
 bool Moonraker::test(wxString& msg) const
 {
+    //// test
+    //MqttClient* mqttClient = new MqttClient("mqtt://172.18.0.9:1883", "OrcaClient", false);
+    //mqttClient->SetMessageCallback([](const std::string& topic, const std::string& payload) {
+    //    int a = 0;
+    //    int b = 0;
+    //});
+    //mqttClient->Connect();
+    //mqttClient->Subscribe("9BD4E436F33D0B56/response", 2);
+    //mqttClient->Subscribe("9BD4E436F33D0B56/status", 2);
+    //mqttClient->Publish("9BD4E436F33D0B56/request", "{\"jsonrpc\": \"2.0\",\"method\": \"server.info\",\"id\": 9546}", 1);
+    
     // Since the request is performed synchronously here,
     // it is ok to refer to `msg` from within the closure
     const char* name = get_name();
@@ -586,4 +604,244 @@ std::string Moonraker::make_url(const std::string& path) const
     }
 }
 
+
+bool Moonraker::connect(wxString& msg, const nlohmann::json& params) {
+    return test(msg);
+}
+
+
+
+
+
+
+
+
+// Moonraker_mqtt
+
+MqttClient* Moonraker_Mqtt::m_mqtt_client = nullptr;
+
+std::string Moonraker_Mqtt::m_request_topic = "/request";
+std::string Moonraker_Mqtt::m_response_topic = "/response";
+std::string Moonraker_Mqtt::m_notification_topic = "/notification";
+std::string Moonraker_Mqtt::m_status_topic       = "/status";
+
+std::unordered_map<std::string, std::function<void(const nlohmann::json&)>> Moonraker_Mqtt::m_request_cb_map;
+std::timed_mutex Moonraker_Mqtt::m_cb_map_mtx;
+
+std::function<void(const nlohmann::json&)> Moonraker_Mqtt::m_status_cb = nullptr;
+
+std::string Moonraker_Mqtt::m_sn          = "";
+
+Moonraker_Mqtt::Moonraker_Mqtt(DynamicPrintConfig* config) : Moonraker(config) {
+    std::string host_info = config->option<ConfigOptionString>("print_host")->value;
+    if (!m_mqtt_client)
+        m_mqtt_client         = new MqttClient("mqtt://" + host_info, "orca", false);
+
+    
+}
+
+bool Moonraker_Mqtt::connect(wxString& msg, const nlohmann::json& params) {
+    if (m_mqtt_client->CheckConnected()) {
+        disconnect(msg, params);
+    }
+
+    std::string sn = "";
+    
+    if (!params.count("sn")) {
+        // 如果没有sn码，需要发http请求获取
+    } else {
+        sn = params["sn"].get<std::string>();
+    }
+
+    if (sn == "") {
+        return false;
+    }
+
+    m_sn = sn;
+
+    bool is_connect = m_mqtt_client->Connect();
+    bool response_subscribed = m_mqtt_client->Subscribe(m_sn + m_response_topic, 2);
+    m_mqtt_client->SetMessageCallback([this](const std::string& topic, const std::string& payload) {
+        this->on_mqtt_message_arrived(topic, payload);
+    });
+
+    return is_connect && response_subscribed;
+
+}
+
+
+bool Moonraker_Mqtt::disconnect(wxString& msg, const nlohmann::json& params) {
+    return m_mqtt_client->Disconnect();
+}
+
+void Moonraker_Mqtt::async_subscribe_machine_info(std::function<void(const nlohmann::json&)> callback)
+{
+    bool res = m_mqtt_client->Subscribe(m_sn + m_status_topic, 0);
+
+    if (!res || m_status_cb) {
+        callback(json::value_t::null);
+        return;
+    }
+
+    m_status_cb = callback;
+}
+
+void Moonraker_Mqtt::async_get_machine_info(const std::vector<std::pair<std::string, std::vector<std::string>>>& targets, std::function<void(const nlohmann::json& response)> callback)
+{
+    std::string method = "printer.objects.query";
+
+    json params;
+    params["objects"] = json::object();
+
+    for (size_t i = 0; i < targets.size(); ++i) {
+        if (targets[i].second.size() == 0) {
+            params["objects"][targets[i].first] = json::value_t::null;
+        } else {
+            params["objects"][targets[i].first] = json::array();
+
+            for (const auto& key : targets[i].second) {
+                params["objects"][targets[i].first].push_back(key);
+            }
+        }
+    }
+
+    if (!send_to_request(method, params, true, callback) && callback) {
+        callback(json::value_t::null);
+    }
+}
+
+
+bool Moonraker_Mqtt::send_to_request(const std::string& method, const json& params, bool need_response, std::function<void(const nlohmann::json& response)> callback) 
+{
+    json body;
+
+    body["jsonrpc"] = "2.0";
+    body["method"]  = method;
+    body["params"]  = params;
+
+    boost::uuids::uuid uuid = m_generator();
+
+    std::string str_uuid = boost::uuids::to_string(uuid);
+
+    if (need_response) {
+        if (!add_response_target(str_uuid, callback)) {
+            return false;
+        }
+        body["id"]                 = str_uuid;
+    }
+
+    if (m_mqtt_client) {
+        bool res = m_mqtt_client->Publish(m_sn + m_request_topic, body.dump(), 2);
+        if (!res) {
+            delete_response_target(str_uuid);
+        }
+        return res;
+    } else {
+        return false;
+    }
+}
+
+bool Moonraker_Mqtt::add_response_target(const std::string& id, std::function<void(const nlohmann::json& response)> callback) {
+    if (m_cb_map_mtx.try_lock_for(std::chrono::seconds(5))) {
+        m_request_cb_map[id] = callback;
+
+        m_cb_map_mtx.unlock();
+        return true;
+    }
+    return false;
+
+}
+
+void Moonraker_Mqtt::delete_response_target(const std::string& id) {
+    if (m_cb_map_mtx.try_lock_for(std::chrono::seconds(5))) {
+        if (m_request_cb_map.count(id)) {
+            m_request_cb_map.erase(id);
+        }
+        m_cb_map_mtx.unlock();
+    }
+    
+}
+
+std::function<void(const json&)> Moonraker_Mqtt::get_request_callback(const std::string& id)
+{
+    if (m_cb_map_mtx.try_lock_for(std::chrono::seconds(5))) {
+        if (m_request_cb_map.count(id)) {
+            auto result = m_request_cb_map[id];
+            m_cb_map_mtx.unlock();
+            return result;
+        } else {
+            m_cb_map_mtx.unlock();
+            return nullptr;
+        }
+    } 
+
+    return nullptr;
+}
+
+void Moonraker_Mqtt::on_mqtt_message_arrived(const std::string& topic, const std::string& payload)
+{
+    try {
+        if (topic.find(m_response_topic) != std::string::npos) {
+            on_response_arrived(payload);
+        } else if (topic.find(m_status_topic) != std::string::npos) {
+            on_status_arrived(payload);
+        } else if (topic.find(m_notification_topic) != std::string::npos) {
+            on_notification_arrived(payload);
+        } 
+        else {
+            return;
+        }
+
+    } catch (std::exception& e) {}
+}
+
+
+void Moonraker_Mqtt::on_response_arrived(const std::string& payload)
+{
+    try {
+        json body = json::parse(payload);
+
+        if (!body.count("id")) {
+            return;
+        }
+
+        std::string id = body["id"].get<std::string>();
+
+        auto cb = get_request_callback(id);
+        delete_response_target(id);
+
+        if (!cb) {
+            return;
+        }
+
+        if (!body.count("result")) {
+            cb(json::value_t::null);
+        } else {
+            cb(body["result"]);
+        }
+
+    } catch (std::exception& e) {}
+}
+
+void Moonraker_Mqtt::on_status_arrived(const std::string& payload)
+{
+    try {
+        json body = json::parse(payload);
+
+        // 待修改
+        if (!m_status_cb) {
+            return;
+        }
+
+        m_status_cb(body);
+
+    } catch (std::exception& e) {}
+}
+
+void Moonraker_Mqtt::on_notification_arrived(const std::string& payload)
+{
+    try {
+    } catch (std::exception& e) {}
+}
+
 } // namespace Slic3r
diff --git a/src/slic3r/Utils/MoonRaker.hpp b/src/slic3r/Utils/MoonRaker.hpp
index 1ff558f6303..50b8d917da8 100644
--- a/src/slic3r/Utils/MoonRaker.hpp
+++ b/src/slic3r/Utils/MoonRaker.hpp
@@ -5,10 +5,14 @@
 #include <wx/string.h>
 #include <boost/optional.hpp>
 #include <boost/asio/ip/address.hpp>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
 
 #include "PrintHost.hpp"
 #include "libslic3r/PrintConfig.hpp"
 
+class MqttClient;
 
 namespace Slic3r {
 
@@ -28,7 +32,7 @@ class Moonraker : public PrintHost
     wxString get_test_failed_msg (wxString &msg) const override;
     bool upload(PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const override;
     bool                       send_gcodes(const std::vector<std::string>& codes, std::string& extraInfo) override;
-    bool                       get_machine_info(const std::vector<std::pair<std::string, std::string>>& targets, nlohmann::json& response) override;
+    bool                       get_machine_info(const std::vector<std::pair<std::string, std::vector<std::string>>>& targets, nlohmann::json& response) override;
     bool has_auto_discovery() const override { return true; }
     bool can_test() const override { return true; }
     PrintHostPostUploadActions get_post_upload_actions() const override { return PrintHostPostUploadAction::StartPrint; }
@@ -36,6 +40,11 @@ class Moonraker : public PrintHost
     const std::string& get_apikey() const { return m_apikey; }
     const std::string& get_cafile() const { return m_cafile; }
 
+    virtual bool connect(wxString& msg, const nlohmann::json& params) override;
+    virtual bool disconnect(wxString& msg, const nlohmann::json& params) override { return true; }
+    virtual void async_get_machine_info(const std::vector<std::pair<std::string, std::vector<std::string>>>& targets, std::function<void(const nlohmann::json& response)>) override  {}
+    virtual void async_subscribe_machine_info(std::function<void(const nlohmann::json&)>) override {}
+
 protected:
 #ifdef WIN32
     virtual bool upload_inner_with_resolved_ip(PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn, const boost::asio::ip::address& resolved_addr) const;
@@ -58,6 +67,58 @@ class Moonraker : public PrintHost
 };
 
 
+
+class Moonraker_Mqtt : public Moonraker
+{
+public:
+    Moonraker_Mqtt(DynamicPrintConfig* config);
+
+    virtual bool connect(wxString& msg, const nlohmann::json& params) override;
+
+    virtual bool disconnect(wxString& msg, const nlohmann::json& params) override;
+
+    virtual void async_get_machine_info(const std::vector<std::pair<std::string, std::vector<std::string>>>& targets, std::function<void(const nlohmann::json& response)> callback) override;
+
+    virtual void async_subscribe_machine_info(std::function<void(const nlohmann::json&)>) override;
+
+public:
+    void on_mqtt_message_arrived(const std::string& topic, const std::string& payload);
+
+private:
+    bool send_to_request(const std::string& method, const nlohmann::json& params, bool need_response = false, std::function<void(const nlohmann::json& response)> callback = nullptr);
+
+    bool add_response_target(const std::string& id, std::function<void(const nlohmann::json& response)> callback);
+
+    std::function<void(const nlohmann::json& response)> get_request_callback(const std::string& id);
+
+    void delete_response_target(const std::string& id);
+
+    void on_response_arrived(const std::string& payload);
+
+    void on_status_arrived(const std::string& payload);
+
+    void on_notification_arrived(const std::string& payload);
+
+
+private:
+    static MqttClient* m_mqtt_client;
+
+    static std::unordered_map<std::string, std::function<void(const nlohmann::json&)>> m_request_cb_map;
+    static std::timed_mutex                                                                     m_cb_map_mtx;
+    static std::function<void(const nlohmann::json&)>                                  m_status_cb;
+
+
+    static std::string m_response_topic;
+    static std::string m_status_topic;
+    static std::string m_notification_topic;
+    static std::string m_request_topic;
+
+    static std::string m_sn;
+
+private:
+    boost::uuids::random_generator m_generator; // 用于生成唯一id
+};
+
 }
 
 #endif
diff --git a/src/slic3r/Utils/PrintHost.cpp b/src/slic3r/Utils/PrintHost.cpp
index 99b40223406..faeb7f9cf2c 100644
--- a/src/slic3r/Utils/PrintHost.cpp
+++ b/src/slic3r/Utils/PrintHost.cpp
@@ -50,9 +50,10 @@ PrintHost* PrintHost::get_print_host(DynamicPrintConfig *config)
 
     if (tech == ptFFF) {
         const auto opt = config->option<ConfigOptionEnum<PrintHostType>>("host_type");
-        const auto host_type = opt != nullptr ? opt->value : htOctoPrint;
+        const auto host_type = opt != nullptr ? opt->value : htMoonRaker_mqtt;
 
         switch (host_type) {
+            case htMoonRaker_mqtt: return new Moonraker_Mqtt(config);
             case htMoonRaker: return new Moonraker(config);
             case htOctoPrint: return new OctoPrint(config);
             case htDuet:      return new Duet(config);
diff --git a/src/slic3r/Utils/PrintHost.hpp b/src/slic3r/Utils/PrintHost.hpp
index c9e768c3d29..c69300878f0 100644
--- a/src/slic3r/Utils/PrintHost.hpp
+++ b/src/slic3r/Utils/PrintHost.hpp
@@ -74,7 +74,15 @@ class PrintHost
 
     virtual bool send_gcodes(const std::vector<std::string>& codes, std::string& extraInfo) { return false; }
 
-    virtual bool get_machine_info(const std::vector<std::pair<std::string, std::string>>& targets, nlohmann::json& response) { return false; }
+    virtual bool get_machine_info(const std::vector<std::pair<std::string, std::vector<std::string>>>& targets, nlohmann::json& response) { return false; }
+
+    virtual void async_get_machine_info(const std::vector<std::pair<std::string, std::vector<std::string>>>& targets, std::function<void(const nlohmann::json& response)>) {}
+
+    virtual void async_subscribe_machine_info(std::function<void(const nlohmann::json&)>) {}
+
+    virtual bool connect(wxString& msg, const nlohmann::json& params) { return false; }
+
+    virtual bool disconnect(wxString& msg, const nlohmann::json& params) { return true; }
 
     //Support for cloud webui login
     virtual bool is_cloud() const { return false; }