Support both old and new version of BBL network plugin

src/slic3r/CMakeLists.txt

@@ -574,6 +574,7 @@ set(SLIC3R_GUI_SOURCES
     Utils/ElegooLink.hpp
     Utils/ElegooLink.cpp
     Utils/WebSocketClient.hpp
+    Utils/bambu_networking.hpp
 )
 
 if (WIN32)

src/slic3r/GUI/DeviceManager.cpp

@@ -2623,29 +2623,38 @@ bool MachineObject::is_camera_busy_off()
     return false;
 }
 
-int MachineObject::publish_json(std::string json_str, int qos)
+int MachineObject::publish_json(std::string json_str, int qos, int flag)
 {
+    int rtn = 0;
     if (is_lan_mode_printer()) {
-        return local_publish_json(json_str, qos);
+        rtn = local_publish_json(json_str, qos, flag);
     } else {
-        return cloud_publish_json(json_str, qos);
+        rtn = cloud_publish_json(json_str, qos, flag);
-    }
     }
 
-int MachineObject::cloud_publish_json(std::string json_str, int qos)
+    if (rtn == 0) {
+        BOOST_LOG_TRIVIAL(info) << "publish_json: " << json_str << " code: " << rtn;
+    } else {
+        BOOST_LOG_TRIVIAL(error) << "publish_json: " << json_str << " code: " << rtn;
+    }
+
+    return rtn;
+}
+
+int MachineObject::cloud_publish_json(std::string json_str, int qos, int flag)
 {
     int result = -1;
     if (m_agent)
-        result = m_agent->send_message(dev_id, json_str, qos);
+        result = m_agent->send_message(dev_id, json_str, qos, flag);
 
     return result;
 }
 
-int MachineObject::local_publish_json(std::string json_str, int qos)
+int MachineObject::local_publish_json(std::string json_str, int qos, int flag)
 {
     int result = -1;
     if (m_agent) {
-        result = m_agent->send_message_to_printer(dev_id, json_str, qos);
+        result = m_agent->send_message_to_printer(dev_id, json_str, qos, flag);
     }
     return result;
 }

src/slic3r/GUI/DeviceManager.hpp

@@ -958,9 +958,9 @@ public:
 
     /* Msg for display MsgFn */
     typedef std::function<void(std::string topic, std::string payload)> MsgFn;
-    int publish_json(std::string json_str, int qos = 0);
+    int publish_json(std::string json_str, int qos = 0, int flag = 0);
-    int cloud_publish_json(std::string json_str, int qos = 0);
+    int cloud_publish_json(std::string json_str, int qos = 0, int flag = 0);
-    int local_publish_json(std::string json_str, int qos = 0);
+    int local_publish_json(std::string json_str, int qos = 0, int flag = 0);
     int parse_json(std::string payload, bool key_filed_only = false);
     int publish_gcode(std::string gcode_str);
 

src/slic3r/GUI/GUI_App.cpp

