Slic3r::SnapmakerPrinterAgent Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/SnapmakerPrinterAgent.hpp>

Inheritance diagram for Slic3r::SnapmakerPrinterAgent:

Collaboration diagram for Slic3r::SnapmakerPrinterAgent:

Public Member Functions
	SnapmakerPrinterAgent (std::string log_dir)
	~SnapmakerPrinterAgent () override=default
AgentInfo	get_agent_info () override
bool	fetch_filament_info (std::string dev_id, FilamentSyncMode sync_mode=FilamentSyncMode::pull) override
void	set_cloud_agent (std::shared_ptr< ICloudServiceAgent > cloud) override
int	send_message (std::string dev_id, std::string json_str, int qos, int flag) override
int	connect_printer (const PrinterConnectionParams &params) override
int	disconnect_printer () override
int	send_message_to_printer (std::string dev_id, std::string json_str, int qos, int flag) override
bool	start_discovery (bool start, bool sending) override
int	bind_detect (std::string dev_ip, std::string sec_link, detectResult &detect) override
int	set_server_callback (OnServerErrFn fn) override
std::string	get_user_selected_machine () override
int	set_user_selected_machine (std::string dev_id) override
int	start_print (PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override
int	start_local_print_with_record (PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override
int	start_send_gcode_to_sdcard (PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override
int	start_local_print (PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override
int	start_sdcard_print (PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override
int	set_on_ssdp_msg_fn (OnMsgArrivedFn fn) override
int	set_on_printer_connected_fn (OnPrinterConnectedFn fn) override
int	set_on_subscribe_failure_fn (GetSubscribeFailureFn fn) override
int	set_on_message_fn (OnMessageFn fn) override
int	set_on_user_message_fn (OnMessageFn fn) override
int	set_on_local_connect_fn (OnLocalConnectedFn fn) override
int	set_on_local_message_fn (OnMessageFn fn) override
int	set_queue_on_main_fn (QueueOnMainFn fn) override
FilamentSyncMode	get_filament_sync_mode () const override
virtual int	command_ams_refresh_rfid (std::string, int, int, int, bool)
virtual int	command_ams_calibrate (std::string, int, int, bool)
virtual int	command_ams_select_tray (std::string, std::string, int, bool)
virtual int	command_start_camera (std::string)
virtual int	command_xyz_abs (std::string dev_id, int sequence_id, bool lan_mode)
virtual int	command_auto_leveling (std::string dev_id, int sequence_id, bool lan_mode)
virtual int	command_go_home (std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode)
virtual int	command_set_bed (std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode)
virtual int	command_set_nozzle (std::string dev_id, int temp, int sequence_id, bool lan_mode)
virtual int	command_axis_control (std::string dev_id, std::string axis, double unit, double input_val, int speed, bool is_core_xy, bool supports_mqtt_axis_control, int sequence_id, bool lan_mode)
virtual std::string	default_lan_username () const
virtual int	check_cert ()
virtual void	install_device_cert (std::string dev_id, bool lan_only)
virtual int	ping_bind (std::string ping_code)
virtual int	bind (std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn)
virtual int	unbind (std::string dev_id)
virtual int	request_bind_ticket (std::string *ticket)
virtual int	get_hms_snapshot (std::string dev_id, std::string file_name, std::function< void(std::string, int)> callback)
virtual int	start_subscribe (std::string module)
virtual int	stop_subscribe (std::string module)
virtual int	add_subscribe (std::vector< std::string > dev_list)
virtual int	del_subscribe (std::vector< std::string > dev_list)
virtual CameraStreamMode	get_camera_stream_mode () const
virtual std::string	to_orca_filament_id (const std::string &printer_filament_id) const
virtual std::string	from_orca_filament_id (const std::string &orca_filament_id) const
virtual std::string	get_camera_url () const

Static Public Member Functions
static AgentInfo	get_agent_info_static ()

Protected Member Functions
void	build_ams_payload (int ams_count, int max_lane_index, const std::vector< AmsTrayData > &trays)
virtual bool	init_device_info (const std::string &dev_id, const std::string &dev_ip, const std::string &username, const std::string &password, bool use_ssl, const std::string &port)
virtual bool	fetch_device_info (const std::string &base_url, const std::string &api_key, MoonrakerDeviceInfo &info, std::string &error, const std::function< bool()> &cancelled) const
void	start_status_stream (const std::string &dev_id, const std::string &base_url, const std::string &api_key)
void	stop_status_stream ()
bool	is_numeric (const std::string &value)
std::string	normalize_base_url (bool use_ssl, const std::string &host, const std::string &port)
std::string	sanitize_filename (const std::string &filename)
std::string	join_url (const std::string &base_url, const std::string &path) const

Static Protected Member Functions
static std::string	trim_and_upper (const std::string &input)
static std::string	map_filament_type_to_generic_id (const std::string &filament_type)

Protected Attributes
struct Slic3r::MoonrakerPrinterAgent::MoonrakerDeviceInfo	device_info
struct Slic3r::MoonrakerPrinterAgent::StatusStreamTimings	ws_timings
std::recursive_mutex	state_mutex

Private Member Functions
int	handle_request (const std::string &dev_id, const std::string &json_str)
int	send_version_info (const std::string &dev_id)
int	send_access_code (const std::string &dev_id)
bool	fetch_object_list (const std::string &base_url, const std::string &api_key, std::set< std::string > &objects, std::string &error) const
bool	query_printer_status (const std::string &base_url, const std::string &api_key, nlohmann::json &status, std::string &error, const std::function< bool()> &cancelled) const
bool	send_gcode_sync (const std::string &dev_id, const std::string &gcode) const
void	send_gcode_async (const std::string &dev_id, const std::string &gcode, std::function< void(bool)> on_result={}) const
void	announce_printhost_device ()
void	dispatch_local_connect (int state, const std::string &dev_id, const std::string &msg)
void	dispatch_printer_connected (const std::string &dev_id)
void	dispatch_message (const std::string &dev_id, const std::string &payload)
void	join_stopped_status_stream ()
void	run_status_stream (std::string dev_id, std::string base_url, std::string api_key, StatusStreamTimings timings)
void	handle_ws_message (const std::string &dev_id, const std::string &payload)
void	send_heartbeat_if_due (const std::string &dev_id, std::chrono::milliseconds interval)
void	update_status_cache (const nlohmann::json &updates)
nlohmann::json	build_print_payload_locked () const
int	pause_print (const std::string &dev_id)
int	resume_print (const std::string &dev_id)
int	cancel_print (const std::string &dev_id)
bool	upload_gcode (const std::string &local_path, const std::string &filename, const std::string &base_url, const std::string &api_key, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
bool	send_jsonrpc_command (const std::string &base_url, const std::string &api_key, const nlohmann::json &request, std::string &response) const
void	perform_connection_async (const std::string &dev_id, const std::string &base_url, const std::string &api_key, uint64_t generation)
bool	fetch_hh_filament_info (std::vector< AmsTrayData > &trays, int &max_lane_index)
bool	fetch_moonraker_filament_data (std::vector< AmsTrayData > &trays, int &max_lane_index)
int	publish_command_json (std::string dev_id, const nlohmann::json &j, bool lan_mode)

Static Private Member Functions
static std::string	combine_filament_type (const std::string &type, const std::string &sub_type)
static std::string	safe_json_string (const nlohmann::json &obj, const char *key)
static int	safe_json_int (const nlohmann::json &obj, const char *key)
static std::string	safe_array_string (const nlohmann::json &arr, int idx)
static int	safe_array_int (const nlohmann::json &arr, int idx)
static std::string	normalize_color_value (const std::string &color)

Private Attributes
std::string	ssdp_announced_host
std::string	ssdp_announced_id
std::shared_ptr< ICloudServiceAgent >	m_cloud_agent
std::string	selected_machine
OnMsgArrivedFn	on_ssdp_msg_fn
OnPrinterConnectedFn	on_printer_connected_fn
GetSubscribeFailureFn	on_subscribe_failure_fn
OnMessageFn	on_message_fn
OnMessageFn	on_user_message_fn
OnLocalConnectedFn	on_local_connect_fn
OnMessageFn	on_local_message_fn
QueueOnMainFn	queue_on_main_fn
OnServerErrFn	on_server_err_fn
std::recursive_mutex	payload_mutex
nlohmann::json	status_cache
std::atomic< int >	next_jsonrpc_id {1}
std::set< std::string >	available_objects
std::atomic< bool >	ws_stop {false}
std::atomic< bool >	ws_reconnect_requested {false}
std::atomic< uint64_t >	ws_last_emit_ms {0}
std::thread	ws_thread
std::mutex	ws_abort_mutex
std::function< void()>	ws_abort
std::atomic< uint64_t >	ws_last_dispatch_ms {0}
std::string	last_print_state
std::atomic< uint64_t >	connect_generation {0}
std::thread	connect_thread
std::recursive_mutex	connect_mutex

Static Private Attributes
static constexpr uint64_t	STATUS_UPDATE_INTERVAL_MS = 1000

Detailed Description

Constructor & Destructor Documentation

SnapmakerPrinterAgent()

Slic3r::SnapmakerPrinterAgent::SnapmakerPrinterAgent ( std::string log_dir )

explicit

: MoonrakerPrinterAgent(std::move(log_dir)) {}

References Slic3r::MoonrakerPrinterAgent::MoonrakerPrinterAgent().

Here is the call graph for this function:

~SnapmakerPrinterAgent()

Slic3r::SnapmakerPrinterAgent::~SnapmakerPrinterAgent ( )

overridedefault

Member Function Documentation

add_subscribe()

virtual int Slic3r::IPrinterAgent::add_subscribe ( std::vector< std::string > dev_list )

inlinevirtualinherited

Subscribe to push streams for specific device identifiers.

Reimplemented in Slic3r::BBLPrinterAgent.

{ (void) dev_list; return BAMBU_NETWORK_SUCCESS; }

References BAMBU_NETWORK_SUCCESS.

announce_printhost_device()

void Slic3r::MoonrakerPrinterAgent::announce_printhost_device ( )

privateinherited

{
    OnMsgArrivedFn ssdp_fn;
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        ssdp_fn = on_ssdp_msg_fn;
        if (!ssdp_fn || device_info.dev_id.empty() || device_info.dev_ip.empty() || device_info.base_url.empty()) {
            return;
        }
        if (ssdp_announced_host == device_info.base_url && !ssdp_announced_id.empty()) {
            return;
        }
    }
 
    // Never asks the printer, since discovery runs on the GUI thread and an unreachable printer would freeze it
    const std::string dev_name = device_info.model_name.empty() ? "Moonraker Printer" : device_info.model_name;
 
    const std::string model_id = device_info.model_id;
 
    nlohmann::json payload;
    payload["dev_name"]     = dev_name;
    payload["dev_id"]       = device_info.dev_id;
    payload["dev_ip"]       = device_info.dev_ip;
    payload["dev_type"]     = model_id.empty() ? dev_name : model_id;
    payload["dev_signal"]   = "0";
    payload["connect_type"] = "lan";
    payload["bind_state"]   = "free";
    payload["sec_link"]     = "secure";
    payload["ssdp_version"] = "v1";
 
    ssdp_fn(payload.dump());
 
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        ssdp_announced_host = device_info.base_url;
        ssdp_announced_id   = device_info.dev_id;
 
        // Set this as the selected machine if nothing is currently selected
        if (selected_machine.empty()) {
            selected_machine = device_info.dev_id;
        }
    }
}

References announce_printhost_device(), device_info, on_ssdp_msg_fn, selected_machine, ssdp_announced_host, ssdp_announced_id, and state_mutex.

Referenced by announce_printhost_device(), and start_discovery().

Here is the call graph for this function:

Here is the caller graph for this function:

bind()

virtual int Slic3r::IPrinterAgent::bind ( std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn )

inlinevirtualinherited

Execute the multi-stage printer binding workflow.

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        (void) dev_ip;
        (void) dev_id;
        (void) dev_model;
        (void) sec_link;
        (void) timezone;
        (void) improved;
        (void) update_fn;
        return BAMBU_NETWORK_SUCCESS;
    }

References BAMBU_NETWORK_SUCCESS.

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

bind_detect()

int Slic3r::MoonrakerPrinterAgent::bind_detect ( std::string dev_ip, std::string sec_link, detectResult & detect )

overridevirtualinherited

Perform binding detection/handshake on a LAN printer.

Implements Slic3r::IPrinterAgent.

{
    (void) sec_link;
 
    detect.dev_id   = device_info.dev_id.empty() ? dev_ip : device_info.dev_id;
    detect.model_id = device_info.model_id.empty() ? device_info.model_name : device_info.model_id;
    // Prefer fetched hostname, then preset model name, then generic fallback
    detect.dev_name     = device_info.dev_name.empty() ? dev_ip : device_info.dev_name;
    detect.model_id     = device_info.model_id;
    detect.version      = device_info.version;
    detect.connect_type = "lan";
    detect.bind_state   = "free";
 
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, bind_detect(), Slic3r::detectResult::bind_state, Slic3r::detectResult::connect_type, Slic3r::detectResult::dev_id, Slic3r::detectResult::dev_name, device_info, Slic3r::detectResult::model_id, and Slic3r::detectResult::version.

Referenced by bind_detect().

Here is the call graph for this function:

Here is the caller graph for this function:

build_ams_payload()

void Slic3r::MoonrakerPrinterAgent::build_ams_payload ( int ams_count, int max_lane_index, const std::vector< AmsTrayData > & trays )

protectedinherited

{
 
    // Look up MachineObject via DeviceManager
    auto* dev_manager = GUI::wxGetApp().getDeviceManager();
    if (!dev_manager) {
        return;
    }
    MachineObject* obj = dev_manager->get_my_machine(device_info.dev_id);
    if (!obj) {
        return;
    }
 
    // Build BBL-format JSON for DevFilaSystemParser::ParseV1_0
    nlohmann::json ams_json = nlohmann::json::object();
    nlohmann::json ams_array = nlohmann::json::array();
 
    // Calculate ams_exist_bits and tray_exist_bits
    unsigned long ams_exist_bits = 0;
    unsigned long tray_exist_bits = 0;
 
    for (int ams_id = 0; ams_id < ams_count; ++ams_id) {
        ams_exist_bits |= (1 << ams_id);
 
        nlohmann::json ams_unit = nlohmann::json::object();
        ams_unit["id"] = std::to_string(ams_id);
        ams_unit["info"] = "0002";  // treat as AMS_LITE 
 
        nlohmann::json tray_array = nlohmann::json::array();
        int max_slot_in_this_ams = std::min(3, max_lane_index - ams_id * 4);
        for (int slot_id = 0; slot_id <= max_slot_in_this_ams; ++slot_id) {
            int slot_index = ams_id * 4 + slot_id;
 
            // Find tray with matching slot_index
            const AmsTrayData* tray = nullptr;
            for (const auto& t : trays) {
                if (t.slot_index == slot_index) {
                    tray = &t;
                    break;
                }
            }
 
            nlohmann::json tray_json = nlohmann::json::object();
            tray_json["id"] = std::to_string(slot_id);
            tray_json["tag_uid"] = "0000000000000000";
 
            if (tray && tray->has_filament) {
                tray_exist_bits |= (1 << slot_index);
 
                tray_json["tray_info_idx"] = tray->tray_info_idx;
                tray_json["tray_type"] = tray->tray_type;
                tray_json["tray_color"] = normalize_color_value(tray->tray_color);
 
                // Add temperature data if provided
                if (tray->bed_temp > 0) {
                    tray_json["bed_temp"] = std::to_string(tray->bed_temp);
                }
                if (tray->nozzle_temp > 0) {
                    tray_json["nozzle_temp_max"] = std::to_string(tray->nozzle_temp);
                }
            } else {
                tray_json["tray_info_idx"] = "";
                tray_json["tray_type"] = "";
                tray_json["tray_color"] = "00000000";
                tray_json["tray_slot_placeholder"] = "1";
            }
 
            tray_array.push_back(tray_json);
        }
        ams_unit["tray"] = tray_array;
        ams_array.push_back(ams_unit);
    }
 
    // Format as hex strings (matching BBL protocol)
    std::ostringstream ams_exist_ss;
    ams_exist_ss << std::hex << std::uppercase << ams_exist_bits;
    std::ostringstream tray_exist_ss;
    tray_exist_ss << std::hex << std::uppercase << tray_exist_bits;
 
    ams_json["ams"] = ams_array;
    ams_json["ams_exist_bits"] = ams_exist_ss.str();
    ams_json["tray_exist_bits"] = tray_exist_ss.str();
 
    // Wrap in the expected structure for ParseV1_0
    nlohmann::json print_json = nlohmann::json::object();
    print_json["ams"] = ams_json;
 
    // Call the parser to populate DevFilaSystem
    DevFilaSystemParser::ParseV1_0(print_json, obj, obj->GetFilaSystem().get(), false);
    BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::build_ams_payload: Parsed " << trays.size() << " trays";
 
    // Set printer_type so update_sync_status() can match it against the preset's printer type.
    // Without this, the comparison fails and all sync badges are cleared.
    obj->printer_type = device_info.model_id;
 
    // Set push counters so is_info_ready() returns true for pull-mode agents.
    if (obj->m_push_count == 0) {
        obj->m_push_count = 1;
    }
    if (obj->m_full_msg_count == 0) {
        obj->m_full_msg_count = 1;
    }
    obj->last_push_time = std::chrono::system_clock::now();
 
    // Set storage state - Moonraker printers use virtual_sdcard, storage is always available.
    // This is required for SelectMachineDialog to allow printing (otherwise it blocks with "No SD card").
    obj->GetStorage()->set_sdcard_state(DevStorage::HAS_SDCARD_NORMAL);
 
    // Populate module_vers so is_info_ready() passes the version check.
    // Moonraker printers don't have BBL-style version info, but we need a non-empty map.
    if (obj->module_vers.empty()) {
        DevFirmwareVersionInfo ota_info;
        ota_info.name = "ota";
        ota_info.sw_ver = "1.0.0";  // Placeholder version for Moonraker printers
        obj->module_vers.emplace("ota", ota_info);
    }
}

References Slic3r::MoonrakerPrinterAgent::AmsTrayData::bed_temp, build_ams_payload(), device_info, Slic3r::MachineObject::GetFilaSystem(), Slic3r::MachineObject::GetStorage(), Slic3r::MoonrakerPrinterAgent::AmsTrayData::has_filament, Slic3r::DevStorage::HAS_SDCARD_NORMAL, Slic3r::MachineObject::last_push_time, Slic3r::MachineObject::m_full_msg_count, Slic3r::MachineObject::m_push_count, Slic3r::MachineObject::module_vers, Slic3r::DevFirmwareVersionInfo::name, normalize_color_value(), Slic3r::MoonrakerPrinterAgent::AmsTrayData::nozzle_temp, Slic3r::DevFilaSystemParser::ParseV1_0(), Slic3r::MachineObject::printer_type, Slic3r::DevStorage::set_sdcard_state(), Slic3r::DevFirmwareVersionInfo::sw_ver, Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_color, Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_info_idx, and Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_type.

Referenced by build_ams_payload(), Slic3r::CrealityPrintAgent::fetch_filament_info(), fetch_filament_info(), Slic3r::QidiPrinterAgent::fetch_filament_info(), and Slic3r::SnapmakerPrinterAgent::fetch_filament_info().

Here is the call graph for this function:

Here is the caller graph for this function:

build_print_payload_locked()

nlohmann::json Slic3r::MoonrakerPrinterAgent::build_print_payload_locked ( ) const

privateinherited

{
    nlohmann::json payload;
    payload["print"]["command"]            = "push_status";
    payload["print"]["msg"]                = 0;
    payload["print"]["support_mqtt_alive"] = true;
 
    std::string state = "IDLE";
    if (status_cache.contains("print_stats") && status_cache["print_stats"].contains("state") &&
        status_cache["print_stats"]["state"].is_string()) {
        state = map_moonraker_state(status_cache["print_stats"]["state"].get<std::string>());
    }
    payload["print"]["gcode_state"] = state;
 
    // Map Moonraker state to Bambu stage numbers
    int mc_print_stage = 0;
    if (status_cache.contains("print_stats") && status_cache["print_stats"].contains("state")) {
        std::string mr_state = status_cache["print_stats"]["state"].get<std::string>();
        if (mr_state == "printing")
            mc_print_stage = 1;
        else if (mr_state == "paused")
            mc_print_stage = 2;
        else if (mr_state == "complete")
            mc_print_stage = 3;
        else if (mr_state == "error")
            mc_print_stage = 4;
    }
    payload["print"]["mc_print_stage"] = mc_print_stage;
 
    // Leave mc_print_error_code and print_error at 0
    // UI expects numeric HMS codes - setting to 1 shows generic error dialog
    // Only set if real mapping from Moonraker error strings to HMS codes is defined
    payload["print"]["mc_print_error_code"] = 0;
    payload["print"]["print_error"]         = 0;
 
    // Map homed axes to bit field: X=bit0, Y=bit1, Z=bit2
    // WARNING: This only sets bits 0-2, clearing support flags (bit 3+)
    // Bit 3 = 220V voltage, bit 4 = auto recovery, etc.
    // This is acceptable for Moonraker (no AMS, different feature set)
    int home_flag = 0;
    if (status_cache.contains("toolhead") && status_cache["toolhead"].contains("homed_axes")) {
        std::string homed = status_cache["toolhead"]["homed_axes"].get<std::string>();
        if (homed.find('X') != std::string::npos)
            home_flag |= 1; // bit 0
        if (homed.find('Y') != std::string::npos)
            home_flag |= 2; // bit 1
        if (homed.find('Z') != std::string::npos)
            home_flag |= 4; // bit 2
    }
    payload["print"]["home_flag"] = home_flag;
 
    // Moonraker doesn't provide temperature ranges via API - use hardcoded defaults
    payload["print"]["nozzle_temp_range"] = {100, 370}; // Typical Klipper range
    payload["print"]["bed_temp_range"]    = {0, 120};   // Typical bed range
 
    payload["print"]["support_send_to_sd"] = true;
    // Detect bed_leveling support from available objects (bed_mesh or probe)
    // Default to 0 (not supported) if neither object exists
    bool has_bed_leveling                    = (available_objects.count("bed_mesh") != 0 || available_objects.count("probe") != 0);
    payload["print"]["support_bed_leveling"] = has_bed_leveling ? 1 : 0;
 
    const nlohmann::json* extruder = nullptr;
    if (status_cache.contains("extruder") && status_cache["extruder"].is_object()) {
        extruder = &status_cache["extruder"];
    } else {
        for (const auto& item : status_cache.items()) {
            if (item.value().is_object() && item.key().rfind("extruder", 0) == 0) {
                extruder = &item.value();
                break;
            }
        }
    }
 
    if (extruder) {
        if (extruder->contains("temperature") && (*extruder)["temperature"].is_number()) {
            payload["print"]["nozzle_temper"] = (*extruder)["temperature"].get<float>();
        }
        if (extruder->contains("target") && (*extruder)["target"].is_number()) {
            payload["print"]["nozzle_target_temper"] = (*extruder)["target"].get<float>();
        }
    }
 
    if (status_cache.contains("heater_bed") && status_cache["heater_bed"].is_object()) {
        const auto& bed = status_cache["heater_bed"];
        if (bed.contains("temperature") && bed["temperature"].is_number()) {
            payload["print"]["bed_temper"] = bed["temperature"].get<float>();
        }
        if (bed.contains("target") && bed["target"].is_number()) {
            payload["print"]["bed_target_temper"] = bed["target"].get<float>();
        }
    }
 
    // Handle fan speed - only if Moonraker provides "fan" object (standard API)
    if (status_cache.contains("fan") && status_cache["fan"].is_object() && !status_cache["fan"].empty()) {
        const auto& fan = status_cache["fan"];
        if (fan.contains("speed") && fan["speed"].is_number()) {
            double speed = fan["speed"].get<double>();
            int    pwm   = 0;
            if (speed <= 1.0) {
                pwm = static_cast<int>(speed * 255.0 + 0.5);
            } else {
                pwm = static_cast<int>(speed + 0.5);
            }
            pwm                          = std::clamp(pwm, 0, 255);
            payload["print"]["fan_gear"] = pwm;
        } else if (fan.contains("power") && fan["power"].is_number()) {
            double power                 = fan["power"].get<double>();
            int    pwm                   = static_cast<int>(power * 255.0 + 0.5);
            pwm                          = std::clamp(pwm, 0, 255);
            payload["print"]["fan_gear"] = pwm;
        }
    }
    // If "fan" object doesn't exist, don't include fan_gear in payload
 
    if (status_cache.contains("print_stats") && status_cache["print_stats"].contains("filename") &&
        status_cache["print_stats"]["filename"].is_string()) {
        payload["print"]["subtask_name"] = status_cache["print_stats"]["filename"].get<std::string>();
    }
 
    if (status_cache.contains("print_stats") && status_cache["print_stats"].contains("filename")) {
        payload["print"]["gcode_file"] = status_cache["print_stats"]["filename"];
    }
 
    int mc_percent = -1;
    if (status_cache.contains("virtual_sdcard") && status_cache["virtual_sdcard"].contains("progress") &&
        status_cache["virtual_sdcard"]["progress"].is_number()) {
        const double progress = status_cache["virtual_sdcard"]["progress"].get<double>();
        if (progress >= 0.0) {
            mc_percent = std::clamp(static_cast<int>(progress * 100.0 + 0.5), 0, 100);
        }
    }
    if (mc_percent >= 0) {
        payload["print"]["mc_percent"] = mc_percent;
    }
 
    if (status_cache.contains("print_stats") && status_cache["print_stats"].contains("total_duration") &&
        status_cache["print_stats"].contains("print_duration") && status_cache["print_stats"]["total_duration"].is_number() &&
        status_cache["print_stats"]["print_duration"].is_number()) {
        const double total   = status_cache["print_stats"]["total_duration"].get<double>();
        const double elapsed = status_cache["print_stats"]["print_duration"].get<double>();
        if (total > 0.0 && elapsed >= 0.0) {
            const auto remaining_minutes          = std::max(0, static_cast<int>((total - elapsed) / 60.0));
            payload["print"]["mc_remaining_time"] = remaining_minutes;
        }
    }
 
    const auto now_ms = static_cast<uint64_t>(
        std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
    payload["t_utc"] = now_ms;
 
    return payload;
}

References available_objects, build_print_payload_locked(), anonymous_namespace{MoonrakerPrinterAgent.cpp}::map_moonraker_state(), and status_cache.

Referenced by build_print_payload_locked(), handle_ws_message(), and send_heartbeat_if_due().

Here is the call graph for this function:

Here is the caller graph for this function:

cancel_print()

int Slic3r::MoonrakerPrinterAgent::cancel_print ( const std::string & dev_id )

privateinherited

{
    send_gcode_async(dev_id, "CANCEL_PRINT");
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, cancel_print(), and send_gcode_async().

Referenced by cancel_print(), and handle_request().

Here is the call graph for this function:

Here is the caller graph for this function:

check_cert()

virtual int Slic3r::IPrinterAgent::check_cert ( )

inlinevirtualinherited

Validate current user certificates for the printer.

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

{ return BAMBU_NETWORK_SUCCESS; }

References BAMBU_NETWORK_SUCCESS.

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

combine_filament_type()

std::string Slic3r::SnapmakerPrinterAgent::combine_filament_type ( const std::string & type, const std::string & sub_type )

staticprivate

{
    const std::string base = trim_and_upper(type);
    const std::string sub  = trim_and_upper(sub_type);
 
    if (base.empty())
        return "PLA";
 
    if (sub.empty() || sub == "NONE")
        return base;
 
    if (sub == "CF")
        return base + "-CF";
    if (sub == "GF")
        return base + "-GF";
    if (sub == "SNAPSPEED" || sub == "HS")
        return base + " HIGH SPEED";
    if (sub == "SILK")
        return base + " SILK";
    if (sub == "WOOD")
        return base + " WOOD";
    if (sub == "MATTE")
        return base + " MATTE";
    if (sub == "MARBLE")
        return base + " MARBLE";
 
    // Unrecognized sub-type (brand names like Polylite, Basic, etc.) -- use base type only
    return base;
}

References Slic3r::MoonrakerPrinterAgent::trim_and_upper().

Referenced by fetch_filament_info().

Here is the call graph for this function:

Here is the caller graph for this function:

command_ams_calibrate()

virtual int Slic3r::IPrinterAgent::command_ams_calibrate ( std::string , int , int , bool  )

inlinevirtualinherited

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }

References ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

command_ams_refresh_rfid()

virtual int Slic3r::IPrinterAgent::command_ams_refresh_rfid ( std::string , int , int , int , bool  )

inlinevirtualinherited

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }

References ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

command_ams_select_tray()

virtual int Slic3r::IPrinterAgent::command_ams_select_tray ( std::string , std::string , int , bool  )

inlinevirtualinherited

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }

References ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

command_auto_leveling()

virtual int Slic3r::IPrinterAgent::command_auto_leveling ( std::string dev_id, int sequence_id, bool lan_mode )

inlinevirtualinherited

Reimplemented in Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        nlohmann::json j;
        j["print"]["command"]     = "gcode_line";
        j["print"]["param"]       = "G29 \n";
        j["print"]["sequence_id"] = std::to_string(sequence_id);
        return publish_command_json(dev_id, j, lan_mode);
    }

References publish_command_json().

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the call graph for this function:

Here is the caller graph for this function:

command_axis_control()

virtual int Slic3r::IPrinterAgent::command_axis_control ( std::string dev_id, std::string axis, double unit, double input_val, int speed, bool is_core_xy, bool supports_mqtt_axis_control, int sequence_id, bool lan_mode )

inlinevirtualinherited

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        (void) supports_mqtt_axis_control;
 
        double value = input_val;
        if (!is_core_xy && (axis == "Y" || axis == "Z"))
            value = -input_val;
 
        std::string value_str = (boost::format("%.1f") % (value * unit)).str();
        std::string gcode;
        if (axis == "X" || axis == "Y" || axis == "Z") {
            gcode = (boost::format("G91 \nG1 %1%%2% F%3%\nG90 \n") % axis % value_str % speed).str();
        } else if (axis == "E") {
            gcode = (boost::format("M83 \nG0 %1%%2% F%3%\n") % axis % value_str % speed).str();
        } else {
            return -1;
        }
 
        nlohmann::json j;
        j["print"]["command"]     = "gcode_line";
        j["print"]["param"]       = gcode;
        j["print"]["sequence_id"] = std::to_string(sequence_id);
        return publish_command_json(dev_id, j, lan_mode);
    }

References publish_command_json().

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the call graph for this function:

Here is the caller graph for this function:

command_go_home()

virtual int Slic3r::IPrinterAgent::command_go_home ( std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode )

inlinevirtualinherited

Reimplemented in Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        nlohmann::json j;
        j["print"]["sequence_id"] = std::to_string(sequence_id);
        if (supports_mqtt_homing) {
            j["print"]["command"] = "back_to_center";
        } else {
            j["print"]["command"] = "gcode_line";
            j["print"]["param"]   = is_printing ? "G28 X\n" : "G28 \n";
        }
        return publish_command_json(dev_id, j, lan_mode);
    }

References publish_command_json().

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the call graph for this function:

Here is the caller graph for this function:

command_set_bed()

virtual int Slic3r::IPrinterAgent::command_set_bed ( std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode )

inlinevirtualinherited

Reimplemented in Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        nlohmann::json j;
        j["print"]["sequence_id"] = std::to_string(sequence_id);
        if (supports_mqtt_bed_ctrl) {
            j["print"]["command"] = "set_bed_temp";
            j["print"]["temp"]    = temp;
        } else {
            j["print"]["command"] = "gcode_line";
            j["print"]["param"]   = (boost::format("M140 S%1%\n") % temp).str();
        }
        return publish_command_json(dev_id, j, lan_mode);
    }

References publish_command_json().

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the call graph for this function:

Here is the caller graph for this function:

command_set_nozzle()

virtual int Slic3r::IPrinterAgent::command_set_nozzle ( std::string dev_id, int temp, int sequence_id, bool lan_mode )

inlinevirtualinherited

Reimplemented in Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        nlohmann::json j;
        j["print"]["command"]     = "gcode_line";
        j["print"]["param"]       = (boost::format("M104 S%1%\n") % temp).str();
        j["print"]["sequence_id"] = std::to_string(sequence_id);
        return publish_command_json(dev_id, j, lan_mode);
    }