@@ -1166,7 +1166,7 @@ std::string GUI_App::get_plugin_url(std::string name, std::string country_code)
 {
     std::string url = get_http_url(country_code);
 
-    std::string curr_version = SLIC3R_VERSION;
+    std::string curr_version = NetworkAgent::use_legacy_network ? BAMBU_NETWORK_AGENT_VERSION_LEGACY : BAMBU_NETWORK_AGENT_VERSION;
     std::string using_version = curr_version.substr(0, 9) + "00";
     if (name == "cameratools")
         using_version = curr_version.substr(0, 6) + "00.00";
@@ -1542,7 +1542,7 @@ bool GUI_App::check_networking_version()
     if (!network_ver.empty()) {
         BOOST_LOG_TRIVIAL(info) << "get_network_agent_version=" << network_ver;
     }
-    std::string studio_ver = SLIC3R_VERSION;
+    std::string studio_ver = NetworkAgent::use_legacy_network ? BAMBU_NETWORK_AGENT_VERSION_LEGACY : BAMBU_NETWORK_AGENT_VERSION;
     if (network_ver.length() >= 8) {
         if (network_ver.substr(0,8) == studio_ver.substr(0,8)) {
             m_networking_compatible = true;

src/slic3r/Utils/NetworkAgent.cpp

@@ -26,6 +26,15 @@ static void* netwoking_module = NULL;
 static void* source_module = NULL;
 #endif
 
+bool NetworkAgent::use_legacy_network = true;
+
+typedef int (*func_start_print_legacy)(void *agent, PrintParams_Legacy params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn);
+typedef int (*func_start_local_print_with_record_legacy)(void *agent, PrintParams_Legacy params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn);
+typedef int (*func_start_send_gcode_to_sdcard_legacy)(void *agent, PrintParams_Legacy params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn);
+typedef int (*func_start_local_print_legacy)(void *agent, PrintParams_Legacy params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
+typedef int (*func_start_sdcard_print_legacy)(void* agent, PrintParams_Legacy params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
+typedef int (*func_send_message_legacy)(void* agent, std::string dev_id, std::string json_str, int qos);
+typedef int (*func_send_message_to_printer_legacy)(void* agent, std::string dev_id, std::string json_str, int qos);
 
 func_check_debug_consistent         NetworkAgent::check_debug_consistent_ptr = nullptr;
 func_get_version                    NetworkAgent::get_version_ptr = nullptr;
@@ -62,6 +71,8 @@ func_send_message                   NetworkAgent::send_message_ptr = nullptr;
 func_connect_printer                NetworkAgent::connect_printer_ptr = nullptr;
 func_disconnect_printer             NetworkAgent::disconnect_printer_ptr = nullptr;
 func_send_message_to_printer        NetworkAgent::send_message_to_printer_ptr = nullptr;
+func_check_cert                     NetworkAgent::check_cert_ptr = nullptr;
+func_install_device_cert            NetworkAgent::install_device_cert_ptr = nullptr;
 func_start_discovery                NetworkAgent::start_discovery_ptr = nullptr;
 func_change_user                    NetworkAgent::change_user_ptr = nullptr;
 func_is_user_login                  NetworkAgent::is_user_login_ptr = nullptr;
@@ -128,6 +139,47 @@ func_get_model_mall_rating_result   NetworkAgent::get_model_mall_rating_result_p
 func_get_mw_user_preference         NetworkAgent::get_mw_user_preference_ptr = nullptr;
 func_get_mw_user_4ulist             NetworkAgent::get_mw_user_4ulist_ptr     = nullptr;
 
+static PrintParams_Legacy as_legacy(PrintParams& param)
+{
+    PrintParams_Legacy l;
+
+    l.dev_id                = std::move(param.dev_id);
+    l.task_name             = std::move(param.task_name);
+    l.project_name          = std::move(param.project_name);
+    l.preset_name           = std::move(param.preset_name);
+    l.filename              = std::move(param.filename);
+    l.config_filename       = std::move(param.config_filename);
+    l.plate_index           = param.plate_index;
+    l.ftp_folder            = std::move(param.ftp_folder);
+    l.ftp_file              = std::move(param.ftp_file);
+    l.ftp_file_md5          = std::move(param.ftp_file_md5);
+    l.ams_mapping           = std::move(param.ams_mapping);
+    l.ams_mapping_info      = std::move(param.ams_mapping_info);
+    l.connection_type       = std::move(param.connection_type);
+    l.comments              = std::move(param.comments);
+    l.origin_profile_id     = param.origin_profile_id;
+    l.stl_design_id         = param.stl_design_id;
+    l.origin_model_id       = std::move(param.origin_model_id);
+    l.print_type            = std::move(param.print_type);
+    l.dst_file              = std::move(param.dst_file);
+    l.dev_name              = std::move(param.dev_name);
+    l.dev_ip                = std::move(param.dev_ip);
+    l.use_ssl_for_ftp       = param.use_ssl_for_ftp;
+    l.use_ssl_for_mqtt      = param.use_ssl_for_mqtt;
+    l.username              = std::move(param.username);
+    l.password              = std::move(param.password);
+    l.task_bed_leveling     = param.task_bed_leveling;
+    l.task_flow_cali        = param.task_flow_cali;
+    l.task_vibration_cali   = param.task_vibration_cali;
+    l.task_layer_inspect    = param.task_layer_inspect;
+    l.task_record_timelapse = param.task_record_timelapse;
+    l.task_use_ams          = param.task_use_ams;
+    l.task_bed_type         = std::move(param.task_bed_type);
+    l.extra_options         = std::move(param.extra_options);
+
+    return l;
+}
+
 NetworkAgent::NetworkAgent(std::string log_dir)
 {
     if (create_agent_ptr) {
@@ -159,7 +211,7 @@ std::string NetworkAgent::get_libpath_in_current_directory(std::string library_n
     std::string file_name_string(size_needed, 0);
     ::WideCharToMultiByte(0, 0, file_name, wcslen(file_name), file_name_string.data(), size_needed, nullptr, nullptr);
 
-    std::size_t found = file_name_string.find("bambu-studio.exe");
+    std::size_t found = file_name_string.find("orca-slicer.exe");
     if (found == (file_name_string.size() - 16)) {
         lib_path = library_name + ".dll";
         lib_path = file_name_string.replace(found, 16, lib_path);
@@ -272,6 +324,8 @@ int NetworkAgent::initialize_network_module(bool using_backup)
     connect_printer_ptr               =  reinterpret_cast<func_connect_printer>(get_network_function("bambu_network_connect_printer"));
     disconnect_printer_ptr            =  reinterpret_cast<func_disconnect_printer>(get_network_function("bambu_network_disconnect_printer"));
     send_message_to_printer_ptr       =  reinterpret_cast<func_send_message_to_printer>(get_network_function("bambu_network_send_message_to_printer"));
+    check_cert_ptr                    =  reinterpret_cast<func_check_cert>(get_network_function("bambu_network_update_cert"));
+    install_device_cert_ptr           =  reinterpret_cast<func_install_device_cert>(get_network_function("bambu_network_install_device_cert"));
     start_discovery_ptr               =  reinterpret_cast<func_start_discovery>(get_network_function("bambu_network_start_discovery"));
     change_user_ptr                   =  reinterpret_cast<func_change_user>(get_network_function("bambu_network_change_user"));
     is_user_login_ptr                 =  reinterpret_cast<func_is_user_login>(get_network_function("bambu_network_is_user_login"));
@@ -394,6 +448,7 @@ int NetworkAgent::unload_network_module()
     connect_printer_ptr               =  nullptr;
     disconnect_printer_ptr            =  nullptr;
     send_message_to_printer_ptr       =  nullptr;
+    check_cert_ptr                    =  nullptr;
     start_discovery_ptr               =  nullptr;
     change_user_ptr                   =  nullptr;
     is_user_login_ptr                 =  nullptr;
@@ -847,11 +902,15 @@ int NetworkAgent::stop_device_subscribe()
     return ret;
 }
 
-int NetworkAgent::send_message(std::string dev_id, std::string json_str, int qos)
+int NetworkAgent::send_message(std::string dev_id, std::string json_str, int qos, int flag)
 {
     int ret = 0;
     if (network_agent && send_message_ptr) {
-        ret = send_message_ptr(network_agent, dev_id, json_str, qos);
+        if (use_legacy_network) {
+            ret = (reinterpret_cast<func_send_message_legacy>(send_message_ptr))(network_agent, dev_id, json_str, qos);
+        } else {
+            ret = send_message_ptr(network_agent, dev_id, json_str, qos, flag);
+        }
         if (ret)
             BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(" error: network_agent=%1%, ret=%2%, dev_id=%3%, json_str=%4%, qos=%5%")%network_agent %ret %dev_id %json_str %qos;
     }
@@ -881,11 +940,15 @@ int NetworkAgent::disconnect_printer()
     return ret;
 }
 
-int NetworkAgent::send_message_to_printer(std::string dev_id, std::string json_str, int qos)
+int NetworkAgent::send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag)
 {
     int ret = 0;
     if (network_agent && send_message_to_printer_ptr) {
-        ret = send_message_to_printer_ptr(network_agent, dev_id, json_str, qos);
+        if (use_legacy_network) {
+            ret = (reinterpret_cast<func_send_message_to_printer_legacy>(send_message_to_printer_ptr))(network_agent, dev_id, json_str, qos);
+        } else {
+            ret = send_message_to_printer_ptr(network_agent, dev_id, json_str, qos, flag);
+        }
         if (ret)
             BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(" error: network_agent=%1%, ret=%2%, dev_id=%3%, json_str=%4%, qos=%5%")
                 %network_agent %ret %dev_id %json_str %qos;
@@ -893,6 +956,24 @@ int NetworkAgent::send_message_to_printer(std::string dev_id, std::string json_s
     return ret;
 }
 
+int NetworkAgent::check_cert()
+{
+    int ret = 0;
+    if (network_agent && check_cert_ptr) {
+        ret = check_cert_ptr(network_agent);
+        if (ret)
+            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(" error: network_agent=%1%, ret=%2%") % network_agent % ret;
+    }
+    return ret;
+}
+
+void NetworkAgent::install_device_cert(std::string dev_id, bool lan_only)
+{
+    if (network_agent && install_device_cert_ptr) {
+        install_device_cert_ptr(network_agent, dev_id, lan_only);
+    }
+}
+
 bool NetworkAgent::start_discovery(bool start, bool sending)
 {
     bool ret = false;
@@ -1089,7 +1170,11 @@ int NetworkAgent::start_print(PrintParams params, OnUpdateStatusFn update_fn, Wa
 {
     int ret = 0;
     if (network_agent && start_print_ptr) {
+        if (use_legacy_network) {
+            ret = (reinterpret_cast<func_start_print_legacy>(start_print_ptr))(network_agent, as_legacy(params), update_fn, cancel_fn, wait_fn);
+        } else {
             ret = start_print_ptr(network_agent, params, update_fn, cancel_fn, wait_fn);
+        }
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" : network_agent=%1%, ret=%2%, dev_id=%3%, task_name=%4%, project_name=%5%")
                 %network_agent %ret %params.dev_id %params.task_name %params.project_name;
     }
@@ -1100,7 +1185,11 @@ int NetworkAgent::start_local_print_with_record(PrintParams params, OnUpdateStat
 {
     int ret = 0;
     if (network_agent && start_local_print_with_record_ptr) {
+        if (use_legacy_network) {
+            ret = (reinterpret_cast<func_start_local_print_with_record_legacy>(start_local_print_with_record_ptr))(network_agent, as_legacy(params), update_fn, cancel_fn, wait_fn);
+        } else {
             ret = start_local_print_with_record_ptr(network_agent, params, update_fn, cancel_fn, wait_fn);
+        }
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" : network_agent=%1%, ret=%2%, dev_id=%3%, task_name=%4%, project_name=%5%")
                 %network_agent %ret %params.dev_id %params.task_name %params.project_name;
     }
@@ -1111,7 +1200,11 @@ int NetworkAgent::start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusF
 {
     int ret = 0;
     if (network_agent && start_send_gcode_to_sdcard_ptr) {
+        if (use_legacy_network) {
+            ret = (reinterpret_cast<func_start_send_gcode_to_sdcard_legacy>(start_send_gcode_to_sdcard_ptr))(network_agent, as_legacy(params), update_fn, cancel_fn, wait_fn);
+        } else {
             ret = start_send_gcode_to_sdcard_ptr(network_agent, params, update_fn, cancel_fn, wait_fn);
+        }
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" : network_agent=%1%, ret=%2%, dev_id=%3%, task_name=%4%, project_name=%5%")
             % network_agent % ret % params.dev_id % params.task_name % params.project_name;
     }
@@ -1122,7 +1215,11 @@ int NetworkAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_
 {
     int ret = 0;
     if (network_agent && start_local_print_ptr) {
+        if (use_legacy_network) {
+            ret = (reinterpret_cast<func_start_local_print_legacy>(start_local_print_ptr))(network_agent, as_legacy(params), update_fn, cancel_fn);
+        } else {
             ret = start_local_print_ptr(network_agent, params, update_fn, cancel_fn);
+        }
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" : network_agent=%1%, ret=%2%, dev_id=%3%, task_name=%4%, project_name=%5%")
                 %network_agent %ret %params.dev_id %params.task_name %params.project_name;
     }
@@ -1133,7 +1230,11 @@ int NetworkAgent::start_sdcard_print(PrintParams params, OnUpdateStatusFn update
 {
     int ret = 0;
     if (network_agent && start_sdcard_print_ptr) {
+        if (use_legacy_network) {
+            ret = (reinterpret_cast<func_start_sdcard_print_legacy>(start_sdcard_print_ptr))(network_agent, as_legacy(params), update_fn, cancel_fn);
+        } else {
             ret = start_sdcard_print_ptr(network_agent, params, update_fn, cancel_fn);
+        }
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" : network_agent=%1%, ret=%2%, dev_id=%3%, task_name=%4%, project_name=%5%")
             % network_agent % ret % params.dev_id % params.task_name % params.project_name;
     }

src/slic3r/Utils/NetworkAgent.hpp

@@ -38,10 +38,12 @@ typedef int (*func_del_subscribe)(void *agent, std::vector<std::string> dev_list
 typedef void (*func_enable_multi_machine)(void *agent, bool enable);
 typedef int (*func_start_device_subscribe)(void* agent);
 typedef int (*func_stop_device_subscribe)(void* agent);
-typedef int (*func_send_message)(void *agent, std::string dev_id, std::string json_str, int qos);
+typedef int (*func_send_message)(void *agent, std::string dev_id, std::string json_str, int qos, int flag);
 typedef int (*func_connect_printer)(void *agent, std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl);
 typedef int (*func_disconnect_printer)(void *agent);
-typedef int (*func_send_message_to_printer)(void *agent, std::string dev_id, std::string json_str, int qos);
+typedef int (*func_send_message_to_printer)(void *agent, std::string dev_id, std::string json_str, int qos, int flag);
+typedef int (*func_check_cert)(void* agent);
+typedef void (*func_install_device_cert)(void* agent, std::string dev_id, bool lan_only);
 typedef bool (*func_start_discovery)(void *agent, bool start, bool sending);
 typedef int (*func_change_user)(void *agent, std::string user_info);
 typedef bool (*func_is_user_login)(void *agent);
@@ -110,6 +112,7 @@ typedef int (*func_get_model_mall_rating_result)(void *agent, int job_id, std::s
 typedef int (*func_get_mw_user_preference)(void *agent, std::function<void(std::string)> callback);
 typedef int (*func_get_mw_user_4ulist)(void *agent, int seed, int limit, std::function<void(std::string)> callback);
 
+
 //the NetworkAgent class
 class NetworkAgent
 {
@@ -125,6 +128,7 @@ public:
 #endif
     static std::string get_version();
     static void* get_network_function(const char* name);
+    static bool use_legacy_network;
     NetworkAgent(std::string log_dir);
     ~NetworkAgent();
 
@@ -155,10 +159,12 @@ public:
     void enable_multi_machine(bool enable);
     int start_device_subscribe();
     int stop_device_subscribe();
-    int send_message(std::string dev_id, std::string json_str, int qos);
+    int send_message(std::string dev_id, std::string json_str, int qos, int flag);
     int connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl);
     int disconnect_printer();
-    int send_message_to_printer(std::string dev_id, std::string json_str, int qos);
+    int send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag);
+    int check_cert();
+    void install_device_cert(std::string dev_id, bool lan_only);
     bool start_discovery(bool start, bool sending);
     int change_user(std::string user_info);
     bool is_user_login();
@@ -266,6 +272,8 @@ private:
     static func_connect_printer                connect_printer_ptr;
     static func_disconnect_printer             disconnect_printer_ptr;
     static func_send_message_to_printer        send_message_to_printer_ptr;
+    static func_check_cert                     check_cert_ptr;
+    static func_install_device_cert            install_device_cert_ptr;
     static func_start_discovery                start_discovery_ptr;
     static func_change_user                    change_user_ptr;
     static func_is_user_login                  is_user_login_ptr;

src/slic3r/Utils/bambu_networking.hpp

@@ -36,6 +36,7 @@ namespace BBL {
 #define BAMBU_NETWORK_ERR_PARSE_CONFIG_FAILED           -23
 #define BAMBU_NETWORK_ERR_NO_CORRESPONDING_BUCKET       -24
 #define BAMBU_NETWORK_ERR_GET_INSTANCE_ID_FAILED        -25
+#define BAMBU_NETWORK_SIGNED_ERROR                      -26
 
 //bind error
 #define BAMBU_NETWORK_ERR_BIND_CREATE_SOCKET_FAILED          -1010 //failed to create socket
@@ -78,6 +79,7 @@ namespace BBL {
 #define BAMBU_NETWORK_ERR_PRINT_SP_PATCH_PROJECT_FAILED             -3110 //failed to patch project
 #define BAMBU_NETWORK_ERR_PRINT_SP_POST_TASK_FAILED                 -3120 //failed to post task
 #define BAMBU_NETWORK_ERR_PRINT_SP_WAIT_PRINTER_FAILED              -3130 //failed to wait the ack from printer
+#define BAMBU_NETOWRK_ERR_PRINT_SP_ENC_FLAG_NOT_READY               -3140 //enc parse not ready
 
 //start_local_print   error
 #define BAMBU_NETWORK_ERR_PRINT_LP_FILE_OVER_SIZE                   -4010 //the size of the uploaded file cannot exceed 1 GB
@@ -95,7 +97,8 @@ namespace BBL {
 #define BAMBU_NETWORK_LIBRARY               "bambu_networking"
 #define BAMBU_NETWORK_AGENT_NAME            "bambu_network_agent"
 
-#define BAMBU_NETWORK_AGENT_VERSION         "01.10.01.01"
+#define BAMBU_NETWORK_AGENT_VERSION_LEGACY  "01.10.01.01"
+#define BAMBU_NETWORK_AGENT_VERSION         "02.00.02.50"
 
 //iot preset type strings
 #define IOT_PRINTER_TYPE_STRING     "printer"
@@ -187,7 +190,7 @@ struct detectResult {
 };
 
 /* print job*/
-struct PrintParams {
+struct PrintParams_Legacy {
     /* basic info */
     std::string     dev_id;
     std::string     task_name;
@@ -228,6 +231,53 @@ struct PrintParams {
     std::string     extra_options;
 };
 
+/* print job*/
+struct PrintParams {
+    /* basic info */
+    std::string     dev_id;
+    std::string     task_name;
+    std::string     project_name;
+    std::string     preset_name;
+    std::string     filename;
+    std::string     config_filename;
+    int             plate_index;
+    std::string     ftp_folder;
+    std::string     ftp_file;
+    std::string     ftp_file_md5;
+    std::string     ams_mapping;
+    std::string     ams_mapping2;
+    std::string     ams_mapping_info;
+    std::string     nozzles_info;
+    std::string     connection_type;
+    std::string     comments;
+    int             origin_profile_id = 0;
+    int             stl_design_id = 0;
+    std::string     origin_model_id;
+    std::string     print_type;
+    std::string     dst_file;
+    std::string     dev_name;
+
+    /* access options */
+    std::string     dev_ip;
+    bool            use_ssl_for_ftp;
+    bool            use_ssl_for_mqtt;
+    std::string     username;
+    std::string     password;
+
+    /*user options */
+    bool            task_bed_leveling;      /* bed leveling of task */
+    bool            task_flow_cali;         /* flow calibration of task */
+    bool            task_vibration_cali;    /* vibration calibration of task */
+    bool            task_layer_inspect;     /* first layer inspection of task */
+    bool            task_record_timelapse;  /* record timelapse of task */
+    bool            task_use_ams;
+    std::string     task_bed_type;
+    std::string     extra_options;
+    int             auto_bed_leveling{ 0 };
+    int             auto_flow_cali{ 0 };
+    int             auto_offset_cali{ 0 };
+};
+
 struct TaskQueryParams
 {
     std::string dev_id;
@@ -253,6 +303,14 @@ struct CertificateInformation {
     std::string     serial_number;
 };
 
+
+enum class MessageFlag : int
+{
+    MSG_FLAG_NONE = 0,
+    MSG_SIGN      = 1 << 0,
+    MSG_ENCRYPT   = 1 << 1,
+};
+
 }
 
 #endif