References publish_command_json().

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the call graph for this function:

Here is the caller graph for this function:

command_start_camera()

virtual int Slic3r::IPrinterAgent::command_start_camera ( std::string )

inlinevirtualinherited

Reimplemented in Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }

References ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

command_xyz_abs()

virtual int Slic3r::IPrinterAgent::command_xyz_abs ( std::string dev_id, int sequence_id, bool lan_mode )

inlinevirtualinherited

Reimplemented in Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        nlohmann::json j;
        j["print"]["command"]     = "gcode_line";
        j["print"]["param"]       = "G90 \n";
        j["print"]["sequence_id"] = std::to_string(sequence_id);
        return publish_command_json(dev_id, j, lan_mode);
    }

References publish_command_json().

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_printer()

int Slic3r::MoonrakerPrinterAgent::connect_printer ( const PrinterConnectionParams & params )

overridevirtualinherited

Establish a direct LAN connection to a printer.

Implements Slic3r::IPrinterAgent.

{
    if (params.dev_id.empty() || params.host.empty()) {
        BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: connect_printer missing dev_id or dev_ip";
        return BAMBU_NETWORK_ERR_INVALID_HANDLE;
    }
 
    std::string base_url;
    std::string api_key;
    uint64_t gen;
    {
        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
        init_device_info(params.dev_id, params.host, params.username, params.password, params.use_ssl, params.port);
        gen = ++connect_generation;
        base_url = device_info.base_url;
        api_key  = device_info.api_key;
    }
 
    // Stop existing status stream and clear state
    stop_status_stream();
    {
        std::lock_guard<std::recursive_mutex> lock(payload_mutex);
        status_cache = nlohmann::json::object();
    }
    ws_last_emit_ms.store(0);
    ws_last_dispatch_ms.store(0);
    last_print_state.clear();
 
    // Launch connection in background thread (capture by value to avoid data races)
    {
        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
        // Each connection thread joins the one it supersedes, so the destructor's join waits for all of them
        // Shared, so a failed thread start does not destroy the superseded thread while it is still joinable
        auto superseded = std::make_shared<std::thread>(std::move(connect_thread));
        try {
            connect_thread = std::thread([this, dev_id = params.dev_id, base_url, api_key, gen, superseded]() {
                perform_connection_async(dev_id, base_url, api_key, gen);
                if (superseded->joinable()) {
                    superseded->join();
                }
            });
        } catch (...) {
            connect_thread = std::move(*superseded);
            throw;
        }
    }
 
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_ERR_INVALID_HANDLE, connect_generation, connect_mutex, connect_thread, Slic3r::PrinterConnectionParams::dev_id, device_info, Slic3r::PrinterConnectionParams::host, init_device_info(), last_print_state, Slic3r::PrinterConnectionParams::password, payload_mutex, Slic3r::PrinterConnectionParams::port, status_cache, stop_status_stream(), Slic3r::PrinterConnectionParams::use_ssl, Slic3r::PrinterConnectionParams::username, ws_last_dispatch_ms, and ws_last_emit_ms.

Here is the call graph for this function:

default_lan_username()

virtual std::string Slic3r::IPrinterAgent::default_lan_username ( ) const

inlinevirtualinherited

Default LAN account username for this agent's protocol, if it has a fixed one. Returns an empty string if the agent has no fixed default (e.g. caller must supply one).

Reimplemented in Slic3r::BBLPrinterAgent.

{ return {}; }

del_subscribe()

virtual int Slic3r::IPrinterAgent::del_subscribe ( std::vector< std::string > dev_list )

inlinevirtualinherited

Remove device-level subscriptions.

Reimplemented in Slic3r::BBLPrinterAgent.

{ (void) dev_list; return BAMBU_NETWORK_SUCCESS; }

References BAMBU_NETWORK_SUCCESS.

disconnect_printer()

int Slic3r::MoonrakerPrinterAgent::disconnect_printer ( )

overridevirtualinherited

Tear down the active LAN printer connection.

Implements Slic3r::IPrinterAgent.

{
    {
        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
        device_info = MoonrakerDeviceInfo{};
        ++connect_generation;  // Invalidate any in-flight connection
    }
 
    stop_status_stream();
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, connect_generation, connect_mutex, device_info, disconnect_printer(), and stop_status_stream().

Referenced by disconnect_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

dispatch_local_connect()

void Slic3r::MoonrakerPrinterAgent::dispatch_local_connect ( int state, const std::string & dev_id, const std::string & msg )

privateinherited

{
    OnLocalConnectedFn local_fn;
    QueueOnMainFn      queue_fn;
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        local_fn = on_local_connect_fn;
        queue_fn = queue_on_main_fn;
    }
    if (!local_fn) {
        return;
    }
 
    auto dispatch = [state, dev_id, msg, local_fn]() { local_fn(state, dev_id, msg); };
    if (queue_fn) {
        queue_fn(dispatch);
    } else {
        dispatch();
    }
}

References dispatch_local_connect(), on_local_connect_fn, queue_on_main_fn, and state_mutex.

Referenced by dispatch_local_connect(), and perform_connection_async().

Here is the call graph for this function:

Here is the caller graph for this function:

dispatch_message()

void Slic3r::MoonrakerPrinterAgent::dispatch_message ( const std::string & dev_id, const std::string & payload )

privateinherited

{
    OnMessageFn   local_fn;
    OnMessageFn   cloud_fn;
    QueueOnMainFn queue_fn;
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        local_fn = on_local_message_fn;
        cloud_fn = on_message_fn;
        queue_fn = queue_on_main_fn;
    }
 
    if (!local_fn && !cloud_fn) {
        BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent: dispatch_message - no message callback registered!";
        return;
    }
 
    auto dispatch = [dev_id, payload, local_fn, cloud_fn]() {
        if (local_fn) {
            local_fn(dev_id, payload);
            return;
        }
        if (cloud_fn) {
            cloud_fn(dev_id, payload);
        }
    };
 
    if (queue_fn) {
        queue_fn(dispatch);
    } else {
        dispatch();
    }
}

References dispatch_message(), on_local_message_fn, on_message_fn, queue_on_main_fn, and state_mutex.

Referenced by dispatch_message(), handle_request(), handle_ws_message(), send_access_code(), send_heartbeat_if_due(), and send_version_info().

Here is the call graph for this function:

Here is the caller graph for this function:

dispatch_printer_connected()

void Slic3r::MoonrakerPrinterAgent::dispatch_printer_connected ( const std::string & dev_id )

privateinherited

{
    OnPrinterConnectedFn connected_fn;
    QueueOnMainFn        queue_fn;
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        connected_fn = on_printer_connected_fn;
        queue_fn     = queue_on_main_fn;
    }
    if (!connected_fn) {
        return;
    }
 
    auto dispatch = [dev_id, connected_fn]() { connected_fn(dev_id); };
    if (queue_fn) {
        queue_fn(dispatch);
    } else {
        dispatch();
    }
}

References dispatch_printer_connected(), on_printer_connected_fn, queue_on_main_fn, and state_mutex.

Referenced by dispatch_printer_connected(), and perform_connection_async().

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_device_info()

bool Slic3r::MoonrakerPrinterAgent::fetch_device_info ( const std::string & base_url, const std::string & api_key, MoonrakerDeviceInfo & info, std::string & error, const std::function< bool()> & cancelled ) const

protectedvirtualinherited

{
    auto fetch_json = [&](const std::string& url, nlohmann::json& out) {
        std::string response_body;
        bool        success = false;
        std::string http_error;
 
        auto http = Http::get(url);
        if (!api_key.empty()) {
            http.header("X-Api-Key", api_key);
        }
        http.timeout_connect(5)
            .timeout_max(10)
            .on_progress(cancel_when(cancelled))
            .on_complete([&](std::string body, unsigned status) {
                if (status == 200) {
                    response_body = body;
                    success       = true;
                } else {
                    http_error = "HTTP error: " + std::to_string(status);
                }
            })
            .on_error([&](std::string body, std::string err, unsigned status) {
                http_error = err;
                if (status > 0) {
                    http_error += " (HTTP " + std::to_string(status) + ")";
                }
            })
            .perform_sync();
 
        if (!success) {
            error = http_error.empty() ? "Connection failed" : http_error;
            return false;
        }
 
        out = nlohmann::json::parse(response_body, nullptr, false, true);
        if (out.is_discarded()) {
            error = "Invalid JSON response";
            return false;
        }
        return true;
    };
 
    nlohmann::json json;
    std::string    url = join_url(base_url, "/server/info");
    if (!fetch_json(url, json)) {
        return false;
    }
 
    nlohmann::json result = json.contains("result") ? json["result"] : json;
    info.dev_name         = result.value("machine_name", result.value("hostname", ""));
    info.version          = result.value("moonraker_version", "");
    info.klippy_state     = result.value("klippy_state", "");
 
    return true;
}

References anonymous_namespace{MoonrakerPrinterAgent.cpp}::cancel_when(), Slic3r::MoonrakerPrinterAgent::MoonrakerDeviceInfo::dev_name, fetch_device_info(), Slic3r::Http::get(), Slic3r::http, join_url(), Slic3r::MoonrakerPrinterAgent::MoonrakerDeviceInfo::klippy_state, and Slic3r::MoonrakerPrinterAgent::MoonrakerDeviceInfo::version.

Referenced by fetch_device_info(), Slic3r::QidiPrinterAgent::fetch_filament_info(), and perform_connection_async().

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_filament_info()

bool Slic3r::SnapmakerPrinterAgent::fetch_filament_info ( std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull )

overridevirtual

Refresh filament info from the printer synchronously. Should only be called when get_filament_sync_mode() returns FilamentSyncMode::pull. Populates the MachineObject's DevFilaSystem with fetched filament data.

Reimplemented from Slic3r::MoonrakerPrinterAgent.

{
    std::string url = join_url(device_info.base_url, "/printer/objects/query?print_task_config&filament_detect");
 
    std::string response_body;
    bool        success = false;
    std::string http_error;
 
    auto http = Http::get(url);
    if (!device_info.api_key.empty()) {
        http.header("X-Api-Key", device_info.api_key);
    }
    http.timeout_connect(5)
        .timeout_max(10)
        .on_complete([&](std::string body, unsigned status) {
            if (status == 200) {
                response_body = body;
                success       = true;
            } else {
                http_error = "HTTP error: " + std::to_string(status);
            }
        })
        .on_error([&](std::string body, std::string err, unsigned status) {
            http_error = err;
            if (status > 0) {
                http_error += " (HTTP " + std::to_string(status) + ")";
            }
        })
        .perform_sync();
 
    if (!success) {
        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
        return false;
    }
 
    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
    if (json.is_discarded()) {
        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
        return false;
    }
 
    // Navigate to result.status.print_task_config
    if (!json.contains("result") || !json["result"].contains("status") ||
        !json["result"]["status"].contains("print_task_config")) {
        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
        return false;
    }
 
    auto& ptc = json["result"]["status"]["print_task_config"];
 
    // Read parallel arrays from print_task_config
    auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
    auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
    auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
    auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
    auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
 
    const int slot_count = static_cast<int>(filament_exist.size());
    if (slot_count == 0) {
        BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
        return false;
    }
 
    // Read NFC filament_detect data for temperature info (optional)
    nlohmann::json nfc_info;
    if (json["result"]["status"].contains("filament_detect") &&
        json["result"]["status"]["filament_detect"].contains("info")) {
        nfc_info = json["result"]["status"]["filament_detect"]["info"];
    }
 
    static const std::string empty_str;
    static const std::string default_color = "FFFFFFFF";
 
    std::vector<AmsTrayData> trays;
    trays.reserve(slot_count);
 
    for (int i = 0; i < slot_count; ++i) {
        AmsTrayData tray;
        tray.slot_index   = i;
        tray.has_filament = filament_exist[i];
 
        if (tray.has_filament) {
            tray.tray_type     = combine_filament_type(safe_at(filament_type, i, empty_str),
                                                       safe_at(filament_sub_type, i, empty_str));
            tray.tray_color    = safe_at(filament_color, i, default_color);
 
            auto* bundle = GUI::wxGetApp().preset_bundle;
            // Try to find a matching preset for this filament based on vendor, type and color.
            // If not found, default to traditional search by type only or generic type mapping.
            if (bundle) {
                std::string vendor      = safe_at(filament_vendor, i, empty_str);
                std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
                                                                                       tray.tray_color);
 
                if (!filament_id.empty()) {
                    tray.tray_info_idx = filament_id;
                    BOOST_LOG_TRIVIAL(warning) << "Filament sync: Found manufacturer-specific profile for slot " << i << ": "
                                               << filament_id;
                } else {
                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
                }
            } else {
                tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
            }
 
            // Extract NFC temperature data if available
            if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
                auto& nfc_slot = nfc_info[i];
                std::string vendor = nfc_slot.value("VENDOR", "NONE");
                if (vendor != "NONE" && !vendor.empty()) {
                    tray.bed_temp    = nfc_slot.value("BED_TEMP", 0);
                    tray.nozzle_temp = nfc_slot.value("FIRST_LAYER_TEMP", 0);
                }
            }
        }
 
        trays.emplace_back(std::move(tray));
    }
 
    build_ams_payload(1, slot_count - 1, trays);
    return true;
}

References Slic3r::MoonrakerPrinterAgent::AmsTrayData::bed_temp, Slic3r::MoonrakerPrinterAgent::build_ams_payload(), combine_filament_type(), Slic3r::Geometry::contains(), Slic3r::MoonrakerPrinterAgent::device_info, Slic3r::filament_type(), Slic3r::filament_vendor(), Slic3r::Http::get(), Slic3r::MoonrakerPrinterAgent::AmsTrayData::has_filament, Slic3r::http, Slic3r::MoonrakerPrinterAgent::join_url(), Slic3r::MoonrakerPrinterAgent::map_filament_type_to_generic_id(), Slic3r::MoonrakerPrinterAgent::AmsTrayData::nozzle_temp, Slic3r::MoonrakerPrinterAgent::AmsTrayData::slot_index, Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_color, Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_info_idx, and Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_type.

Here is the call graph for this function:

fetch_hh_filament_info()

bool Slic3r::MoonrakerPrinterAgent::fetch_hh_filament_info ( std::vector< AmsTrayData > & trays, int & max_lane_index )

privateinherited

{
    // Query Happy Hare MMU status
    std::string url = join_url(device_info.base_url, "/printer/objects/query?mmu");
 
    std::string response_body;
    bool success = false;
    std::string http_error;
 
    auto http = Http::get(url);
    if (!device_info.api_key.empty()) {
        http.header("X-Api-Key", device_info.api_key);
    }
    http.timeout_connect(5)
        .timeout_max(10)
        .on_complete([&](std::string body, unsigned status) {
            if (status == 200) {
                response_body = body;
                success = true;
            } else {
                http_error = "HTTP error: " + std::to_string(status);
            }
        })
        .on_error([&](std::string body, std::string err, unsigned status) {
            http_error = err;
            if (status > 0) {
                http_error += " (HTTP " + std::to_string(status) + ")";
            }
        })
        .perform_sync();
 
    if (!success) {
        BOOST_LOG_TRIVIAL(debug) << "MoonrakerPrinterAgent::fetch_hh_filament_info: Failed to fetch HH data: " << http_error;
        return false;
    }
 
    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
    if (json.is_discarded()) {
        BOOST_LOG_TRIVIAL(debug) << "MoonrakerPrinterAgent::fetch_hh_filament_info: Invalid JSON response";
        return false;
    }
 
    // Expected structure: { "result": { "status": { "mmu": { ... } } } }
    if (!json.contains("result") || !json["result"].contains("status") ||
        !json["result"]["status"].contains("mmu") || !json["result"]["status"]["mmu"].is_object()) {
        BOOST_LOG_TRIVIAL(debug) << "MoonrakerPrinterAgent::fetch_hh_filament_info: No mmu object in response";
        return false;
    }
 
    const auto& mmu = json["result"]["status"]["mmu"];
 
    // Check if HH is installed (empty mmu object means HH not installed)
    if (mmu.empty()) {
        BOOST_LOG_TRIVIAL(debug) << "MoonrakerPrinterAgent::fetch_hh_filament_info: Empty mmu object (HH not installed)";
        return false;
    }
 
    // Get num_gates
    if (!mmu.contains("num_gates") || !mmu["num_gates"].is_number()) {
        BOOST_LOG_TRIVIAL(debug) << "MoonrakerPrinterAgent::fetch_hh_filament_info: No num_gates field";
        return false;
    }
 
    int num_gates = mmu["num_gates"].get<int>();
    if (num_gates <= 0) {
        BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent::fetch_hh_filament_info: Invalid num_gates: " << num_gates;
        return false;
    }
 
    // Get arrays
    const auto& gate_status = mmu.contains("gate_status") ? mmu["gate_status"] : nlohmann::json::array();
    const auto& gate_material = mmu.contains("gate_material") ? mmu["gate_material"] : nlohmann::json::array();
    const auto& gate_color = mmu.contains("gate_color") ? mmu["gate_color"] : nlohmann::json::array();
    const auto& gate_temperature = mmu.contains("gate_temperature") ? mmu["gate_temperature"] : nlohmann::json::array();
 
    if (!gate_status.is_array() || !gate_material.is_array() ||
        !gate_color.is_array() || !gate_temperature.is_array()) {
        BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent::fetch_hh_filament_info: HH arrays not found or invalid type";
        return false;
    }
 
    // Parse gate data
    trays.clear();
    max_lane_index = 0;
 
    for (int gate_idx = 0; gate_idx < num_gates; ++gate_idx) {
        // Check gate_status: -1 = unknown, 0 = empty, 1 or 2 = available
        int status = safe_array_int(gate_status, gate_idx);
        if (status <= 0) {
            continue;  // Skip unknown or empty gates
        }
 
        // Extract gate data
        std::string material = safe_array_string(gate_material, gate_idx);
        std::string color = safe_array_string(gate_color, gate_idx);
        int nozzle_temp = safe_array_int(gate_temperature, gate_idx);
 
        // Skip if no material type (empty gate)
        if (material.empty()) {
            continue;
        }
 
        AmsTrayData tray;
        tray.slot_index = gate_idx;
        tray.tray_type = material;
        tray.tray_color = color;
        tray.nozzle_temp = nozzle_temp;
        tray.bed_temp = 0;  // HH doesn't provide bed temp in gate arrays
        tray.has_filament = true;
 
        auto* bundle = GUI::wxGetApp().preset_bundle;
        tray.tray_info_idx = bundle
            ? bundle->filaments.filament_id_by_type(tray.tray_type)
            : map_filament_type_to_generic_id(tray.tray_type);
 
        max_lane_index = std::max(max_lane_index, gate_idx);
        trays.push_back(tray);
    }
 
    if (trays.empty()) {
        BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::fetch_hh_filament_info: No valid HH gates found";
        return false;
    }
 
    return true;
}

References Slic3r::MoonrakerPrinterAgent::AmsTrayData::bed_temp, device_info, fetch_hh_filament_info(), Slic3r::Http::get(), Slic3r::MoonrakerPrinterAgent::AmsTrayData::has_filament, Slic3r::http, join_url(), map_filament_type_to_generic_id(), Slic3r::MoonrakerPrinterAgent::AmsTrayData::nozzle_temp, safe_array_int(), safe_array_string(), Slic3r::MoonrakerPrinterAgent::AmsTrayData::slot_index, Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_color, Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_info_idx, and Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_type.

Referenced by fetch_filament_info(), and fetch_hh_filament_info().

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_moonraker_filament_data()

bool Slic3r::MoonrakerPrinterAgent::fetch_moonraker_filament_data ( std::vector< AmsTrayData > & trays, int & max_lane_index )

privateinherited

{
    // Fetch lane data from Moonraker database
    std::string url = join_url(device_info.base_url, "/server/database/item?namespace=lane_data");
 
    std::string response_body;
    bool success = false;
    std::string http_error;
 
    auto http = Http::get(url);
    if (!device_info.api_key.empty()) {
        http.header("X-Api-Key", device_info.api_key);
    }
    http.timeout_connect(5)
        .timeout_max(10)
        .on_complete([&](std::string body, unsigned status) {
            if (status == 200) {
                response_body = body;
                success = true;
            } else {
                http_error = "HTTP error: " + std::to_string(status);
            }
        })
        .on_error([&](std::string body, std::string err, unsigned status) {
            http_error = err;
            if (status > 0) {
                http_error += " (HTTP " + std::to_string(status) + ")";
            }
        })
        .perform_sync();
 
    if (!success) {
        BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent::fetch_moonraker_filament_data: Failed to fetch lane data: " << http_error;
        return false;
    }
 
    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
    if (json.is_discarded()) {
        BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent::fetch_moonraker_filament_data: Invalid JSON response";
        return false;
    }
 
    // Expected structure: { "result": { "namespace": "lane_data", "value": { "lane1": {...}, ... } } }
    if (!json.contains("result") || !json["result"].contains("value") || !json["result"]["value"].is_object()) {
        BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent::fetch_moonraker_filament_data: Unexpected JSON structure or no lane_data found";
        return false;
    }
 
    // Parse response into AmsTrayData
    const auto& value = json["result"]["value"];
    trays.clear();
    max_lane_index = 0;
 
    for (const auto& [lane_key, lane_obj] : value.items()) {
        if (!lane_obj.is_object()) {
            continue;
        }
 
        // Extract lane index from the "lane" field (tool number, 0-based)
        std::string lane_str = safe_json_string(lane_obj, "lane");
        int lane_index = -1;
        if (!lane_str.empty()) {
            try {
                lane_index = std::stoi(lane_str);
            } catch (...) {
                lane_index = -1;
            }
        }
 
        if (lane_index < 0) {
            continue;
        }
 
        AmsTrayData tray;
        tray.slot_index = lane_index;
        tray.tray_color = safe_json_string(lane_obj, "color");
        tray.tray_type = safe_json_string(lane_obj, "material");
        tray.bed_temp = safe_json_int(lane_obj, "bed_temp");
        tray.nozzle_temp = safe_json_int(lane_obj, "nozzle_temp");
        tray.has_filament = !tray.tray_type.empty();
        auto* bundle = GUI::wxGetApp().preset_bundle;
        tray.tray_info_idx = bundle
            ? bundle->filaments.filament_id_by_type(tray.tray_type)
            : map_filament_type_to_generic_id(tray.tray_type);
 
        max_lane_index = std::max(max_lane_index, lane_index);
        trays.push_back(tray);
    }
 
    if (trays.empty()) {
        BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::fetch_moonraker_filament_data: No lanes found";
        return false;
    }
 
    return true;
}

References Slic3r::MoonrakerPrinterAgent::AmsTrayData::bed_temp, device_info, fetch_moonraker_filament_data(), Slic3r::Http::get(), Slic3r::MoonrakerPrinterAgent::AmsTrayData::has_filament, Slic3r::http, join_url(), map_filament_type_to_generic_id(), Slic3r::MoonrakerPrinterAgent::AmsTrayData::nozzle_temp, safe_json_int(), safe_json_string(), Slic3r::MoonrakerPrinterAgent::AmsTrayData::slot_index, Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_color, Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_info_idx, and Slic3r::MoonrakerPrinterAgent::AmsTrayData::tray_type.

Referenced by fetch_filament_info(), and fetch_moonraker_filament_data().

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_object_list()

bool Slic3r::MoonrakerPrinterAgent::fetch_object_list ( const std::string & base_url, const std::string & api_key, std::set< std::string > & objects, std::string & error ) const

privateinherited

{
    std::string response_body;
    bool        success = false;
    std::string http_error;
 
    auto http = Http::get(join_url(base_url, "/printer/objects/list"));
    if (!api_key.empty()) {
        http.header("X-Api-Key", api_key);
    }
    http.timeout_connect(5)
        .timeout_max(10)
        // Gives up once the status stream, the only caller, stops
        .on_progress(cancel_when([this] { return ws_stop.load(); }))
        .on_complete([&](std::string body, unsigned status) {
            if (status == 200) {
                response_body = body;
                success       = true;
            } else {
                http_error = "HTTP error: " + std::to_string(status);
            }
        })
        .on_error([&](std::string body, std::string err, unsigned status) {
            http_error = err;
            if (status > 0) {
                http_error += " (HTTP " + std::to_string(status) + ")";
            }
        })
        .perform_sync();
 
    if (!success) {
        error = http_error.empty() ? "Connection failed" : http_error;
        return false;
    }
 
    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
    if (json.is_discarded()) {
        error = "Invalid JSON response";
        return false;
    }
 
    nlohmann::json result = json.contains("result") ? json["result"] : json;
    if (!result.contains("objects") || !result["objects"].is_array()) {
        error = "Unexpected JSON structure";
        return false;
    }
 
    objects.clear();
    for (const auto& entry : result["objects"]) {
        if (entry.is_string()) {
            objects.insert(entry.get<std::string>());
        }
    }
 
    return !objects.empty();
}

References anonymous_namespace{MoonrakerPrinterAgent.cpp}::cancel_when(), fetch_object_list(), Slic3r::Http::get(), Slic3r::http, join_url(), and ws_stop.

Referenced by fetch_object_list(), and run_status_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

from_orca_filament_id()

virtual std::string Slic3r::IPrinterAgent::from_orca_filament_id ( const std::string & orca_filament_id ) const

inlinevirtualinherited

Reimplemented in Slic3r::BBLPrinterAgent.

{ return orca_filament_id; }

get_agent_info()

AgentInfo Slic3r::SnapmakerPrinterAgent::get_agent_info ( )

inlineoverridevirtual

Get agent information.

Reimplemented from Slic3r::MoonrakerPrinterAgent.

{ return get_agent_info_static(); }

References get_agent_info_static().

Here is the call graph for this function:

get_agent_info_static()

AgentInfo Slic3r::SnapmakerPrinterAgent::get_agent_info_static ( )

static

{
    return AgentInfo{"snapmaker", "Snapmaker", SNAPMAKER_AGENT_VERSION, "Snapmaker printer agent"};
}

Referenced by get_agent_info().

Here is the caller graph for this function:

get_camera_stream_mode()

virtual CameraStreamMode Slic3r::IPrinterAgent::get_camera_stream_mode ( ) const

inlinevirtualinherited

Get the camera stream mode for this agent. This value can be deterministic and derived at runtime if the printer supports multiple camera stream modes. E.g. LAN => HTTP/HTTPS/RTSP, Cloud => WebRTC.

Returns

CameraStreamMode indicating how the camera stream is obtained or used:

Reimplemented in Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

{ return CameraStreamMode::none; }

References Slic3r::none.

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

get_camera_url()

virtual std::string Slic3r::IPrinterAgent::get_camera_url ( ) const

inlinevirtualinherited

Get the current camera stream URL for this agent's active machine. Only meaningful when get_camera_stream_mode() returns an HTTP, HTTPS, or RTSP mode.

Reimplemented in Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

{ return {}; }

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

get_filament_sync_mode()

FilamentSyncMode Slic3r::MoonrakerPrinterAgent::get_filament_sync_mode ( ) const

inlineoverridevirtualinherited

Get the filament synchronization mode for this agent.

Returns

FilamentSyncMode indicating how filament data is obtained:

• subscription: Real-time push updates via MQTT (no fetch needed)
• pull: On-demand fetch via REST API (call fetch_filament_info())
• none: Filament synchronization not supported

Reimplemented from Slic3r::IPrinterAgent.

{ return FilamentSyncMode::pull; }

References Slic3r::pull.

get_hms_snapshot()

virtual int Slic3r::IPrinterAgent::get_hms_snapshot ( std::string dev_id, std::string file_name, std::function< void(std::string, int)> callback )

inlinevirtualinherited

Fetch the cloud snapshot image captured at a print failure. Returns 0 if the request was dispatched; the image body arrives via callback(body, http_status).

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        (void) dev_id;
        (void) file_name;
        (void) callback;
        return -1;
    }

get_user_selected_machine()

std::string Slic3r::MoonrakerPrinterAgent::get_user_selected_machine ( )

overridevirtualinherited

Return the currently selected printer ID.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    return selected_machine;
}

References get_user_selected_machine(), selected_machine, and state_mutex.

Referenced by get_user_selected_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_request()

int Slic3r::MoonrakerPrinterAgent::handle_request ( const std::string & dev_id, const std::string & json_str )

privateinherited

{
    auto json = nlohmann::json::parse(json_str, nullptr, false);
    if (json.is_discarded()) {
        BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: Invalid JSON request";
        return BAMBU_NETWORK_ERR_INVALID_RESULT;
    }
 
    // Handle info commands
    if (json.contains("info") && json["info"].contains("command")) {
        const auto& command = json["info"]["command"];
        if (command.is_string() && command.get<std::string>() == "get_version") {
            return send_version_info(dev_id);
        }
    }
 
    // Handle system commands
    if (json.contains("system") && json["system"].contains("command")) {
        const auto& command = json["system"]["command"];
        if (command.is_string() && command.get<std::string>() == "get_access_code") {
            return send_access_code(dev_id);
        }
    }
 
    // Handle print commands
    if (json.contains("print") && json["print"].contains("command")) {
        const auto& command = json["print"]["command"];
        if (!command.is_string()) {
            BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent: print command is not a string";
            return BAMBU_NETWORK_ERR_INVALID_RESULT;
        }
 
        const std::string cmd = command.get<std::string>();
 
        // Handle gcode_line command - this is how G-code commands are sent from OrcaSlicer
        if (cmd == "gcode_line") {
            if (!json["print"].contains("param") || !json["print"]["param"].is_string()) {
                BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: gcode_line missing param value, full json: " << json_str;
                return BAMBU_NETWORK_ERR_INVALID_RESULT;
            }
            std::string gcode = json["print"]["param"].get<std::string>();
 
            // Extract sequence_id from request if present
            std::string sequence_id;
            if (json["print"].contains("sequence_id") && json["print"]["sequence_id"].is_string()) {
                sequence_id = json["print"]["sequence_id"].get<std::string>();
            }
 
            nlohmann::json response;
            response["print"]["command"] = "gcode_line";
            if (!sequence_id.empty()) {
                response["print"]["sequence_id"] = sequence_id;
            }
            response["print"]["param"] = gcode;
 
            send_gcode_async(dev_id, gcode, [this, dev_id, response](bool success) mutable {
                response["print"]["result"] = success ? "success" : "failed";
                dispatch_message(dev_id, response.dump());
            });
            return BAMBU_NETWORK_SUCCESS;
        }
 
        // Print control commands
        if (cmd == "pause") {
            return pause_print(dev_id);
        }
        if (cmd == "resume") {
            return resume_print(dev_id);
        }
        if (cmd == "stop") {
            return cancel_print(dev_id);
        }
 
        // Bed temperature - UI sends "temp" field
        if (cmd == "set_bed_temp") {
            if (json["print"].contains("temp") && json["print"]["temp"].is_number()) {
                int         temp  = json["print"]["temp"].get<int>();
                std::string gcode = "SET_HEATER_TEMPERATURE HEATER=heater_bed TARGET=" + std::to_string(temp);
                send_gcode_async(dev_id, gcode);
                return BAMBU_NETWORK_SUCCESS;
            }
        }
 
        // Nozzle temperature - UI sends "target_temp" and "extruder_index" fields
        if (cmd == "set_nozzle_temp") {
            if (json["print"].contains("target_temp") && json["print"]["target_temp"].is_number()) {
                int temp         = json["print"]["target_temp"].get<int>();
                int extruder_idx = 0; // Default to main extruder
                if (json["print"].contains("extruder_index") && json["print"]["extruder_index"].is_number()) {
                    extruder_idx = json["print"]["extruder_index"].get<int>();
                }
                std::string heater = (extruder_idx == 0) ? "extruder" : "extruder" + std::to_string(extruder_idx);
                std::string gcode  = "SET_HEATER_TEMPERATURE HEATER=" + heater + " TARGET=" + std::to_string(temp);
                send_gcode_async(dev_id, gcode);
                return BAMBU_NETWORK_SUCCESS;
            }
        }
 
        if (cmd == "home") {
            send_gcode_async(dev_id, "G28");
            return BAMBU_NETWORK_SUCCESS;
        }
    }
 
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_ERR_INVALID_RESULT, BAMBU_NETWORK_SUCCESS, cancel_print(), Slic3r::Geometry::contains(), dispatch_message(), handle_request(), pause_print(), resume_print(), send_access_code(), send_gcode_async(), and send_version_info().

Referenced by handle_request(), send_message(), and send_message_to_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_ws_message()

void Slic3r::MoonrakerPrinterAgent::handle_ws_message ( const std::string & dev_id, const std::string & payload )

privateinherited

{
    auto json = nlohmann::json::parse(payload, nullptr, false);
    if (json.is_discarded()) {
        BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent: Invalid WebSocket message JSON";
        return;
    }
 
    bool updated     = false;
    bool is_critical = false; // Track if this is a critical update that bypasses throttle
 
    // Check for subscription response (has "result.status") - initial subscription is critical
    if (json.contains("result") && json["result"].contains("status") && json["result"]["status"].is_object()) {
        update_status_cache(json["result"]["status"]);
        updated     = true;
        is_critical = true; // Initial subscription response - dispatch immediately
    }
 
    // Check for status update notifications
    if (json.contains("method") && json["method"].is_string()) {
        const std::string method = json["method"].get<std::string>();
        if (method == "notify_status_update" && json.contains("params") && json["params"].is_array() && !json["params"].empty() &&
            json["params"][0].is_object()) {
            update_status_cache(json["params"][0]);
            updated = true;
            // Note: is_critical stays false for regular status updates (telemetry)
        } else if (method == "notify_klippy_ready") {
            nlohmann::json updates;
            updates["print_stats"]["state"] = "standby";
            update_status_cache(updates);
            updated     = true;
            is_critical = true; // Klippy events are critical
        } else if (method == "notify_klippy_shutdown") {
            nlohmann::json updates;
            updates["print_stats"]["state"] = "error";
            update_status_cache(updates);
            updated     = true;
            is_critical = true; // Klippy events are critical
        }
        // Handle Klippy disconnect - update status and trigger reconnection
        else if (method == "notify_klippy_disconnected") {
            // Klippy disconnected - update status to reflect disconnect state
            nlohmann::json updates;
            updates["print_stats"]["state"] = "error";
            update_status_cache(updates);
            updated     = true;
            is_critical = true; // Klippy events are critical
            // Set flag to trigger reconnection after dispatching the status update
            ws_reconnect_requested.store(true);
            BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent: Klippy disconnected, triggering reconnection";
        }
    }
 
    // Check for print state changes (critical - always dispatch immediately)
    if (updated && !is_critical) {
        std::string current_state;
        {
            std::lock_guard<std::recursive_mutex> lock(payload_mutex);
            if (status_cache.contains("print_stats") && status_cache["print_stats"].contains("state") &&
                status_cache["print_stats"]["state"].is_string()) {
                current_state = status_cache["print_stats"]["state"].get<std::string>();
            }
        }
 
        if (!current_state.empty() && current_state != last_print_state) {
            is_critical      = true;
            last_print_state = current_state;
        }
    }
 
    if (updated) {
        const auto now_ms           = steady_now_ms();
        const auto last_dispatch_ms = ws_last_dispatch_ms.load();
 
        // Dispatch if: critical change OR throttle interval elapsed
        const bool should_dispatch = is_critical || last_dispatch_ms == 0 || now_ms - last_dispatch_ms >= STATUS_UPDATE_INTERVAL_MS;
 
        if (should_dispatch) {
            nlohmann::json message;
            {
                std::lock_guard<std::recursive_mutex> lock(payload_mutex);
                message = build_print_payload_locked();
            }
 
            dispatch_message(dev_id, message.dump());
            ws_last_dispatch_ms.store(now_ms);
            ws_last_emit_ms.store(now_ms); // Also update heartbeat timer
        }
        // else: skip dispatch, cache is updated for next dispatch cycle
    }
}

References build_print_payload_locked(), dispatch_message(), handle_ws_message(), last_print_state, payload_mutex, status_cache, STATUS_UPDATE_INTERVAL_MS, anonymous_namespace{MoonrakerPrinterAgent.cpp}::steady_now_ms(), update_status_cache(), ws_last_dispatch_ms, ws_last_emit_ms, and ws_reconnect_requested.

Referenced by handle_ws_message(), and run_status_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

init_device_info()

bool Slic3r::MoonrakerPrinterAgent::init_device_info ( const std::string & dev_id, const std::string & dev_ip, const std::string & username, const std::string & password, bool use_ssl, const std::string & port )

protectedvirtualinherited

{
    device_info         = MoonrakerDeviceInfo{};
    auto* preset_bundle = GUI::wxGetApp().preset_bundle;
    if (!preset_bundle) {
        return false;
    }
 
    auto&       preset      = preset_bundle->printers.get_edited_preset();
    const auto& printer_cfg = preset.config;
 
    device_info.dev_ip     = dev_ip;
    device_info.api_key    = password;
    device_info.model_name = printer_cfg.opt_string("printer_model");
    device_info.model_id   = preset.get_printer_type(preset_bundle);
    device_info.base_url   = normalize_base_url(use_ssl, dev_ip, port);
    device_info.dev_id     = dev_id;
    device_info.version    = "";
    device_info.dev_name   = device_info.dev_id;
 
    return true;
}

References device_info, init_device_info(), and normalize_base_url().

Referenced by connect_printer(), and init_device_info().

Here is the call graph for this function:

Here is the caller graph for this function:

install_device_cert()

virtual void Slic3r::IPrinterAgent::install_device_cert ( std::string dev_id, bool lan_only )

inlinevirtualinherited

Install or refresh device certificate for LAN TLS.

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        (void) dev_id;
        (void) lan_only;
    }

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

is_numeric()

bool Slic3r::MoonrakerPrinterAgent::is_numeric ( const std::string & value )

protectedinherited

{
    return !value.empty() && std::all_of(value.begin(), value.end(), [](unsigned char c) { return std::isdigit(c) != 0; });
}

References is_numeric().

Referenced by Slic3r::QidiPrinterAgent::fetch_slot_info(), Slic3r::QidiPrinterAgent::infer_series_id(), and is_numeric().

Here is the call graph for this function:

Here is the caller graph for this function:

join_stopped_status_stream()

void Slic3r::MoonrakerPrinterAgent::join_stopped_status_stream ( )

privateinherited

{
    std::thread stopped;
    {
        std::lock_guard<std::mutex> lock(ws_abort_mutex);
        // A running stream belongs to a newer connection, so only one that is already stopping is joined
        if (ws_stop.load() && ws_thread.get_id() != std::this_thread::get_id()) {
            stopped = std::move(ws_thread);
        }
    }
    if (stopped.joinable()) {
        stopped.join();
    }
}

References join_stopped_status_stream(), ws_abort_mutex, ws_stop, and ws_thread.

Referenced by join_stopped_status_stream(), and perform_connection_async().

Here is the call graph for this function:

Here is the caller graph for this function:

join_url()

std::string Slic3r::MoonrakerPrinterAgent::join_url ( const std::string & base_url, const std::string & path ) const

protectedinherited

{
    if (base_url.empty()) {
        return "";
    }
    if (path.empty()) {
        return base_url;
    }
    if (base_url.back() == '/' && path.front() == '/') {
        return base_url.substr(0, base_url.size() - 1) + path;
    }
    if (base_url.back() != '/' && path.front() != '/') {
        return base_url + "/" + path;
    }
    return base_url + path;
}

References join_url().

Referenced by fetch_device_info(), Slic3r::QidiPrinterAgent::fetch_filament_dict(), Slic3r::SnapmakerPrinterAgent::fetch_filament_info(), fetch_hh_filament_info(), fetch_moonraker_filament_data(), fetch_object_list(), Slic3r::QidiPrinterAgent::fetch_slot_info(), join_url(), query_printer_status(), send_gcode_async(), send_gcode_sync(), send_jsonrpc_command(), and upload_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

map_filament_type_to_generic_id()

std::string Slic3r::MoonrakerPrinterAgent::map_filament_type_to_generic_id ( const std::string & filament_type )

staticprotectedinherited

{
    const std::string upper = trim_and_upper(filament_type);
 
    // Normalize reported material names (trimmed, uppercased) to an OrcaFilamentLibrary
    // generic family. The family's filament_id is resolved from the loaded system presets
    // below rather than hardcoded, so profile id re-mints never require touching this table.
    // scripts/test_moonraker_lane_data.py parses this initializer; keep the {"A", "B"} format.
    static const std::map<std::string, std::string> type_to_ofl_family = {
        // PLA variants
        {"PLA", "PLA"},
        {"PLA-CF", "PLA-CF"},
        {"PLA SILK", "PLA Silk"},
        {"PLA-SILK", "PLA Silk"},
        {"PLA HIGH SPEED", "PLA High Speed"},
        {"PLA-HS", "PLA High Speed"},
        {"PLA HS", "PLA High Speed"},
 
        // ABS/ASA variants
        {"ABS", "ABS"},
        {"ASA", "ASA"},
 
        // PETG/PET variants
        {"PETG", "PETG"},
        {"PET", "PETG"},
        {"PCTG", "PCTG"},
 
        // PA/Nylon variants
        {"PA", "PA"},
        {"NYLON", "PA"},
        {"PA-CF", "PA-CF"},
        {"PPA", "PPA-CF"},
        {"PPA-CF", "PPA-CF"},
        {"PPA-GF", "PPA-GF"},
 
        // PC variants
        {"PC", "PC"},
 
        // PP/PE variants
        {"PE", "PE"},
        {"PP", "PP"},
 
        // Support materials
        {"PVA", "PVA"},
        {"HIPS", "HIPS"},
        {"BVOH", "BVOH"},
 
        // TPU variants
        {"TPU", "TPU"},
 
        // Other materials
        {"EVA", "EVA"},
        {"PHA", "PHA"},
        {"COPE", "CoPE"},
        {"SBS", "SBS"},
    };
 
    auto it = type_to_ofl_family.find(upper);
    if (it == type_to_ofl_family.end())
        return UNKNOWN_FILAMENT_ID;
 
    if (auto* bundle = GUI::wxGetApp().preset_bundle) {
        const Preset* preset = bundle->filaments.find_preset("Generic " + it->second + " @System");
        if (preset != nullptr && preset->is_system && !preset->filament_id.empty())
            return preset->filament_id;
    }
 
    // Unknown material, or no loaded preset data to resolve against
    return UNKNOWN_FILAMENT_ID;
}

References Slic3r::Preset::filament_id, Slic3r::filament_type(), Slic3r::Preset::is_system, map_filament_type_to_generic_id(), trim_and_upper(), and UNKNOWN_FILAMENT_ID.

Referenced by Slic3r::SnapmakerPrinterAgent::fetch_filament_info(), fetch_hh_filament_info(), fetch_moonraker_filament_data(), and map_filament_type_to_generic_id().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_base_url()

std::string Slic3r::MoonrakerPrinterAgent::normalize_base_url ( bool use_ssl, const std::string & host, const std::string & port )

protectedinherited

{
    std::string value = use_ssl ? "https://" : "http://";
    value += host;
    value += port.empty() ? "" : (":" + port);
    return value;
}

References normalize_base_url().

Referenced by init_device_info(), and normalize_base_url().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_color_value()

std::string Slic3r::MoonrakerPrinterAgent::normalize_color_value ( const std::string & color )

staticprivateinherited

{
    std::string value = color;
    boost::trim(value);
 
    // Remove 0x or 0X prefix if present
    if (value.size() >= 2 && (value.rfind("0x", 0) == 0 || value.rfind("0X", 0) == 0)) {
        value = value.substr(2);
    }
    // Remove # prefix if present
    if (!value.empty() && value[0] == '#') {
        value = value.substr(1);
    }
 
    // Extract only hex digits
    std::string normalized;
    for (char c : value) {
        if (std::isxdigit(static_cast<unsigned char>(c))) {
            normalized.push_back(static_cast<char>(std::toupper(static_cast<unsigned char>(c))));
        }
    }
 
    // If 6 hex digits, add FF alpha
    if (normalized.size() == 6) {
        normalized += "FF";
    }
 
    // Validate length - return default if invalid
    if (normalized.size() != 8) {
        return "00000000";
    }
 
    return normalized;
}

References normalize_color_value().

Referenced by build_ams_payload(), and normalize_color_value().

Here is the call graph for this function:

Here is the caller graph for this function:

pause_print()

int Slic3r::MoonrakerPrinterAgent::pause_print ( const std::string & dev_id )

privateinherited

{
    send_gcode_async(dev_id, "PAUSE");
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, pause_print(), and send_gcode_async().

Referenced by handle_request(), and pause_print().

Here is the call graph for this function:

Here is the caller graph for this function:

perform_connection_async()

void Slic3r::MoonrakerPrinterAgent::perform_connection_async ( const std::string & dev_id, const std::string & base_url, const std::string & api_key, uint64_t generation )

privateinherited

{
    auto is_stale = [&]() { return generation != connect_generation.load(); };
 
    int         result = BAMBU_NETWORK_ERR_CONNECTION_TO_PRINTER_FAILED;
    std::string error_msg;
 
    // Early exit if a newer connection was started before we begin
    if (is_stale()) {
        return;
    }
 
    try {
        MoonrakerDeviceInfo fetched_info;
        if (!fetch_device_info(base_url, api_key, fetched_info, error_msg, is_stale)) {
            if (!is_stale()) {
                BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: Failed to fetch server info: " << error_msg;
            }
            // Orca todo: revist here, for now don't send error, this is set current MachineObject to null
            // dispatch_local_connect(ConnectStatusFailed, dev_id, "server_info_failed");
            return;
        }
 
        // Commit fetched info back to device_info under lock, only if still current
        {
            std::lock_guard<std::recursive_mutex> lock(connect_mutex);
            if (is_stale()) {
                return;
            }
            device_info.dev_name     = fetched_info.dev_name.empty() ? dev_id : fetched_info.dev_name;
            device_info.version      = fetched_info.version;
            device_info.klippy_state = fetched_info.klippy_state;
        }
 
// Orca todo: disable websocket for now, as we don't use MonitorPanel for Moonraker printers yet
#if 1
        // Query initial status
        nlohmann::json initial_status;
        if (query_printer_status(base_url, api_key, initial_status, error_msg, is_stale)) {
            // Under connect_mutex, so a superseded connection never writes into the next connection's cache
            std::lock_guard<std::recursive_mutex> lock(connect_mutex);
            if (is_stale()) {
                return;
            }
            update_status_cache(initial_status);
            BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent: Initial status queried successfully";
        } else if (!is_stale()) {
            BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent: Initial status query failed: " << error_msg;
        }
 
        join_stopped_status_stream();
        // Holds connect_mutex across the staleness check and the start, so a disconnect during the queries above prevents the start
        {
            std::lock_guard<std::recursive_mutex> lock(connect_mutex);
            if (is_stale()) {
                return;
            }
            start_status_stream(dev_id, base_url, api_key);
        }
#endif
 
        // Success!
        result = BAMBU_NETWORK_SUCCESS;
 
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: Connection exception: " << e.what();
        error_msg = std::string("exception: ") + e.what();
        result    = BAMBU_NETWORK_ERR_CONNECTION_TO_PRINTER_FAILED;
    }
 
    if (result == BAMBU_NETWORK_SUCCESS) {
        // Under connect_mutex, so a superseded connection never reports itself connected
        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
        if (!is_stale()) {
            dispatch_local_connect(ConnectStatusOk, dev_id, "0");
            dispatch_printer_connected(dev_id);
            BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent: connect_printer completed - dev_id=" << dev_id;
        }
    } else if (result != BAMBU_NETWORK_ERR_CANCELED) {
        // Orca todo: revist here, for now don't send error, this is set current MachineObject to null
        // dispatch_local_connect(ConnectStatusFailed, dev_id, error_msg);
    }
}

References BAMBU_NETWORK_ERR_CANCELED, BAMBU_NETWORK_ERR_CONNECTION_TO_PRINTER_FAILED, BAMBU_NETWORK_SUCCESS, connect_generation, connect_mutex, Slic3r::ConnectStatusOk, Slic3r::MoonrakerPrinterAgent::MoonrakerDeviceInfo::dev_name, device_info, dispatch_local_connect(), dispatch_printer_connected(), fetch_device_info(), join_stopped_status_stream(), Slic3r::MoonrakerPrinterAgent::MoonrakerDeviceInfo::klippy_state, perform_connection_async(), query_printer_status(), start_status_stream(), update_status_cache(), and Slic3r::MoonrakerPrinterAgent::MoonrakerDeviceInfo::version.

Referenced by perform_connection_async().

Here is the call graph for this function:

Here is the caller graph for this function:

ping_bind()

virtual int Slic3r::IPrinterAgent::ping_bind ( std::string ping_code )

inlinevirtualinherited

Ping the binding endpoint to check printer readiness.

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        (void) ping_code;
        return BAMBU_NETWORK_SUCCESS;
    }

References BAMBU_NETWORK_SUCCESS.

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

publish_command_json()

int Slic3r::IPrinterAgent::publish_command_json ( std::string dev_id, const nlohmann::json & j, bool lan_mode )

inlineprivateinherited

    {
        return lan_mode ? send_message_to_printer(dev_id, j.dump(), 0, 0)
                         : send_message(dev_id, j.dump(), 0, 0);
    }

References send_message(), and send_message_to_printer().

Referenced by command_auto_leveling(), command_axis_control(), command_go_home(), command_set_bed(), command_set_nozzle(), and command_xyz_abs().

Here is the call graph for this function:

Here is the caller graph for this function:

query_printer_status()

bool Slic3r::MoonrakerPrinterAgent::query_printer_status ( const std::string & base_url, const std::string & api_key, nlohmann::json & status, std::string & error, const std::function< bool()> & cancelled ) const

privateinherited

{
    std::string url = join_url(base_url, "/printer/objects/query?print_stats&virtual_sdcard&extruder&heater_bed&fan");
 
    std::string response_body;
    bool        success = false;
    std::string http_error;
 
    auto http = Http::get(url);
    if (!api_key.empty()) {
        http.header("X-Api-Key", api_key);
    }
    http.timeout_connect(5)
        .timeout_max(10)
        .on_progress(cancel_when(cancelled))
        .on_complete([&](std::string body, unsigned status_code) {
            if (status_code == 200) {
                response_body = body;
                success       = true;
            } else {
                http_error = "HTTP error: " + std::to_string(status_code);
            }
        })
        .on_error([&](std::string body, std::string err, unsigned status_code) {
            http_error = err;
            if (status_code > 0) {
                http_error += " (HTTP " + std::to_string(status_code) + ")";
            }
        })
        .perform_sync();
 
    if (!success) {
        error = http_error.empty() ? "Connection failed" : http_error;
        return false;
    }
 
    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
    if (json.is_discarded()) {
        error = "Invalid JSON response";
        return false;
    }
 
    if (!json.contains("result") || !json["result"].contains("status")) {
        error = "Unexpected JSON structure";
        return false;
    }
 
    status = json["result"]["status"];
    return true;
}

References anonymous_namespace{MoonrakerPrinterAgent.cpp}::cancel_when(), Slic3r::Http::get(), Slic3r::http, join_url(), and query_printer_status().

Referenced by perform_connection_async(), and query_printer_status().

Here is the call graph for this function:

Here is the caller graph for this function:

request_bind_ticket()

virtual int Slic3r::IPrinterAgent::request_bind_ticket ( std::string * ticket )

inlinevirtualinherited

Request a one-time bind ticket from the server.

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        if (ticket)
            *ticket = {};
        return BAMBU_NETWORK_SUCCESS;
    }

References BAMBU_NETWORK_SUCCESS.

resume_print()

int Slic3r::MoonrakerPrinterAgent::resume_print ( const std::string & dev_id )

privateinherited

{
    send_gcode_async(dev_id, "RESUME");
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, resume_print(), and send_gcode_async().

Referenced by handle_request(), and resume_print().

Here is the call graph for this function:

Here is the caller graph for this function:

run_status_stream()

void Slic3r::MoonrakerPrinterAgent::run_status_stream ( std::string dev_id, std::string base_url, std::string api_key, StatusStreamTimings timings )

privateinherited

{
    WsEndpoint endpoint;
    if (!parse_ws_endpoint(base_url, endpoint)) {
        BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent: websocket endpoint invalid for base_url=" << base_url;
        return;
    }
    if (endpoint.secure) {
        BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent: websocket wss not supported for base_url=" << base_url;
        return;
    }
 
    net::io_context       ioc;
    net::steady_timer     backoff{ioc};
    std::function<void()> abort_connection; // Set while a connection attempt runs
    const auto            run = [&](auto&& initiate) { return run_until_done(ioc, ws_stop, initiate); };
 
    // Registered under the lock stop_status_stream() takes, so a stop either finds this abort or has already set ws_stop
    {
        std::lock_guard<std::mutex> lock(ws_abort_mutex);
        if (ws_stop.load()) {
            return;
        }
        ws_abort = [&] {
            net::post(ioc, [&] {
                backoff.cancel();
                if (abort_connection) {
                    abort_connection();
                }
            });
        };
    }
    const ScopeGuard clear_abort([this] {
        std::lock_guard<std::mutex> lock(ws_abort_mutex);
        ws_abort = nullptr;
    });
 
    // Reconnection logic
    ws_reconnect_requested.store(false); // Reset reconnect flag
    int retry_count = 0;
 
    while (!ws_stop.load()) {
        bool connection_lost = false; // Flag to distinguish clean shutdown from unexpected disconnect
 
        tcp::resolver                        resolver{ioc};
        websocket::stream<beast::tcp_stream> ws{ioc};
        beast::tcp_stream&                   stream = beast::get_lowest_layer(ws);
        net::steady_timer                    close_deadline{ioc};
        bool                                 closing          = false;
        bool                                 deadline_pending = false;
        auto                                 last_message     = std::chrono::steady_clock::now();
        // Sends a close frame if the websocket is open, and drops the socket when the printer has not answered within timings.close
        const auto close_politely = [&](websocket::close_code code) {
            if (!ws.is_open() || closing) {
                return;
            }
            closing          = true;
            deadline_pending = true;
            close_deadline.expires_after(timings.close);
            close_deadline.async_wait([&](beast::error_code ec) {
                deadline_pending = false;
                if (!ec) {
                    beast::error_code ignored;
                    stream.socket().close(ignored);
                }
            });
            ws.async_close(code, [&](beast::error_code) {
                closing = false;
                close_deadline.cancel();
            });
        };
        abort_connection = [&] {
            // Beast reports a closing websocket as not open, and dropping its socket would cut off the close frame
            if (closing) {
                return;
            }
            if (ws.is_open()) {
                close_politely(websocket::close_code::going_away);
            } else {
                beast::error_code ignored;
                stream.socket().close(ignored);
            }
        };
        const ScopeGuard clear_connection_abort([&] { abort_connection = nullptr; });
 
        try {
            const beast::error_code connect_ec =
                connect_until_done(ioc, stream, resolver.resolve(endpoint.host, endpoint.port), std::chrono::seconds(5), ws_stop);
            if (connect_ec) {
                throw beast::system_error{connect_ec};
            }
            // Clears the connect deadline, which would otherwise close the socket 5 s after connecting
            stream.expires_never();
 
            websocket::stream_base::timeout timeouts{};
            timeouts.handshake_timeout = timings.handshake;
            timeouts.idle_timeout      = timings.idle;
            timeouts.keep_alive_pings  = true;
            ws.set_option(timeouts);
            // Beast pings on a fixed schedule, so the heartbeat also checks how long the printer has sent no message
            ws.control_callback([&](websocket::frame_type kind, beast::string_view) {
                if (kind == websocket::frame_type::pong && !closing &&
                    std::chrono::steady_clock::now() - last_message >= timings.heartbeat) {
                    send_heartbeat_if_due(dev_id, timings.heartbeat);
                }
            });
            ws.set_option(websocket::stream_base::decorator([&](websocket::request_type& req) {
                req.set(http::field::user_agent, "OrcaSlicer");
                if (!api_key.empty()) {
                    req.set("X-Api-Key", api_key);
                }
            }));
 
            std::string host_header = endpoint.host;
            if (!endpoint.port.empty() && endpoint.port != "80") {
                host_header += ":" + endpoint.port;
            }
            if (const auto ec = run([&](auto&& handler) { ws.async_handshake(host_header, endpoint.target, handler); })) {
                throw beast::system_error{ec};
            }
            ws.text(true);
 
            // Send client identification
            nlohmann::json identify;
            identify["jsonrpc"]               = "2.0";
            identify["method"]                = "server.connection.identify";
            identify["params"]["client_name"] = "OrcaSlicer";
            identify["params"]["version"]     = MoonrakerPrinterAgent_VERSION;
            identify["params"]["type"]        = "agent";
            identify["params"]["url"]         = "https://github.com/SoftFever/OrcaSlicer";
            identify["id"]                    = 0;
            const std::string identify_payload = identify.dump();
            if (const auto ec = run([&](auto&& handler) { ws.async_write(net::buffer(identify_payload), handler); })) {
                throw beast::system_error{ec};
            }
 
            std::set<std::string> subscribe_objects = {"print_stats", "virtual_sdcard"};
            std::set<std::string> available_objects;
            std::string           list_error;
            if (fetch_object_list(base_url, api_key, available_objects, list_error)) {
                {
                    std::lock_guard<std::recursive_mutex> lock(payload_mutex);
                    this->available_objects = std::move(available_objects);
                }
 
                if (this->available_objects.count("heater_bed") != 0) {
                    subscribe_objects.insert("heater_bed");
                }
                if (this->available_objects.count("fan") != 0) {
                    subscribe_objects.insert("fan");
                }
 
                // Add toolhead for homing status
                if (this->available_objects.count("toolhead") != 0) {
                    subscribe_objects.insert("toolhead");
                }
 
                // Add display_status for layer info (if available)
                if (this->available_objects.count("display_status") != 0) {
                    subscribe_objects.insert("display_status");
                }
 
                for (const auto& name : this->available_objects) {
                    if (name == "extruder" || name.rfind("extruder", 0) == 0) {
                        subscribe_objects.insert(name);
                        if (name == "extruder") {
                            break;
                        }
                    }
                }
            } else {
                subscribe_objects.insert("extruder");
                subscribe_objects.insert("heater_bed");
                subscribe_objects.insert("toolhead"); // Add toolhead as fallback
                subscribe_objects.insert("fan");      // Try to subscribe to fan as fallback
            }
 
            nlohmann::json subscribe;
            subscribe["jsonrpc"]   = "2.0";
            subscribe["method"]    = "printer.objects.subscribe";
            nlohmann::json objects = nlohmann::json::object();
            for (const auto& name : subscribe_objects) {
                objects[name] = nullptr;
            }
            subscribe["params"]["objects"] = std::move(objects);
            subscribe["id"]                = 1;
            const std::string subscribe_payload = subscribe.dump();
            if (const auto ec = run([&](auto&& handler) { ws.async_write(net::buffer(subscribe_payload), handler); })) {
                throw beast::system_error{ec};
            }
 
            // Read loop
            while (!ws_stop.load()) {
                beast::flat_buffer buffer;
                const auto         ec = run([&](auto&& handler) { ws.async_read(buffer, handler); });
                if (ws_stop.load()) {
                    break;
                }
                if (ec == websocket::error::closed) {
                    connection_lost = true;
                    break;
                }
                if (ec) {
                    BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent: websocket read error: " << ec.message();
                    connection_lost = true;
                    break;
                }
                last_message = std::chrono::steady_clock::now();
                // A message shows the printer is answering, so the next drop starts the backoff from reconnect_delay
                retry_count = 0;
                handle_ws_message(dev_id, beast::buffers_to_string(buffer.data()));
                // Check if handle_ws_message triggered reconnection request
                if (ws_reconnect_requested.exchange(false)) {
                    connection_lost = true;
                    break;
                }
            }
        } catch (const std::exception& e) {
            if (!ws_stop.load()) {
                BOOST_LOG_TRIVIAL(warning) << "MoonrakerPrinterAgent: websocket disconnected: " << e.what();
            }
            connection_lost = true;
        }
 
        close_politely(ws_stop.load() ? websocket::close_code::going_away : websocket::close_code::normal);
        ioc.restart();
        // Both handlers refer to this connection, so neither may be left queued for the next one
        while ((closing || deadline_pending) && ioc.run_one() != 0) {}
 
        // Exit loop on clean shutdown
        if (!connection_lost) {
            break;
        }
 
        // Check if we should stop reconnection attempts
        if (ws_stop.load()) {
            break;
        }
 
        // Exponential backoff before reconnection, capped at 32 times reconnect_delay so a printer that comes back is found again
        const auto delay = timings.reconnect_delay * (1 << std::min(retry_count, 5));
        BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent: Reconnecting in " << delay.count() << "ms (attempt " << (retry_count + 1) << ")";
        backoff.expires_after(delay);
        run([&](auto&& handler) { backoff.async_wait(handler); });
        retry_count++;
    }
}

References available_objects, Slic3r::MoonrakerPrinterAgent::StatusStreamTimings::close, Slic3r::closing(), Slic3r::connect_until_done(), fetch_object_list(), handle_ws_message(), Slic3r::MoonrakerPrinterAgent::StatusStreamTimings::handshake, Slic3r::MoonrakerPrinterAgent::StatusStreamTimings::heartbeat, Slic3r::MoonrakerPrinterAgent::StatusStreamTimings::idle, Slic3r::MoonrakerPrinterAgent_VERSION, anonymous_namespace{MoonrakerPrinterAgent.cpp}::parse_ws_endpoint(), payload_mutex, Slic3r::MoonrakerPrinterAgent::StatusStreamTimings::reconnect_delay, run_status_stream(), Slic3r::run_until_done(), send_heartbeat_if_due(), ws_abort, ws_abort_mutex, ws_reconnect_requested, and ws_stop.

Referenced by run_status_stream(), and start_status_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_array_int()

int Slic3r::MoonrakerPrinterAgent::safe_array_int ( const nlohmann::json & arr, int idx )

staticprivateinherited

{
    if (arr.is_array() && idx >= 0 && idx < static_cast<int>(arr.size()) && arr[idx].is_number())
        return arr[idx].get<int>();
    return 0;
}

References safe_array_int().

Referenced by fetch_hh_filament_info(), and safe_array_int().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_array_string()

std::string Slic3r::MoonrakerPrinterAgent::safe_array_string ( const nlohmann::json & arr, int idx )

staticprivateinherited

{
    if (arr.is_array() && idx >= 0 && idx < static_cast<int>(arr.size()) && arr[idx].is_string())
        return arr[idx].get<std::string>();
    return "";
}

References safe_array_string().

Referenced by fetch_hh_filament_info(), and safe_array_string().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_json_int()

int Slic3r::MoonrakerPrinterAgent::safe_json_int ( const nlohmann::json & obj, const char * key )

staticprivateinherited

{
    auto it = obj.find(key);
    if (it != obj.end() && it->is_number())
        return it->get<int>();
    return 0;
}

References safe_json_int().

Referenced by fetch_moonraker_filament_data(), and safe_json_int().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_json_string()

std::string Slic3r::MoonrakerPrinterAgent::safe_json_string ( const nlohmann::json & obj, const char * key )

staticprivateinherited

{
    auto it = obj.find(key);
    if (it != obj.end() && it->is_string())
        return it->get<std::string>();
    return "";
}

References safe_json_string().

Referenced by fetch_moonraker_filament_data(), and safe_json_string().

Here is the call graph for this function:

Here is the caller graph for this function:

sanitize_filename()

std::string Slic3r::MoonrakerPrinterAgent::sanitize_filename ( const std::string & filename )

protectedinherited

{
    if (filename.empty()) {
        return "print.gcode";
    }
    namespace fs = boost::filesystem;
    fs::path    p(filename);
    std::string basename = p.filename().string();
    if (basename.empty() || basename == "." || basename == "..") {
        return "print.gcode";
    }
    return basename;
}

References sanitize_filename().

Referenced by sanitize_filename(), start_local_print(), start_send_gcode_to_sdcard(), and upload_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

send_access_code()

int Slic3r::MoonrakerPrinterAgent::send_access_code ( const std::string & dev_id )

privateinherited

{
    nlohmann::json payload;
    payload["system"]["command"]     = "get_access_code";
    payload["system"]["access_code"] = device_info.api_key;
    dispatch_message(dev_id, payload.dump());
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, device_info, dispatch_message(), and send_access_code().

Referenced by handle_request(), and send_access_code().

Here is the call graph for this function:

Here is the caller graph for this function:

send_gcode_async()

void Slic3r::MoonrakerPrinterAgent::send_gcode_async ( const std::string & dev_id, const std::string & gcode, std::function< void(bool)> on_result = {} ) const

privateinherited

{
    (void) dev_id;
    const std::string base_url = device_info.base_url;
    const std::string api_key  = device_info.api_key;
    auto http = Http::post(join_url(base_url, "/printer/gcode/script"));
    if (!api_key.empty()) {
        http.header("X-Api-Key", api_key);
    }
    http.header("Content-Type", "application/json")
        .set_post_body(nlohmann::json{{"script", gcode}}.dump())
        .timeout_connect(5)
        .timeout_max(10)
        .on_complete([on_result](std::string body, unsigned status_code) {
            (void) body;
            const bool success = status_code == 200;
            if (!success) {
                BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: send_gcode failed: HTTP error " << status_code;
            }
            if (on_result) {
                on_result(success);
            }
        })
        .on_error([on_result](std::string body, std::string err, unsigned status_code) {
            (void) body;
            std::string error = err;
            if (status_code > 0) {
                error += " (HTTP " + std::to_string(status_code) + ")";
            }
            BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: send_gcode failed: " << error;
            if (on_result) {
                on_result(false);
            }
        })
        .perform();
}

References device_info, Slic3r::http, join_url(), Slic3r::Http::post(), and send_gcode_async().

Referenced by cancel_print(), handle_request(), pause_print(), resume_print(), and send_gcode_async().

Here is the call graph for this function:

Here is the caller graph for this function:

send_gcode_sync()

bool Slic3r::MoonrakerPrinterAgent::send_gcode_sync ( const std::string & dev_id, const std::string & gcode ) const

privateinherited

{
    nlohmann::json payload;
    payload["script"]       = gcode;
    std::string payload_str = payload.dump();
 
    std::string response_body;
    bool        success = false;
    std::string http_error;
 
    auto http = Http::post(join_url(device_info.base_url, "/printer/gcode/script"));
    if (!device_info.api_key.empty()) {
        http.header("X-Api-Key", device_info.api_key);
    }
    http.header("Content-Type", "application/json")
        .set_post_body(payload_str)
        .timeout_connect(5)
        .timeout_max(10)
        .on_complete([&](std::string body, unsigned status_code) {
            if (status_code == 200) {
                response_body = body;
                success       = true;
            } else {
                http_error = "HTTP error: " + std::to_string(status_code);
            }
        })
        .on_error([&](std::string body, std::string err, unsigned status_code) {
            http_error = err;
            if (status_code > 0) {
                http_error += " (HTTP " + std::to_string(status_code) + ")";
            }
        })
        .perform_sync();
 
    if (!success) {
        BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: send_gcode failed: " << http_error;
        return false;
    }
 
    return true;
}

References device_info, Slic3r::http, join_url(), Slic3r::Http::post(), and send_gcode_sync().

Referenced by send_gcode_sync(), and start_local_print().

Here is the call graph for this function:

Here is the caller graph for this function:

send_heartbeat_if_due()

void Slic3r::MoonrakerPrinterAgent::send_heartbeat_if_due ( const std::string & dev_id, std::chrono::milliseconds interval )

privateinherited

{
    const auto now_ms  = steady_now_ms();
    const auto last_ms = ws_last_emit_ms.load();
    // Re-sends only a status the printer has reported at least once
    if (last_ms == 0 || now_ms - last_ms < static_cast<uint64_t>(interval.count())) {
        return;
    }
 
    nlohmann::json message;
    {
        std::lock_guard<std::recursive_mutex> lock(payload_mutex);
        message = build_print_payload_locked();
    }
    dispatch_message(dev_id, message.dump());
    ws_last_emit_ms.store(now_ms);
}

References build_print_payload_locked(), dispatch_message(), payload_mutex, send_heartbeat_if_due(), anonymous_namespace{MoonrakerPrinterAgent.cpp}::steady_now_ms(), and ws_last_emit_ms.

Referenced by run_status_stream(), and send_heartbeat_if_due().

Here is the call graph for this function:

Here is the caller graph for this function:

send_jsonrpc_command()

bool Slic3r::MoonrakerPrinterAgent::send_jsonrpc_command ( const std::string & base_url, const std::string & api_key, const nlohmann::json & request, std::string & response ) const

privateinherited

{
    std::string request_str = request.dump();
    std::string url         = join_url(base_url, "/printer/print/start");
 
    bool        success = false;
    std::string http_error;
 
    auto http = Http::post(url);
    if (!api_key.empty()) {
        http.header("X-Api-Key", api_key);
    }
    http.header("Content-Type", "application/json")
        .set_post_body(request_str)
        .timeout_connect(5)
        .timeout_max(10)
        .on_complete([&](std::string body, unsigned status) {
            if (status == 200) {
                response = body;
                success  = true;
            } else {
                http_error = "HTTP " + std::to_string(status);
            }
        })
        .on_error([&](std::string body, std::string err, unsigned status) { http_error = err; })
        .perform_sync();
 
    if (!success) {
        BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: JSON-RPC command failed: " << http_error;
    }
 
    return success;
}

References Slic3r::http, join_url(), Slic3r::Http::post(), and send_jsonrpc_command().

Referenced by send_jsonrpc_command().

Here is the call graph for this function:

Here is the caller graph for this function:

send_message()

int Slic3r::MoonrakerPrinterAgent::send_message ( std::string dev_id, std::string json_str, int qos, int flag )

overridevirtualinherited

Publish a JSON command to a printer through cloud relay.

Implements Slic3r::IPrinterAgent.

{
    (void) qos;
    (void) flag;
    return handle_request(dev_id, json_str);
}

References handle_request().

Here is the call graph for this function:

send_message_to_printer()

int Slic3r::MoonrakerPrinterAgent::send_message_to_printer ( std::string dev_id, std::string json_str, int qos, int flag )

overridevirtualinherited

Send a JSON command to a LAN printer (bypassing cloud).

Implements Slic3r::IPrinterAgent.

{
    (void) qos;
    (void) flag;
    return handle_request(dev_id, json_str);
}

References handle_request().

Here is the call graph for this function:

send_version_info()

int Slic3r::MoonrakerPrinterAgent::send_version_info ( const std::string & dev_id )

privateinherited

{
    nlohmann::json payload;
    payload["info"]["command"] = "get_version";
    payload["info"]["result"]  = "success";
    payload["info"]["module"]  = nlohmann::json::array();
 
    nlohmann::json module;
    module["name"]         = "ota";
    module["sw_ver"]       = device_info.version;
    module["product_name"] = "Moonraker";
    payload["info"]["module"].push_back(module);
 
    dispatch_message(dev_id, payload.dump());
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, dispatch_message(), Slic3r::module(), and send_version_info().

Referenced by handle_request(), and send_version_info().

Here is the call graph for this function:

Here is the caller graph for this function:

set_cloud_agent()

void Slic3r::MoonrakerPrinterAgent::set_cloud_agent ( std::shared_ptr< ICloudServiceAgent > cloud )

overridevirtualinherited

Set the cloud agent used for token access. Must be called before any cloud-relay operations.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    m_cloud_agent = cloud;
}

References m_cloud_agent, and state_mutex.

set_on_local_connect_fn()

int Slic3r::MoonrakerPrinterAgent::set_on_local_connect_fn ( OnLocalConnectedFn fn )

overridevirtualinherited

Register LAN connection status callback.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    on_local_connect_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, on_local_connect_fn, set_on_local_connect_fn(), and state_mutex.

Referenced by set_on_local_connect_fn().

Here is the call graph for this function:

Here is the caller graph for this function:

set_on_local_message_fn()

int Slic3r::MoonrakerPrinterAgent::set_on_local_message_fn ( OnMessageFn fn )

overridevirtualinherited

Register LAN message callback.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    on_local_message_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, on_local_message_fn, set_on_local_message_fn(), and state_mutex.

Referenced by set_on_local_message_fn().

Here is the call graph for this function:

Here is the caller graph for this function:

set_on_message_fn()

int Slic3r::MoonrakerPrinterAgent::set_on_message_fn ( OnMessageFn fn )

overridevirtualinherited

Register cloud device message callback.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    on_message_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, on_message_fn, set_on_message_fn(), and state_mutex.

Referenced by set_on_message_fn().

Here is the call graph for this function:

Here is the caller graph for this function:

set_on_printer_connected_fn()

int Slic3r::MoonrakerPrinterAgent::set_on_printer_connected_fn ( OnPrinterConnectedFn fn )

overridevirtualinherited

Register printer MQTT connection callback.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    on_printer_connected_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, on_printer_connected_fn, set_on_printer_connected_fn(), and state_mutex.

Referenced by set_on_printer_connected_fn().

Here is the call graph for this function:

Here is the caller graph for this function:

set_on_ssdp_msg_fn()

int Slic3r::MoonrakerPrinterAgent::set_on_ssdp_msg_fn ( OnMsgArrivedFn fn )

overridevirtualinherited

Register SSDP discovery callback.

Implements Slic3r::IPrinterAgent.

{
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        on_ssdp_msg_fn = fn;
    }
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, on_ssdp_msg_fn, set_on_ssdp_msg_fn(), and state_mutex.

Referenced by set_on_ssdp_msg_fn().

Here is the call graph for this function:

Here is the caller graph for this function:

set_on_subscribe_failure_fn()

int Slic3r::MoonrakerPrinterAgent::set_on_subscribe_failure_fn ( GetSubscribeFailureFn fn )

overridevirtualinherited

Register subscription failure callback.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    on_subscribe_failure_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, on_subscribe_failure_fn, set_on_subscribe_failure_fn(), and state_mutex.

Referenced by set_on_subscribe_failure_fn().

Here is the call graph for this function:

Here is the caller graph for this function:

set_on_user_message_fn()

int Slic3r::MoonrakerPrinterAgent::set_on_user_message_fn ( OnMessageFn fn )

overridevirtualinherited

Register user-scoped message callback.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    on_user_message_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, on_user_message_fn, set_on_user_message_fn(), and state_mutex.

Referenced by set_on_user_message_fn().

Here is the call graph for this function:

Here is the caller graph for this function:

set_queue_on_main_fn()

int Slic3r::MoonrakerPrinterAgent::set_queue_on_main_fn ( QueueOnMainFn fn )

overridevirtualinherited

Provide main thread queue callback.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    queue_on_main_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, queue_on_main_fn, set_queue_on_main_fn(), and state_mutex.

Referenced by set_queue_on_main_fn().

Here is the call graph for this function:

Here is the caller graph for this function:

set_server_callback()

int Slic3r::MoonrakerPrinterAgent::set_server_callback ( OnServerErrFn fn )

overridevirtualinherited

Register callback for fatal HTTP errors.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    on_server_err_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, on_server_err_fn, set_server_callback(), and state_mutex.

Referenced by set_server_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

set_user_selected_machine()

int Slic3r::MoonrakerPrinterAgent::set_user_selected_machine ( std::string dev_id )

overridevirtualinherited

Update the selected cloud machine preference.

Implements Slic3r::IPrinterAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    selected_machine = dev_id;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, selected_machine, set_user_selected_machine(), and state_mutex.

Referenced by set_user_selected_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

start_discovery()

bool Slic3r::MoonrakerPrinterAgent::start_discovery ( bool start, bool sending )

overridevirtualinherited

Start or stop SSDP discovery.

Implements Slic3r::IPrinterAgent.

{
    (void) sending;
    if (start) {
        announce_printhost_device();
    }
    return true;
}

References announce_printhost_device(), and start_discovery().

Referenced by start_discovery().

Here is the call graph for this function:

Here is the caller graph for this function:

start_local_print()

int Slic3r::MoonrakerPrinterAgent::start_local_print ( PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn )

overridevirtualinherited

Start a LAN-only print.

Implements Slic3r::IPrinterAgent.

{
    if (update_fn)
        update_fn(PrintingStageCreate, 0, _u8L("Preparing..."));
 
    // Check cancellation
    if (cancel_fn && cancel_fn()) {
        return BAMBU_NETWORK_ERR_CANCELED;
    }
    // Determine the G-code file to upload
    // params.filename may be .3mf, params.dst_file contains actual G-code
    std::string gcode_path = params.filename;
    if (!params.dst_file.empty()) {
        gcode_path = params.dst_file;
    }
 
    // Check if file exists and has .gcode extension
    namespace fs = boost::filesystem;
    fs::path source_path(gcode_path);
    if (!fs::exists(source_path)) {
        BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: G-code file does not exist: " << gcode_path;
        return BAMBU_NETWORK_ERR_FILE_NOT_EXIST;
    }
 
    // Extract filename for upload (relative to gcodes root)
    std::string upload_filename = source_path.filename().string();
    if (!boost::iends_with(upload_filename, ".gcode")) {
        upload_filename += ".gcode";
    }
    // Sanitize filename to prevent path traversal attacks (extra safety)
    upload_filename = sanitize_filename(upload_filename);
 
    // Upload file
    if (update_fn)
        update_fn(PrintingStageUpload, 0, _u8L("Uploading G-code..."));
    if (!upload_gcode(gcode_path, upload_filename, device_info.base_url, device_info.api_key, update_fn, cancel_fn)) {
        return BAMBU_NETWORK_ERR_PRINT_LP_UPLOAD_FTP_FAILED;
    }
 
    // Check cancellation
    if (cancel_fn && cancel_fn()) {
        return BAMBU_NETWORK_ERR_CANCELED;
    }
 
    // Start print via gcode script (simpler than JSON-RPC)
    if (update_fn)
        update_fn(PrintingStageSending, 0, _u8L("Starting print..."));
    std::string gcode = "SDCARD_PRINT_FILE FILENAME=" + upload_filename;
    if (!send_gcode_sync(device_info.dev_id, gcode)) {
        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
    }
 
    if (update_fn)
        update_fn(PrintingStageFinished, 100, _u8L("Print started"));
    return BAMBU_NETWORK_SUCCESS;
}

References _u8L, BAMBU_NETWORK_ERR_CANCELED, BAMBU_NETWORK_ERR_FILE_NOT_EXIST, BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED, BAMBU_NETWORK_ERR_PRINT_LP_UPLOAD_FTP_FAILED, BAMBU_NETWORK_SUCCESS, device_info, Slic3r::PrintParams::dst_file, Slic3r::PrintParams::filename, Slic3r::PrintingStageCreate, Slic3r::PrintingStageFinished, Slic3r::PrintingStageSending, Slic3r::PrintingStageUpload, sanitize_filename(), send_gcode_sync(), start_local_print(), and upload_gcode().

Referenced by start_local_print().

Here is the call graph for this function:

Here is the caller graph for this function:

start_local_print_with_record()

int Slic3r::MoonrakerPrinterAgent::start_local_print_with_record ( PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn )

overridevirtualinherited

Start a local print with cloud record.

Implements Slic3r::IPrinterAgent.

{
    (void) params;
    (void) update_fn;
    (void) cancel_fn;
    (void) wait_fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, and start_local_print_with_record().

Referenced by start_local_print_with_record().

Here is the call graph for this function:

Here is the caller graph for this function:

start_print()

int Slic3r::MoonrakerPrinterAgent::start_print ( PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn )

overridevirtualinherited

Start a fully managed cloud print.

Implements Slic3r::IPrinterAgent.

{
    (void) params;
    (void) update_fn;
    (void) cancel_fn;
    (void) wait_fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, and start_print().

Referenced by start_print().

Here is the call graph for this function:

Here is the caller graph for this function:

start_sdcard_print()

int Slic3r::MoonrakerPrinterAgent::start_sdcard_print ( PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn )

overridevirtualinherited

Start a print from printer's SD card.

Implements Slic3r::IPrinterAgent.

{
    (void) params;
    (void) update_fn;
    (void) cancel_fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, and start_sdcard_print().

Referenced by start_sdcard_print().

Here is the call graph for this function:

Here is the caller graph for this function:

start_send_gcode_to_sdcard()

int Slic3r::MoonrakerPrinterAgent::start_send_gcode_to_sdcard ( PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn )

overridevirtualinherited

Upload gcode to printer's SD card without starting.

Implements Slic3r::IPrinterAgent.

{
    (void) wait_fn;
 
    if (update_fn)
        update_fn(PrintingStageCreate, 0, _u8L("Preparing..."));
 
    std::string filename = params.filename;
    if (filename.empty()) {
        filename = params.task_name;
    }
    if (!boost::iends_with(filename, ".gcode")) {
        filename += ".gcode";
    }
 
    // Sanitize filename to prevent path traversal attacks
    std::string safe_filename = sanitize_filename(filename);
 
    // Upload only, don't start print
    if (!upload_gcode(params.filename, safe_filename, device_info.base_url, device_info.api_key, update_fn, cancel_fn)) {
        return BAMBU_NETWORK_ERR_PRINT_SG_UPLOAD_FTP_FAILED;
    }
 
    if (update_fn)
        update_fn(PrintingStageFinished, 100, _u8L("File uploaded"));
    return BAMBU_NETWORK_SUCCESS;
}

References _u8L, BAMBU_NETWORK_ERR_PRINT_SG_UPLOAD_FTP_FAILED, BAMBU_NETWORK_SUCCESS, device_info, Slic3r::PrintParams::filename, Slic3r::PrintingStageCreate, Slic3r::PrintingStageFinished, sanitize_filename(), start_send_gcode_to_sdcard(), Slic3r::PrintParams::task_name, and upload_gcode().

Referenced by start_send_gcode_to_sdcard().

Here is the call graph for this function:

Here is the caller graph for this function:

start_status_stream()

void Slic3r::MoonrakerPrinterAgent::start_status_stream ( const std::string & dev_id, const std::string & base_url, const std::string & api_key )

protectedinherited

{
    stop_status_stream();
    if (base_url.empty()) {
        return;
    }
 
    std::lock_guard<std::mutex> lock(ws_abort_mutex);
    ws_stop.store(false);
    ws_thread = std::thread(
        [this, dev_id, base_url, api_key, timings = ws_timings]() { run_status_stream(dev_id, base_url, api_key, timings); });
}

References run_status_stream(), start_status_stream(), stop_status_stream(), ws_abort_mutex, ws_stop, ws_thread, and ws_timings.

Referenced by perform_connection_async(), and start_status_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

start_subscribe()

virtual int Slic3r::IPrinterAgent::start_subscribe ( std::string module )

inlinevirtualinherited

Subscribe to a logical module (for example app- or tunnel-scoped streams).

Reimplemented in Slic3r::BBLPrinterAgent.

{ (void) module; return BAMBU_NETWORK_SUCCESS; }

References BAMBU_NETWORK_SUCCESS, and Slic3r::module().

Here is the call graph for this function:

stop_status_stream()

void Slic3r::MoonrakerPrinterAgent::stop_status_stream ( )

protectedinherited

{
    std::thread stopped;
    {
        std::lock_guard<std::mutex> lock(ws_abort_mutex);
        ws_stop.store(true);
        if (ws_abort) {
            ws_abort();
        }
        // A callback on the stream thread can stop the stream, which then ends on its own and is joined later, outside connect_mutex
        if (ws_thread.get_id() != std::this_thread::get_id()) {
            stopped = std::move(ws_thread);
        }
    }
    if (stopped.joinable()) {
        stopped.join();
    }
}

References stop_status_stream(), ws_abort, ws_abort_mutex, ws_stop, and ws_thread.

Referenced by ~MoonrakerPrinterAgent(), connect_printer(), disconnect_printer(), start_status_stream(), and stop_status_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_subscribe()

virtual int Slic3r::IPrinterAgent::stop_subscribe ( std::string module )

inlinevirtualinherited

Stop listening to a formerly subscribed module.

Reimplemented in Slic3r::BBLPrinterAgent.

{ (void) module; return BAMBU_NETWORK_SUCCESS; }

References BAMBU_NETWORK_SUCCESS, and Slic3r::module().

Here is the call graph for this function:

to_orca_filament_id()

virtual std::string Slic3r::IPrinterAgent::to_orca_filament_id ( const std::string & printer_filament_id ) const

inlinevirtualinherited

Translate one filament id across the printer boundary.

Orca content-addresses every system filament; a printer, its AMS and its vendor cloud know only that vendor's own catalog ids. An agent whose printers already speak Orca's ids leaves them alone, and so does an id with no mapping.

Reimplemented in Slic3r::BBLPrinterAgent.

{ return printer_filament_id; }

trim_and_upper()

std::string Slic3r::MoonrakerPrinterAgent::trim_and_upper ( const std::string & input )

staticprotectedinherited

{
    std::string result = input;
    boost::trim(result);
    std::transform(result.begin(), result.end(), result.begin(),
                   [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
    return result;
}

References trim_and_upper().

Referenced by Slic3r::SnapmakerPrinterAgent::combine_filament_type(), map_filament_type_to_generic_id(), Slic3r::QidiPrinterAgent::map_filament_type_to_setting_id(), Slic3r::QidiPrinterAgent::normalize_filament_type(), and trim_and_upper().

Here is the call graph for this function:

Here is the caller graph for this function:

unbind()

virtual int Slic3r::IPrinterAgent::unbind ( std::string dev_id )

inlinevirtualinherited

Remove the association between account and printer.

Reimplemented in Slic3r::BBLPrinterAgent, and Slic3r::PyPrinterAgentPluginCapabilityTrampoline.

    {
        (void) dev_id;
        return BAMBU_NETWORK_SUCCESS;
    }

References BAMBU_NETWORK_SUCCESS.

Referenced by Slic3r::PrinterAgentPluginCapability::RegisterBindings().

Here is the caller graph for this function:

update_status_cache()

void Slic3r::MoonrakerPrinterAgent::update_status_cache ( const nlohmann::json & updates )

privateinherited

{
    if (!updates.is_object()) {
        return;
    }
 
    std::lock_guard<std::recursive_mutex> lock(payload_mutex);
    if (!status_cache.is_object()) {
        status_cache = nlohmann::json::object();
    }
 
    for (const auto& item : updates.items()) {
        if (item.value().is_object()) {
            nlohmann::json& target = status_cache[item.key()];
            if (!target.is_object()) {
                target = nlohmann::json::object();
            }
            for (const auto& field : item.value().items()) {
                target[field.key()] = field.value();
            }
        } else {
            status_cache[item.key()] = item.value();
        }
    }
}

References payload_mutex, status_cache, and update_status_cache().

Referenced by handle_ws_message(), perform_connection_async(), and update_status_cache().

Here is the call graph for this function:

Here is the caller graph for this function:

upload_gcode()

bool Slic3r::MoonrakerPrinterAgent::upload_gcode ( const std::string & local_path, const std::string & filename, const std::string & base_url, const std::string & api_key, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn )

privateinherited

{
    namespace fs = boost::filesystem;
 
    // Validate file exists
    fs::path source_path(local_path);
    if (!fs::exists(source_path)) {
        BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: File does not exist: " << local_path;
        return false;
    }
 
    // Check file size
    std::uintmax_t file_size = fs::file_size(source_path);
    if (file_size > 1024 * 1024 * 1024) { // 1GB limit
        BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: File too large: " << file_size << " bytes";
        return false;
    }
 
    // Sanitize filename to prevent path traversal attacks
    std::string safe_filename = sanitize_filename(filename);
 
    bool        result = true;
    std::string http_error;
 
    // Use Http::form_add and Http::form_add_file
    auto http = Http::post(join_url(base_url, "/server/files/upload"));
    if (!api_key.empty()) {
        http.header("X-Api-Key", api_key);
    }
    http.form_add("root", "gcodes") // Upload to gcodes directory
        .form_add("print", "false") // Don't auto-start print
        .form_add_file("file", source_path.string(), safe_filename)
        .timeout_connect(5)
        .timeout_max(300) // 5 minutes for large files
        .on_complete([&](std::string body, unsigned status) {
            (void) body;
            (void) status;
        })
        .on_error([&](std::string body, std::string err, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: Upload error: " << err << " HTTP " << status;
            http_error = err;
            result     = false;
        })
        .on_progress([&](Http::Progress progress, bool& cancel) {
            // Check for cancellation via WasCancelledFn
            if (cancel_fn && cancel_fn()) {
                cancel = true;
                result = false;
                return;
            }
            // Report progress via OnUpdateStatusFn
            if (update_fn && progress.ultotal > 0) {
                int percent = static_cast<int>((progress.ulnow * 100) / progress.ultotal);
                update_fn(PrintingStageUpload, percent, _u8L("Uploading..."));
            }
        })
        .perform_sync();
 
    if (!result) {
        BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: Upload failed: " << http_error;
        return false;
    }
 
    return true;
}

References _u8L, Slic3r::http, join_url(), Slic3r::Http::post(), Slic3r::PrintingStageUpload, sanitize_filename(), Slic3r::Http::Progress::ulnow, Slic3r::Http::Progress::ultotal, and upload_gcode().

Referenced by start_local_print(), start_send_gcode_to_sdcard(), and upload_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

available_objects

std::set<std::string> Slic3r::MoonrakerPrinterAgent::available_objects

privateinherited

Referenced by build_print_payload_locked(), and run_status_stream().

connect_generation

std::atomic<uint64_t> Slic3r::MoonrakerPrinterAgent::connect_generation {0}

privateinherited

{0};

Referenced by ~MoonrakerPrinterAgent(), connect_printer(), disconnect_printer(), and perform_connection_async().

connect_mutex

std::recursive_mutex Slic3r::MoonrakerPrinterAgent::connect_mutex

privateinherited

Referenced by ~MoonrakerPrinterAgent(), connect_printer(), disconnect_printer(), and perform_connection_async().

connect_thread

std::thread Slic3r::MoonrakerPrinterAgent::connect_thread

privateinherited

Referenced by ~MoonrakerPrinterAgent(), and connect_printer().

device_info

struct Slic3r::MoonrakerPrinterAgent::MoonrakerDeviceInfo Slic3r::MoonrakerPrinterAgent::device_info

protectedinherited

Referenced by ~MoonrakerPrinterAgent(), announce_printhost_device(), bind_detect(), build_ams_payload(), connect_printer(), disconnect_printer(), Slic3r::CrealityPrintAgent::fetch_filament_info(), Slic3r::QidiPrinterAgent::fetch_filament_info(), Slic3r::SnapmakerPrinterAgent::fetch_filament_info(), fetch_hh_filament_info(), fetch_moonraker_filament_data(), init_device_info(), perform_connection_async(), send_access_code(), send_gcode_async(), send_gcode_sync(), start_local_print(), and start_send_gcode_to_sdcard().

last_print_state

std::string Slic3r::MoonrakerPrinterAgent::last_print_state

privateinherited

Referenced by connect_printer(), and handle_ws_message().

m_cloud_agent

std::shared_ptr<ICloudServiceAgent> Slic3r::MoonrakerPrinterAgent::m_cloud_agent

privateinherited

Referenced by MoonrakerPrinterAgent(), and set_cloud_agent().

next_jsonrpc_id

std::atomic<int> Slic3r::MoonrakerPrinterAgent::next_jsonrpc_id {1}

privateinherited

{1};

on_local_connect_fn

OnLocalConnectedFn Slic3r::MoonrakerPrinterAgent::on_local_connect_fn

privateinherited

Referenced by dispatch_local_connect(), and set_on_local_connect_fn().

on_local_message_fn

OnMessageFn Slic3r::MoonrakerPrinterAgent::on_local_message_fn

privateinherited

Referenced by dispatch_message(), and set_on_local_message_fn().

on_message_fn

OnMessageFn Slic3r::MoonrakerPrinterAgent::on_message_fn

privateinherited

Referenced by dispatch_message(), and set_on_message_fn().

on_printer_connected_fn

OnPrinterConnectedFn Slic3r::MoonrakerPrinterAgent::on_printer_connected_fn

privateinherited

Referenced by dispatch_printer_connected(), and set_on_printer_connected_fn().

on_server_err_fn

OnServerErrFn Slic3r::MoonrakerPrinterAgent::on_server_err_fn

privateinherited

Referenced by set_server_callback().

on_ssdp_msg_fn

OnMsgArrivedFn Slic3r::MoonrakerPrinterAgent::on_ssdp_msg_fn

privateinherited

Referenced by announce_printhost_device(), and set_on_ssdp_msg_fn().

on_subscribe_failure_fn

GetSubscribeFailureFn Slic3r::MoonrakerPrinterAgent::on_subscribe_failure_fn

privateinherited

Referenced by set_on_subscribe_failure_fn().

on_user_message_fn

OnMessageFn Slic3r::MoonrakerPrinterAgent::on_user_message_fn

privateinherited

Referenced by set_on_user_message_fn().

payload_mutex

std::recursive_mutex Slic3r::MoonrakerPrinterAgent::payload_mutex

mutableprivateinherited

Referenced by connect_printer(), handle_ws_message(), run_status_stream(), send_heartbeat_if_due(), and update_status_cache().

queue_on_main_fn

QueueOnMainFn Slic3r::MoonrakerPrinterAgent::queue_on_main_fn

privateinherited

Referenced by dispatch_local_connect(), dispatch_message(), dispatch_printer_connected(), and set_queue_on_main_fn().

selected_machine

std::string Slic3r::MoonrakerPrinterAgent::selected_machine

privateinherited

Referenced by announce_printhost_device(), get_user_selected_machine(), and set_user_selected_machine().

ssdp_announced_host

std::string Slic3r::MoonrakerPrinterAgent::ssdp_announced_host

privateinherited

Referenced by announce_printhost_device().

ssdp_announced_id

std::string Slic3r::MoonrakerPrinterAgent::ssdp_announced_id

privateinherited

Referenced by announce_printhost_device().

state_mutex

std::recursive_mutex Slic3r::MoonrakerPrinterAgent::state_mutex

mutableprotectedinherited

Referenced by announce_printhost_device(), dispatch_local_connect(), dispatch_message(), dispatch_printer_connected(), get_user_selected_machine(), set_cloud_agent(), set_on_local_connect_fn(), set_on_local_message_fn(), set_on_message_fn(), set_on_printer_connected_fn(), set_on_ssdp_msg_fn(), set_on_subscribe_failure_fn(), set_on_user_message_fn(), set_queue_on_main_fn(), set_server_callback(), and set_user_selected_machine().

status_cache

nlohmann::json Slic3r::MoonrakerPrinterAgent::status_cache

privateinherited

Referenced by build_print_payload_locked(), connect_printer(), handle_ws_message(), and update_status_cache().

STATUS_UPDATE_INTERVAL_MS

uint64_t Slic3r::MoonrakerPrinterAgent::STATUS_UPDATE_INTERVAL_MS = 1000

staticconstexprprivateinherited

Referenced by handle_ws_message().

ws_abort

std::function<void()> Slic3r::MoonrakerPrinterAgent::ws_abort

privateinherited

Referenced by run_status_stream(), and stop_status_stream().

ws_abort_mutex

std::mutex Slic3r::MoonrakerPrinterAgent::ws_abort_mutex

privateinherited

Referenced by join_stopped_status_stream(), run_status_stream(), start_status_stream(), and stop_status_stream().

ws_last_dispatch_ms

std::atomic<uint64_t> Slic3r::MoonrakerPrinterAgent::ws_last_dispatch_ms {0}

privateinherited

{0};

Referenced by connect_printer(), and handle_ws_message().

ws_last_emit_ms

std::atomic<uint64_t> Slic3r::MoonrakerPrinterAgent::ws_last_emit_ms {0}

privateinherited

{0};

Referenced by connect_printer(), handle_ws_message(), and send_heartbeat_if_due().

ws_reconnect_requested

std::atomic<bool> Slic3r::MoonrakerPrinterAgent::ws_reconnect_requested {false}

privateinherited

{false};  // Flag to trigger reconnection

Referenced by handle_ws_message(), and run_status_stream().

ws_stop

std::atomic<bool> Slic3r::MoonrakerPrinterAgent::ws_stop {false}

privateinherited

{false};

Referenced by fetch_object_list(), join_stopped_status_stream(), run_status_stream(), start_status_stream(), and stop_status_stream().

ws_thread

std::thread Slic3r::MoonrakerPrinterAgent::ws_thread

privateinherited

Referenced by join_stopped_status_stream(), start_status_stream(), and stop_status_stream().

ws_timings

struct Slic3r::MoonrakerPrinterAgent::StatusStreamTimings Slic3r::MoonrakerPrinterAgent::ws_timings

protectedinherited

Referenced by start_status_stream().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/SnapmakerPrinterAgent.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/SnapmakerPrinterAgent.cpp