Slic3r::DeviceManager Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceCore/DevManager.h>

Collaboration diagram for Slic3r::DeviceManager:

Public Member Functions
	DeviceManager (NetworkAgent *agent=nullptr, bool enable_refresher=true, AppConfig *app_config=nullptr)
	~DeviceManager ()
NetworkAgent *	get_agent () const
AppConfig *	get_app_config () const
void	set_agent (NetworkAgent *agent)
void	start_refresher ()
void	stop_refresher ()
MachineObject *	get_selected_machine ()
bool	set_selected_machine (std::string dev_id)
void	OnSelectedMachineLost ()
void	record_user_last_machine (const std::string &dev_id)
std::string	get_user_last_machine () const
void	set_local_selected_machine (std::string dev_id)
MachineObject *	get_local_selected_machine () const
void	erase_local_machine (std::string dev_id)
std::map< std::string, MachineObject * >	get_local_machinelist () const
MachineObject *	get_local_machine (std::string dev_id) const
std::map< std::string, MachineObject * >	get_user_machinelist () const
std::string	get_first_online_user_machine () const
void	erase_user_machine (std::string dev_id)
void	clean_user_info (bool keep_local_selection=false)
void	clear_other_devices ()
void	load_last_machine ()
void	update_user_machine_list_info (const std::string &provider)
void	parse_user_print_info (std::string body)
void	reload_printer_settings ()
MachineObject *	get_user_machine (std::string dev_id, const std::string &provider)
void	add_user_subscribe ()
void	del_user_subscribe ()
void	subscribe_device_list (std::vector< std::string > dev_list)
MachineObject *	get_my_machine (std::string dev_id)
std::map< std::string, MachineObject * >	get_my_machine_list (const std::string &agent_id="")
std::map< std::string, MachineObject * >	get_my_cloud_machine_list (const std::string &agent_id="")
void	modify_device_name (std::string dev_id, std::string dev_name, const std::string &provider)
std::string	get_current_printer_agent_id () const
void	on_machine_alive (std::string json_str)
int	query_bind_status (std::string &msg, const std::string &provider)
void	EnableMultiMachine (bool enable=true)
bool	IsMultiMachineEnabled () const
MachineObject *	insert_local_device (const BBLocalMachine &machine, std::string connection_type, std::string bind_state, std::string version, std::string access_code)

Static Public Member Functions
static void	update_local_machine (const MachineObject &m)
static void	update_local_machine (const MachineObject &m, AppConfig *config)

Public Attributes
std::vector< std::string >	subscribe_list_cache
std::map< std::string, std::vector< std::string > >	device_subseries

Private Member Functions
void	load_local_machines_from_config ()
void	keep_alive ()
void	check_pushing ()
std::string	get_current_cloud_provider () const
void	OnMachineBindStateChanged (MachineObject *obj, const std::string &new_state)
void	OnSelectedMachineChanged (const std::string &pre_dev_id, const std::string &new_dev_id)

Private Attributes
NetworkAgent *	m_agent { nullptr }
AppConfig *	m_app_config { nullptr }
DeviceManagerRefresher *	m_refresher { nullptr }
bool	m_enable_mutil_machine = false
std::mutex	listMutex
std::string	selected_machine
std::string	local_selected_machine
std::map< std::string, MachineObject * >	localMachineList
std::map< std::string, MachineObject * >	userMachineList

Friends
class	GUI::GUI_App
class	DeviceManagerRefresher

Detailed Description

Constructor & Destructor Documentation

DeviceManager()

Slic3r::DeviceManager::DeviceManager	(	NetworkAgent *	agent = nullptr,
		bool	enable_refresher = true,
		AppConfig *	app_config = nullptr )

    {
        m_agent      = agent;
        m_app_config = app_config;
        if (enable_refresher)
            m_refresher = new DeviceManagerRefresher(this);
 
        DevPrinterConfigUtil::InitFilePath(resources_dir());
 
        // Load saved local machines (needs an agent; when built without one the load is
        // deferred to set_agent()).
        if (agent) {
            load_local_machines_from_config();
        }
    }

References DeviceManagerRefresher, Slic3r::DevPrinterConfigUtil::InitFilePath(), load_local_machines_from_config(), m_agent, m_app_config, m_refresher, and Slic3r::resources_dir().

Here is the call graph for this function:

~DeviceManager()

Slic3r::DeviceManager::~DeviceManager

(

)

    {
        if (m_refresher)
            delete m_refresher;
 
        for (auto it = localMachineList.begin(); it != localMachineList.end(); it++)
        {
            if (it->second)
            {
                delete it->second;
                it->second = nullptr;
            }
        }
        localMachineList.clear();
 
        for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
        {
            if (it->second)
            {
                delete it->second;
                it->second = nullptr;
            }
        }
        userMachineList.clear();
    }

References localMachineList, m_refresher, and userMachineList.

Member Function Documentation

add_user_subscribe()

void Slic3r::DeviceManager::add_user_subscribe

(

)

    {
        /* user machine */
        std::vector<std::string> dev_list;
        for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
        {
            dev_list.push_back(it->first);
            BOOST_LOG_TRIVIAL(trace) << "add_user_subscribe: " << it->first;
        }
        const int result = m_agent->add_subscribe(dev_list);
        BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: add_user_subscribe count=" << dev_list.size()
                                << " result=" << result;
    }

References m_agent, Slic3r::trace(), and userMachineList.

Here is the call graph for this function:

check_pushing()

void Slic3r::DeviceManager::check_pushing ( )

private

    {
        keep_alive();
        MachineObject* obj = this->get_selected_machine();
        if (!obj) {
            BOOST_LOG_TRIVIAL(warning) << "DeviceManager::check_pushing selected machine not found";
            return;
        }
 
        std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
        auto internal = std::chrono::duration_cast<std::chrono::milliseconds>(start - obj->last_update_time);
 
        if (!obj->is_support_mqtt_alive)
        {
            if (internal.count() > TIMEOUT_FOR_STRAT && internal.count() < 1000 * 60 * 60 * 300)
            {
                BOOST_LOG_TRIVIAL(info) << "command_pushing: diff = " << internal.count();
                obj->command_pushing("start");
            }
        }
    }

References Slic3r::MachineObject::command_pushing(), get_selected_machine(), Slic3r::MachineObject::is_support_mqtt_alive, keep_alive(), Slic3r::MachineObject::last_update_time, and TIMEOUT_FOR_STRAT.

Here is the call graph for this function:

clean_user_info()

void Slic3r::DeviceManager::clean_user_info

(

bool

keep_local_selection = false

)

    {
        BOOST_LOG_TRIVIAL(trace) << "DeviceManager::clean_user_info";
        const std::string previous_selected_machine = selected_machine;
        const bool keep_selected_machine = keep_local_selection &&
            !selected_machine.empty() &&
            localMachineList.find(selected_machine) != localMachineList.end();
 
        // clean user list
        for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
        {
            if (it->second)
            {
                it->second->set_access_code("");
                delete it->second;
                it->second = nullptr;
            }
        }
        userMachineList.clear();
 
        if (!keep_selected_machine) {
            selected_machine = "";
            local_selected_machine = "";
        }
 
        OnSelectedMachineChanged(previous_selected_machine, selected_machine);
    }

References local_selected_machine, localMachineList, OnSelectedMachineChanged(), selected_machine, Slic3r::trace(), and userMachineList.

Here is the call graph for this function:

clear_other_devices()

void Slic3r::DeviceManager::clear_other_devices

(

)

    {
        // Device entries are now scoped by printer_agent_id when they are presented. Keep
        // agent-owned discoveries across a switch so agents without automatic discovery (and
        // plugins whose devices have not received an access code yet) do not lose their list.
        // Entries without an owner are legacy/unscoped and cannot safely be shown.
        for (auto it = localMachineList.begin(); it != localMachineList.end();)
        {
            if (!it->second || it->second->printer_agent_id.empty())
            {
                delete it->second;
                it = localMachineList.erase(it);
            }
            else
            {
                ++it;
            }
        }
    }

References localMachineList.

del_user_subscribe()

void Slic3r::DeviceManager::del_user_subscribe

(

)

    {
        /* user machine */
        std::vector<std::string> dev_list;
        for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
        {
            dev_list.push_back(it->first);
            BOOST_LOG_TRIVIAL(trace) << "del_user_subscribe: " << it->first;
        }
        const int result = m_agent->del_subscribe(dev_list);
        BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: del_user_subscribe count=" << dev_list.size()
                                << " result=" << result;
    }

References m_agent, Slic3r::trace(), and userMachineList.

Here is the call graph for this function:

EnableMultiMachine()

void Slic3r::DeviceManager::EnableMultiMachine

(

bool

enable = true

)

    {
        m_agent->enable_multi_machine(enable);
        m_enable_mutil_machine = enable;
    }

References m_agent, and m_enable_mutil_machine.

erase_local_machine()

void Slic3r::DeviceManager::erase_local_machine ( std::string dev_id )

inline

{ localMachineList.erase(dev_id); }

References localMachineList.

erase_user_machine()

void Slic3r::DeviceManager::erase_user_machine ( std::string dev_id )

inline

{ userMachineList.erase(dev_id); }

References userMachineList.

Referenced by Slic3r::GUI::UnBindMachineDialog::on_unbind_printer().

Here is the caller graph for this function:

get_agent()

NetworkAgent * Slic3r::DeviceManager::get_agent ( ) const

inline

{ return m_agent; }

References m_agent.

get_app_config()

AppConfig * Slic3r::DeviceManager::get_app_config

(

)

const

    {
        return m_app_config ? m_app_config : GUI::wxGetApp().app_config;
    }

References m_app_config.

Referenced by get_user_last_machine(), insert_local_device(), load_local_machines_from_config(), on_machine_alive(), parse_user_print_info(), and record_user_last_machine().

Here is the caller graph for this function:

get_current_cloud_provider()

std::string Slic3r::DeviceManager::get_current_cloud_provider ( ) const

private

    {
        const std::string agent_id = get_current_printer_agent_id();
        if (!agent_id.empty())
            return agent_id == BBL_PRINTER_AGENT_ID ? BBL_CLOUD_PROVIDER : ORCA_CLOUD_PROVIDER;
        return GUI::wxGetApp().get_printer_cloud_provider();
    }

References Slic3r::BBL_CLOUD_PROVIDER(), Slic3r::BBL_PRINTER_AGENT_ID, get_current_printer_agent_id(), and Slic3r::ORCA_CLOUD_PROVIDER().

Referenced by parse_user_print_info().

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_printer_agent_id()

std::string Slic3r::DeviceManager::get_current_printer_agent_id

(

)

const

    {
        if (!m_agent)
            return "";
        auto printer_agent = m_agent->get_printer_agent();
        return printer_agent ? printer_agent->get_agent_info().id : "";
    }

References m_agent.

Referenced by Slic3r::GUI::_collect_sorted_machines(), Slic3r::GUI::PresetComboBox::add_connected_printers(), get_current_cloud_provider(), get_my_machine(), Slic3r::GUI::PresetComboBox::get_preset_item_name(), insert_local_device(), on_machine_alive(), parse_user_print_info(), set_selected_machine(), Slic3r::GUI::SelectMachinePopup::update_other_devices(), Slic3r::GUI::SelectMachinePopup::update_user_devices(), Slic3r::GUI::SelectMObjectPopup::update_user_devices(), Slic3r::GUI::SendToPrinterDialog::update_user_printer(), and Slic3r::GUI::SyncAmsInfoDialog::update_user_printer().

Here is the caller graph for this function:

get_first_online_user_machine()

std::string Slic3r::DeviceManager::get_first_online_user_machine

(

)

const

    {
        for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
        {
            if (it->second && it->second->is_online())
            {
                return it->second->get_dev_id();
            }
        }
        return "";
    }

References userMachineList.

get_local_machine()

MachineObject * Slic3r::DeviceManager::get_local_machine ( std::string dev_id ) const

inline

    {
        auto it = localMachineList.find(dev_id);
        return (it != localMachineList.end()) ? it->second : nullptr;
    }

References localMachineList.

Referenced by get_local_selected_machine(), and Slic3r::GUI::UnBindMachineDialog::on_unbind_printer().

Here is the caller graph for this function:

get_local_machinelist()

std::map< std::string, MachineObject * > Slic3r::DeviceManager::get_local_machinelist ( ) const

inline

{ return localMachineList; }

References localMachineList.

Referenced by Slic3r::GUI::SyncAmsInfoDialog::update_lan_machine_list(), Slic3r::GUI::SelectMachinePopup::update_other_devices(), and Slic3r::GUI::SyncAmsInfoDialog::update_user_printer().

Here is the caller graph for this function:

get_local_selected_machine()

MachineObject * Slic3r::DeviceManager::get_local_selected_machine ( ) const

inline

{ return get_local_machine(local_selected_machine); }

References get_local_machine(), and local_selected_machine.

Here is the call graph for this function:

get_my_cloud_machine_list()

std::map< std::string, MachineObject * > Slic3r::DeviceManager::get_my_cloud_machine_list

(

const std::string &

agent_id = ""

)

    {
        std::map<std::string, MachineObject*> result;
        for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
        {
            if (!it->second || (!agent_id.empty() && it->second->printer_agent_id != agent_id))
                continue;
 
            if (!it->second->is_lan_mode_printer()) { result.emplace(*it); }
        }
        return result;
    }

References userMachineList.

Referenced by Slic3r::GUI::CloudTaskManagerPage::refresh_user_device(), Slic3r::GUI::LocalTaskManagerPage::refresh_user_device(), Slic3r::GUI::MultiMachineManagerPage::refresh_user_device(), Slic3r::GUI::MultiMachinePickPage::refresh_user_device(), and Slic3r::GUI::SendMultiMachinePage::refresh_user_device().

Here is the caller graph for this function:

get_my_machine()

MachineObject * Slic3r::DeviceManager::get_my_machine

(

std::string

dev_id

)

    {
        auto list = get_my_machine_list(get_current_printer_agent_id());
        auto it = list.find(dev_id);
        if (it != list.end())
        {
            return it->second;
        }
        return nullptr;
    }

References get_current_printer_agent_id(), and get_my_machine_list().

Referenced by Slic3r::GUI::SendToPrinterDialog::ChangeConnectMethod(), Slic3r::GUI::SelectMachineDialog::on_timer(), Slic3r::GUI::ThermalPreconditioningDialog::on_timer(), Slic3r::GUI::SelectMachineDialog::save_option_vals(), Slic3r::GUI::CalibrationPanel::update_all(), Slic3r::GUI::SendToPrinterDialog::update_show_status(), and Slic3r::GUI::ThermalPreconditioningDialog::update_thermal_remaining_time().

Here is the call graph for this function:

Here is the caller graph for this function:

get_my_machine_list()

std::map< std::string, MachineObject * > Slic3r::DeviceManager::get_my_machine_list

(

const std::string &

agent_id = ""

)

    {
        std::map<std::string, MachineObject*> result;
 
        for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
        {
            if (!it->second || (!agent_id.empty() && it->second->printer_agent_id != agent_id))
                continue;
 
            if (!it->second->is_lan_mode_printer())
            {
                result.insert(std::make_pair(it->first, it->second));
            }
        }
 
        for (auto it = localMachineList.begin(); it != localMachineList.end(); it++)
        {
            if (!it->second || (!agent_id.empty() && it->second->printer_agent_id != agent_id))
                continue;
 
            if (it->second->has_access_right() && it->second->is_avaliable() && it->second->is_lan_mode_printer())
            {
                // remove redundant in userMachineList
                if (result.find(it->first) == result.end())
                {
                    result.emplace(std::make_pair(it->first, it->second));
                }
            }
        }
        return result;
    }

References localMachineList, and userMachineList.

Referenced by Slic3r::GUI::_collect_sorted_machines(), Slic3r::GUI::PresetComboBox::add_connected_printers(), get_my_machine(), Slic3r::GUI::PresetComboBox::get_preset_item_name(), set_selected_machine(), Slic3r::GUI::SelectMachinePopup::update_user_devices(), Slic3r::GUI::SelectMObjectPopup::update_user_devices(), Slic3r::GUI::SendToPrinterDialog::update_user_printer(), and Slic3r::GUI::SyncAmsInfoDialog::update_user_printer().

Here is the caller graph for this function:

get_selected_machine()

MachineObject * Slic3r::DeviceManager::get_selected_machine

(

)

    {
        if (selected_machine.empty()) return nullptr;
 
        MachineObject* obj = get_user_machine(selected_machine, GUI::wxGetApp().get_printer_cloud_provider());
        if (obj)
            return obj;
 
        // return local machine has access code
        auto it = localMachineList.find(selected_machine);
        if (it != localMachineList.end())
        {
            if (it->second->has_access_right())
                return it->second;
        }
        return nullptr;
    }

References get_user_machine(), localMachineList, and selected_machine.

Referenced by Slic3r::GUI::AMSControl::AMSControl(), Slic3r::GUI::NewCalibrationHistoryDialog::NewCalibrationHistoryDialog(), Slic3r::GUI::StatusBasePanel::StatusBasePanel(), Slic3r::GUI::_collect_sorted_machines(), Slic3r::_get_filament_name_from_ams(), Slic3r::GUI::_get_used_nozzle_idxes(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::GUI::CalibUtils::calib_flowrate_X1C(), Slic3r::GUI::CalibUtils::calib_generic_auto_pa_cali(), Slic3r::GUI::CalibUtils::calib_generic_PA(), Slic3r::GUI::CalibUtils::calib_PA(), Slic3r::GUI::SelectMachineDialog::can_support_pa_auto_cali(), Slic3r::GUI::Plater::priv::check_ams_status_impl(), Slic3r::check_filaments_printable(), Slic3r::GUI::CameraPopup::check_func_supported(), Slic3r::GUI::check_nozzle_diameter_and_type(), check_pushing(), Slic3r::GUI::SelectMachineDialog::clear_nozzle_mapping(), Slic3r::GUI::CalibUtils::delete_PA_calib_result(), Slic3r::GUI::CalibUtils::emit_get_flow_ratio_calib_results(), Slic3r::GUI::CalibUtils::emit_get_PA_calib_infos(), Slic3r::GUI::CalibUtils::emit_get_PA_calib_results(), Slic3r::GUI::PartSkipDialog::fetchUrl(), Slic3r::GUI::Plater::priv::get_extruder_filament_info(), Slic3r::GUI::CalibUtils::get_flow_ratio_calib_results(), Slic3r::GUI::get_hms_wiki_url(), Slic3r::GUI::Plater::priv::get_machine_sync_status(), Slic3r::GUI::SelectMachineDialog::get_mapped_nozzle_str(), Slic3r::GUI::SelectMachineDialog::get_mapped_nozzles(), Slic3r::GUI::CalibUtils::get_PA_calib_results(), Slic3r::GUI::CalibUtils::get_PA_calib_tab(), Slic3r::GUI::SendToPrinterDialog::GetConnection(), Slic3r::GUI::SyncAmsInfoDialog::has_selector(), Slic3r::GUI::SelectMachineDialog::init_bind(), Slic3r::GUI::SyncAmsInfoDialog::init_bind(), Slic3r::GUI::GUI_App::is_blocking_printing(), Slic3r::GUI::SyncAmsInfoDialog::is_same_nozzle_type(), Slic3r::GUI::SelectMachineDialog::is_same_printer_model(), Slic3r::GUI::SyncAmsInfoDialog::is_same_printer_model(), Slic3r::GUI::AMSControl::isFilaSwitchReady(), keep_alive(), Slic3r::GUI::SelectMachineDialog::on_flow_cali_option_changed(), Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::SelectMachineDialog::on_ok_btn(), Slic3r::GUI::SelectMachineDialog::on_pa_value_option_changed(), Slic3r::GUI::SelectMachineDialog::on_reselect_dialog_btn_clicked(), Slic3r::GUI::MonitorPanel::on_select_printer(), Slic3r::GUI::SelectMachineDialog::on_selection_changed(), Slic3r::GUI::SendToPrinterDialog::on_selection_changed(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::GUI_App::on_start_subscribe_again(), Slic3r::GUI::CalibrationCaliPage::on_subtask_abort(), Slic3r::GUI::CalibrationCaliPage::on_subtask_pause_resume(), Slic3r::GUI::SelectMachineDialog::on_timelapse_storage_check_result(), Slic3r::GUI::SelectMachineDialog::on_timelapse_storage_check_timer(), Slic3r::GUI::SyncAmsInfoDialog::on_timer(), OnSelectedMachineChanged(), Slic3r::GUI::SelectMachineDialog::popup_filament_backup(), Slic3r::GUI::SyncAmsInfoDialog::popup_filament_backup(), Slic3r::GUI::Plater::print_job_finished(), Slic3r::GUI::PrintJob::process(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GUI::GUI_App::process_network_msg(), Slic3r::GUI::SelectMachineDialog::reset_and_sync_ams_list(), Slic3r::GUI::SyncAmsInfoDialog::reset_and_sync_ams_list(), Slic3r::GUI::CalibUtils::select_PA_calib_result(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::selected_printer(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::SelectMachineDialog::set_default_from_sdcard(), Slic3r::GUI::SelectMachineDialog::set_default_normal(), Slic3r::GUI::CalibUtils::set_PA_calib_result(), Slic3r::GUI::CalibrationPanel::Show(), Slic3r::GUI::MonitorPanel::Show(), Slic3r::GUI::UpgradePanel::Show(), Slic3r::GUI::GUI_App::show_modal_ip_address_enter_dialog(), Slic3r::GUI::SelectMachineDialog::show_status(), Slic3r::GUI::SyncAmsInfoDialog::show_status(), Slic3r::GUI::SelectMachineDialog::show_timelapse_folder_popup(), Slic3r::GUI::SelectMachineDialog::sync_ams_mapping_result(), Slic3r::GUI::CalibrationPanel::update_all(), Slic3r::GUI::MonitorPanel::update_all(), Slic3r::GUI::SelectMachineDialog::update_best_pos_dialog(), Slic3r::GUI::SelectMachineDialog::update_filament_change_count(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::SyncAmsInfoDialog::update_show_status(), Slic3r::GUI::SendToPrinterDialog::update_user_printer(), and Slic3r::GUI::AMSLib::UpdateInfo().

Here is the call graph for this function:

get_user_last_machine()

std::string Slic3r::DeviceManager::get_user_last_machine

(

)

const

    {
        if (AppConfig* config = get_app_config()) {
            const auto& user_last_machine = config->get("user_last_selected_machine");
            if (!user_last_machine.empty()) {
                return user_last_machine;
            } else if (m_agent) {
                return m_agent->get_user_selected_machine();
            }
        }
 
        return "";
    }

References get_app_config(), and m_agent.

Referenced by load_last_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

get_user_machine()

MachineObject * Slic3r::DeviceManager::get_user_machine	(	std::string	dev_id,
		const std::string &	provider )

    {
        if (!m_agent || !m_agent->is_user_login(provider))
        {
            return nullptr;
        }
 
        std::map<std::string, MachineObject*>::iterator it = userMachineList.find(dev_id);
        if (it == userMachineList.end()) return nullptr;
        return it->second;
    }

References m_agent, and userMachineList.

Referenced by get_selected_machine().

Here is the caller graph for this function:

get_user_machinelist()

std::map< std::string, MachineObject * > Slic3r::DeviceManager::get_user_machinelist ( ) const

inline

{ return userMachineList; }

References userMachineList.

insert_local_device()

MachineObject * Slic3r::DeviceManager::insert_local_device	(	const BBLocalMachine &	machine,
		std::string	connection_type,
		std::string	bind_state,
		std::string	version,
		std::string	access_code )

    {
        MachineObject* obj;
        auto           it = localMachineList.find(machine.dev_id);
        if (it != localMachineList.end()) {
            obj = it->second;
            // insert_local_device is called by the active agent, so a reused entry must follow
            // that agent as well; otherwise the agent-scoped printer list hides it.
            obj->printer_agent_id = get_current_printer_agent_id();
        } else {
            obj = new MachineObject(this, m_agent, machine.dev_name, machine.dev_id, machine.dev_ip);
            obj->printer_agent_id = get_current_printer_agent_id();
            localMachineList.insert(std::make_pair(machine.dev_id, obj));
        }
        if (machine.printer_type.empty())
            obj->printer_type = _parse_printer_type("C11");
        else
            obj->printer_type = _parse_printer_type(machine.printer_type);
        obj->dev_connection_type = connection_type == "farm" ? "lan":connection_type;
        obj->bind_state          = connection_type == "farm" ? "free":bind_state;
        obj->bind_sec_link = "secure";
        obj->bind_ssdp_version = version;
        obj->m_is_online = true;
        obj->last_alive = Slic3r::Utils::get_current_time_utc();
        obj->set_access_code(access_code, false);
 
        update_local_machine(*obj, get_app_config());
 
        return obj;
    }

References Slic3r::_parse_printer_type(), Slic3r::MachineObject::bind_sec_link, Slic3r::MachineObject::bind_ssdp_version, Slic3r::MachineObject::bind_state, Slic3r::MachineObject::dev_connection_type, Slic3r::BBLocalMachine::dev_id, Slic3r::BBLocalMachine::dev_ip, Slic3r::BBLocalMachine::dev_name, get_app_config(), get_current_printer_agent_id(), Slic3r::Utils::get_current_time_utc(), Slic3r::MachineObject::last_alive, localMachineList, m_agent, Slic3r::MachineObject::m_is_online, Slic3r::MachineObject::printer_agent_id, Slic3r::BBLocalMachine::printer_type, Slic3r::MachineObject::printer_type, Slic3r::MachineObject::set_access_code(), and update_local_machine().

Referenced by Slic3r::GUI::InputIpAddressDialog::workerThreadFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

IsMultiMachineEnabled()

bool Slic3r::DeviceManager::IsMultiMachineEnabled ( ) const

inline

{ return m_enable_mutil_machine; }

References m_enable_mutil_machine.

keep_alive()

void Slic3r::DeviceManager::keep_alive ( )

private

    {
        MachineObject* obj = this->get_selected_machine();
        if (obj)
        {
            if (obj->keep_alive_count == 0)
            {
                obj->last_keep_alive = std::chrono::system_clock::now();
            }
            obj->keep_alive_count++;
            std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
            auto internal = std::chrono::duration_cast<std::chrono::milliseconds>(start - obj->last_keep_alive);
            if (internal.count() > TIMEOUT_FOR_KEEPALIVE && (internal.count() < 1000 * 60 * 60 * 300))
            {
                BOOST_LOG_TRIVIAL(info) << "keep alive = " << internal.count() << ", count = " << obj->keep_alive_count;
                obj->command_request_push_all();
                obj->last_keep_alive = start;
            }
            else if (obj->m_push_count == 0)
            {
                BOOST_LOG_TRIVIAL(info) << "keep alive = " << internal.count() << ", push_count = 0, count = " << obj->keep_alive_count;
                obj->command_request_push_all();
                obj->last_keep_alive = start;
            }
        }
    }

References Slic3r::MachineObject::command_request_push_all(), get_selected_machine(), Slic3r::MachineObject::keep_alive_count, Slic3r::MachineObject::last_keep_alive, Slic3r::MachineObject::m_push_count, and TIMEOUT_FOR_KEEPALIVE.

Referenced by check_pushing().

Here is the call graph for this function:

Here is the caller graph for this function:

load_last_machine()

void Slic3r::DeviceManager::load_last_machine

(

)

    {
        // Only reconnect the remembered cloud machine. Do not select an arbitrary
        // first machine: agent swaps intentionally leave the selection empty until
        // the new agent explicitly selects its configured printer.
        if (userMachineList.empty())
            return;
 
        const auto& last_monitor_machine = get_user_last_machine();
        if (userMachineList.find(last_monitor_machine) != userMachineList.end())
            set_selected_machine(last_monitor_machine);
    }

References get_user_last_machine(), set_selected_machine(), and userMachineList.

Referenced by Slic3r::GUI::CalibrationPanel::Show(), Slic3r::GUI::MonitorPanel::Show(), and Slic3r::GUI::SendToPrinterDialog::update_user_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

load_local_machines_from_config()

void Slic3r::DeviceManager::load_local_machines_from_config ( )

private

    {
        AppConfig* config = get_app_config();
        if (!config)
            return;
        const auto local_machines = config->get_local_machines();
        for (auto& it : local_machines) {
            const auto& m = it.second;
            if (localMachineList.count(m.dev_id))
                continue;
            MachineObject* obj       = new MachineObject(this, m_agent, m.dev_name, m.dev_id, m.dev_ip);
            obj->printer_type        = m.printer_type;
            obj->printer_agent_id    = m.printer_agent_id;
            obj->dev_connection_type = "lan";
            obj->bind_state          = "free";
            obj->bind_sec_link       = "secure";
            obj->m_is_online         = true;
            obj->last_alive          = Slic3r::Utils::get_current_time_utc();
            obj->set_access_code(get_access_code_with_legacy_fallback(config, m.dev_id, obj->printer_agent_id), false);
            if (obj->has_access_right()) {
                localMachineList.insert(std::make_pair(m.dev_id, obj));
            } else {
                config->erase_local_machine(m.dev_id);
                delete obj;
            }
        }
    }

References Slic3r::MachineObject::bind_sec_link, Slic3r::MachineObject::bind_state, Slic3r::MachineObject::dev_connection_type, Slic3r::AppConfig::erase_local_machine(), get_app_config(), Slic3r::Utils::get_current_time_utc(), Slic3r::AppConfig::get_local_machines(), Slic3r::MachineObject::has_access_right(), Slic3r::MachineObject::last_alive, localMachineList, m_agent, Slic3r::MachineObject::m_is_online, Slic3r::MachineObject::printer_agent_id, Slic3r::MachineObject::printer_type, and Slic3r::MachineObject::set_access_code().

Referenced by DeviceManager(), and set_agent().

Here is the call graph for this function:

Here is the caller graph for this function:

modify_device_name()

void Slic3r::DeviceManager::modify_device_name	(	std::string	dev_id,
		std::string	dev_name,
		const std::string &	provider )

    {
        BOOST_LOG_TRIVIAL(trace) << "modify_device_name";
        if (m_agent)
        {
            int result = m_agent->modify_printer_name(dev_id, dev_name, provider);
            if (result == 0)
            {
                update_user_machine_list_info(provider);
            }
        }
    }

References m_agent, Slic3r::trace(), and update_user_machine_list_info().

Referenced by Slic3r::GUI::EditDevNameDialog::on_edit_name().

Here is the call graph for this function:

Here is the caller graph for this function:

on_machine_alive()

void Slic3r::DeviceManager::on_machine_alive

(

std::string

json_str

)

    {
        try {
            json j = json::parse(json_str);
            std::string dev_name        = j["dev_name"].get<std::string>();
            std::string dev_id          = j["dev_id"].get<std::string>();
            std::string dev_ip          = j["dev_ip"].get<std::string>();
            std::string printer_type_str= j["dev_type"].get<std::string>();
            std::string printer_signal  = j["dev_signal"].get<std::string>();
            std::string connect_type    = j["connect_type"].get<std::string>();
            std::string bind_state      = j["bind_state"].get<std::string>();
 
            // Passive discovery must not replace another agent's saved binding.
            if (get_current_printer_agent_id() == MOONRAKER_PRINTER_AGENT_ID) {
                if (AppConfig* config = get_app_config()) {
                    const auto& machines = config->get_local_machines();
                    auto it = machines.find(dev_id);
                    if (it != machines.end() && it->second.printer_agent_id != MOONRAKER_PRINTER_AGENT_ID) {
                        BOOST_LOG_TRIVIAL(warning) << "Ignoring Moonraker discovery for a device owned by another agent: " << dev_id;
                        return;
                    }
                }
            }
 
            if (connect_type == "farm") {
                connect_type ="lan";
                bind_state   = "free";
            }
 
            std::string sec_link = "";
            std::string ssdp_version = "";
            if (j.contains("sec_link")) {
                sec_link = j["sec_link"].get<std::string>();
            }
            if (j.contains("ssdp_version")) {
                ssdp_version = j["ssdp_version"].get<std::string>();
            }
            std::string connection_name = "";
            if (j.contains("connection_name")) {
                connection_name = j["connection_name"].get<std::string>();
            }
 
            MachineObject* obj;
 
            /* update userMachineList info */
            auto it = userMachineList.find(dev_id);
            if (it != userMachineList.end()) {
                // A reused entry may have been created while another printer agent was active.
                // The response was obtained through the current agent, so move ownership with
                // the entry; otherwise agent-scoped lists hide it after a preset switch.
                it->second->printer_agent_id = get_current_printer_agent_id();
                if (it->second->get_dev_ip() != dev_ip ||
                    it->second->bind_state != bind_state ||
                    it->second->bind_sec_link != sec_link ||
                    it->second->dev_connection_type != connect_type ||
                    it->second->bind_ssdp_version != ssdp_version)
                {
                    if (it->second->bind_state != bind_state) {
                        OnMachineBindStateChanged(it->second, bind_state);
                    }
 
                    it->second->set_dev_ip(dev_ip);
                    it->second->bind_state          = bind_state;
                    it->second->bind_sec_link       = sec_link;
                    it->second->dev_connection_type = connect_type;
                    it->second->bind_ssdp_version   = ssdp_version;
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " UpdateUserMachineInfo"
                        << ", dev_id= " << dev_id
                        << ", ip = "  <<dev_ip
                        << ", printer_name= " << dev_name
                        << ", con_type= " << connect_type << ", signal= " << printer_signal
                        << ", bind_state= " << bind_state;
                }
            }
 
            /* update localMachineList */
            it = localMachineList.find(dev_id);
            AppConfig* config = get_app_config();
 
            if (it != localMachineList.end()) {
                // update properties
                /* ip changed */
                obj = it->second;
                // A reused LAN entry may have been discovered while another printer agent was
                // active. The current discovery message establishes ownership for this agent.
                obj->printer_agent_id = get_current_printer_agent_id();
 
                if (obj->get_dev_ip().compare(dev_ip) != 0) {
                    if ( connection_name.empty() ) {
                        BOOST_LOG_TRIVIAL(info) << "MachineObject IP changed from " << obj->get_dev_ip()
                                                << " to " << dev_ip;
                        obj->set_dev_ip(dev_ip);
                    }
                    else {
                        if ( obj->dev_connection_name.empty() || obj->dev_connection_name.compare(connection_name) == 0) {
                            BOOST_LOG_TRIVIAL(info) << "MachineObject IP changed from " << obj->get_dev_ip()
                                                    << " to " << dev_ip << " connection_name is " << connection_name;
                            if(obj->dev_connection_name.empty()){obj->dev_connection_name = connection_name;}
                            obj->set_dev_ip(dev_ip);
                        }
                    }
                    /* ip changed reconnect mqtt */
                }
 
                if (obj->wifi_signal != printer_signal ||
                    obj->dev_connection_type != connect_type ||
                    obj->bind_state != bind_state ||
                    obj->bind_sec_link != sec_link ||
                    obj->bind_ssdp_version != ssdp_version ||
                    obj->printer_type != _parse_printer_type(printer_type_str))
                {
                    if (obj->dev_connection_type != connect_type ||
                        obj->bind_state != bind_state ||
                        obj->bind_sec_link != sec_link ||
                        obj->bind_ssdp_version != ssdp_version ||
                        obj->printer_type != _parse_printer_type(printer_type_str))
                    {
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " UpdateLocalMachineInfo"
                            << ", dev_id= " << dev_id
                            << ", ip = " << dev_ip
                            << ", printer_name= " << dev_name
                            << ", con_type= " << connect_type << ", signal= " << printer_signal
                            << ", bind_state= " << bind_state;
                    }
                    else
                    {
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " UpdateLocalMachineInfo_WIFI"
                            << ", dev_id= " << dev_id
                            << ", ip = "  << dev_ip
                            << ", printer_name= " << dev_name
                            << ", con_type= " << connect_type << ", signal= " << printer_signal
                            << ", bind_state= " << bind_state;
                    }
 
                    obj->wifi_signal         = printer_signal;
                    obj->dev_connection_type = connect_type;
                    obj->bind_state          = bind_state;
                    obj->bind_sec_link       = sec_link;
                    obj->bind_ssdp_version   = ssdp_version;
                    obj->printer_type        = _parse_printer_type(printer_type_str);
                }
 
                // U0 firmware
                if (obj->dev_connection_type.empty() && obj->bind_state.empty())
                    obj->bind_state = "free";
 
                obj->last_alive = Slic3r::Utils::get_current_time_utc();
                // Route through set_online_state() (rather than writing m_is_online directly) so the
                // DeviceOnline lifecycle event fires consistently; same effective value/behavior
                // here since the object was already online in the common case.
                obj->set_online_state(true);
                obj->set_dev_name(dev_name);
                /* if (!obj->dev_ip.empty()) {
                Slic3r::GUI::wxGetApp().app_config->set_str("ip_address", obj->dev_id, obj->dev_ip);
                Slic3r::GUI::wxGetApp().app_config->save();
                }*/
            }
            else {
                /* insert a new machine */
                obj = new MachineObject(this, m_agent, dev_name, dev_id, dev_ip);
                obj->printer_type = _parse_printer_type(printer_type_str);
                obj->printer_agent_id = get_current_printer_agent_id();
                obj->wifi_signal = printer_signal;
                obj->dev_connection_type = connect_type;
                obj->bind_state     = bind_state;
                obj->bind_sec_link  = sec_link;
                obj->dev_connection_name = connection_name;
                obj->bind_ssdp_version = ssdp_version;
                // Discovery establishes the initial reachability state. Do not report it as an
                // online transition; DeviceDiscovered below is the lifecycle event for a new
                // device. Subsequent updates route through set_online_state(), so a known device
                // still emits DeviceOnline/DeviceOffline when its reachability actually changes.
                obj->m_is_online = true;
 
                //load access code
                if (config) {
                    obj->set_access_code(get_access_code_with_legacy_fallback(config, dev_id, obj->printer_agent_id), false);
                }
                localMachineList.insert(std::make_pair(dev_id, obj));
 
                /* if (!obj->dev_ip.empty()) {
                Slic3r::GUI::wxGetApp().app_config->set_str("ip_address", obj->dev_id, obj->dev_ip);
                Slic3r::GUI::wxGetApp().app_config->save();
                }*/
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " New Machine, dev_id= " << dev_id
                    << ", ip = " << dev_ip <<", printer_name = " << dev_name
                    << ", con_type= " << connect_type <<", signal= " << printer_signal << ", bind_state= " << bind_state;
 
                // First discovery of a genuinely new device (not a periodic SSDP/heartbeat update to
                // an already-known one, which is handled in the branch above).
                {
                    LifecycleEventContext ctx;
                    ctx.name = dev_id;
                    ctx.code = LifecycleEvtCode::Ok;
                    fire_lifecycle_event(LifecycleEvent::DeviceDiscovered, ctx);
                }
            }
            update_local_machine(*obj, config);
        }
        catch (...) {
            ;
        }
    }

References Slic3r::_parse_printer_type(), Slic3r::MachineObject::bind_sec_link, Slic3r::MachineObject::bind_ssdp_version, Slic3r::MachineObject::bind_state, Slic3r::LifecycleEventContext::code, Slic3r::MachineObject::dev_connection_name, Slic3r::MachineObject::dev_connection_type, Slic3r::DeviceDiscovered, Slic3r::fire_lifecycle_event(), get_app_config(), get_current_printer_agent_id(), Slic3r::Utils::get_current_time_utc(), Slic3r::MachineObject::get_dev_ip(), Slic3r::MachineObject::last_alive, localMachineList, m_agent, Slic3r::MachineObject::m_is_online, Slic3r::MOONRAKER_PRINTER_AGENT_ID, Slic3r::LifecycleEventContext::name, Slic3r::Ok, OnMachineBindStateChanged(), Slic3r::MachineObject::printer_agent_id, Slic3r::MachineObject::printer_type, Slic3r::MachineObject::set_access_code(), Slic3r::MachineObject::set_dev_ip(), Slic3r::MachineObject::set_dev_name(), Slic3r::MachineObject::set_online_state(), update_local_machine(), userMachineList, and Slic3r::MachineObject::wifi_signal.

Here is the call graph for this function:

OnMachineBindStateChanged()

void Slic3r::DeviceManager::OnMachineBindStateChanged ( MachineObject * obj, const std::string & new_state )

private

    {
        if (!obj) { return; }
        if (obj->get_dev_id() == selected_machine)
        {
            if (new_state == "free") { OnSelectedMachineLost(); }
        }
    }

References Slic3r::MachineObject::get_dev_id(), OnSelectedMachineLost(), and selected_machine.

Referenced by on_machine_alive().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSelectedMachineChanged()

void Slic3r::DeviceManager::OnSelectedMachineChanged ( const std::string & pre_dev_id, const std::string & new_dev_id )

private

    {
        {
            LifecycleEventContext ctx;
            ctx.name = new_dev_id; // empty string is a valid deselection
            ctx.code = LifecycleEvtCode::Ok;
            fire_lifecycle_event(LifecycleEvent::DeviceSelected, ctx);
        }
        if (MachineObject* obj_ = get_selected_machine()) {
            GUI::wxGetApp().sidebar().update_sync_status(obj_);
            if(m_agent->get_filament_sync_mode() == FilamentSyncMode::subscription)
            {
                GUI::wxGetApp().sidebar().load_ams_list(obj_);
            }
        };
    }

References Slic3r::LifecycleEventContext::code, Slic3r::DeviceSelected, Slic3r::fire_lifecycle_event(), get_selected_machine(), m_agent, Slic3r::LifecycleEventContext::name, Slic3r::Ok, and Slic3r::subscription.

Referenced by clean_user_info(), and set_selected_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSelectedMachineLost()

void Slic3r::DeviceManager::OnSelectedMachineLost

(

)

    {
        GUI::wxGetApp().sidebar().update_sync_status(nullptr);
        GUI::wxGetApp().sidebar().load_ams_list(nullptr);
    }

Referenced by OnMachineBindStateChanged().

Here is the caller graph for this function:

parse_user_print_info()

void Slic3r::DeviceManager::parse_user_print_info

(

std::string

body

)

    {
        BOOST_LOG_TRIVIAL(trace) << "DeviceManager::parse_user_print_info";
        std::lock_guard<std::mutex> lock(listMutex);
 
        if (device_subseries.size() <= 0) {
            device_subseries = DevPrinterConfigUtil::get_all_subseries();
            if (device_subseries.size() <= 0) {
                device_subseries.insert(std::pair<std::string, std::vector<std::string>>("", std::vector<std::string>()));
            }
        }
 
        std::set<std::string> new_list;
        try
        {
            json j = json::parse(body);
 
            const bool has_request_context = j.contains("provider") && j.contains("agent_id") && j.contains("generation");
            const std::string current_provider = get_current_cloud_provider();
            const std::string provider = j.contains("provider") ? j["provider"].get<std::string>()
                                                                   : current_provider;
            const std::string agent_id = j.contains("agent_id") ? j["agent_id"].get<std::string>()
                                                                  : get_current_printer_agent_id();
            const std::uint64_t generation = j.value("generation", std::uint64_t(0));
 
            if (has_request_context &&
                (provider != current_provider ||
                 agent_id != get_current_printer_agent_id() ||
                 generation != (m_agent ? m_agent->get_user_machine_list_generation() : 0))) {
                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << ": ignoring stale response provider="
                                         << provider << " agent_id=" << agent_id
                                         << " generation=" << generation;
                return;
            }
 
#if !BBL_RELEASE_TO_PUBLIC
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": " << j;
#endif
 
            if (j.contains("devices") && !j["devices"].is_null())
            {
                for (auto& elem : j["devices"])
                {
                    MachineObject* obj = nullptr;
                    std::string dev_id;
                    if (!elem["dev_id"].is_null())
                    {
                        dev_id = elem["dev_id"].get<std::string>();
                        new_list.insert(dev_id);
                    }
                    std::map<std::string, MachineObject*>::iterator iter = userMachineList.find(dev_id);
                    if (iter != userMachineList.end())
                    {
                        /* update field */
                        obj = iter->second;
                        obj->set_dev_id(dev_id);
                        // A device can be rediscovered by a different agent after a preset
                        // switch while retaining the same MachineObject instance.
                        obj->printer_agent_id = agent_id;
                    }
                    else
                    {
                        obj = new MachineObject(this, m_agent, "", "", "");
                        obj->printer_agent_id = agent_id;
                        if (m_agent)
                        {
                            obj->set_bind_status(m_agent->get_user_name(provider));
                        }
 
                        if (obj->get_dev_ip().empty())
                        {
                            if (AppConfig* config = get_app_config())
                                obj->get_dev_ip() = config->get("ip_address", dev_id);
                        }
                        userMachineList.insert(std::make_pair(dev_id, obj));
                    }
 
                    if (!obj) continue;
 
                    // Orca cloud printers are only ever delivered through this REST
                    // account list; tag them so DeviceManager's cloud/lan branches
                    // (subscribe + deselect in set_selected_machine) treat them right.
                    if (provider == ORCA_CLOUD_PROVIDER)
                        obj->dev_connection_type = "cloud";
 
                    if (!elem["dev_id"].is_null())
                        obj->set_dev_id(elem["dev_id"].get<std::string>());
                    if (!elem["dev_name"].is_null())
                        obj->set_dev_name(elem["dev_name"].get<std::string>());
                    if (!elem["dev_online"].is_null())
                        obj->m_is_online = elem["dev_online"].get<bool>();
                    if (elem.contains("dev_model_name") && !elem["dev_model_name"].is_null()) {
                        auto printer_type = elem["dev_model_name"].get<std::string>();
                        for (const auto &pair : device_subseries) {
                            auto it = std::find(pair.second.begin(), pair.second.end(), printer_type);
                            if (it != pair.second.end())
                            {
                                obj->printer_type = Slic3r::_parse_printer_type(pair.first);
                                break;
                            }
                            else
                            {
                                obj->printer_type = Slic3r::_parse_printer_type(printer_type);
                            }
                        }
                    }
                    if (!elem["task_status"].is_null())
                        obj->iot_print_status = elem["task_status"].get<std::string>();
                    if (elem.contains("dev_product_name") && !elem["dev_product_name"].is_null())
                        obj->dev_product_name = elem["dev_product_name"].get<std::string>();
                    if (elem.contains("dev_access_code") && !elem["dev_access_code"].is_null())
                    {
                        std::string acc_code = elem["dev_access_code"].get<std::string>();
                        acc_code.erase(std::remove(acc_code.begin(), acc_code.end(), '\n'), acc_code.end());
                        obj->set_access_code(acc_code);
                    }
 
                    BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: parsed cloud machine dev_id=" << dev_id
                                            << " name=" << obj->get_dev_name()
                                            << " agent_id=" << obj->printer_agent_id
                                            << " connection_type=" << obj->connection_type()
                                            << " online=" << obj->m_is_online;
                }
 
                //remove MachineObject from userMachineList
                std::map<std::string, MachineObject*>::iterator iterat;
                for (iterat = userMachineList.begin(); iterat != userMachineList.end(); )
                {
                    if (new_list.find(iterat->first) == new_list.end())
                    {
                        iterat = userMachineList.erase(iterat);
                    }
                    else
                    {
                        iterat++;
                    }
                }
                BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: parse_user_print_info complete provider=" << provider
                                        << " parsed_count=" << new_list.size()
                                        << " stored_count=" << userMachineList.size();
            }
        }
        catch (std::exception& e)
        {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " exception=" << e.what();
        }
    }

References Slic3r::_parse_printer_type(), Slic3r::MachineObject::connection_type(), Slic3r::MachineObject::dev_connection_type, Slic3r::MachineObject::dev_product_name, device_subseries, Slic3r::DevPrinterConfigUtil::get_all_subseries(), get_app_config(), get_current_cloud_provider(), get_current_printer_agent_id(), Slic3r::MachineObject::get_dev_ip(), Slic3r::MachineObject::get_dev_name(), Slic3r::MachineObject::iot_print_status, listMutex, m_agent, Slic3r::MachineObject::m_is_online, Slic3r::ORCA_CLOUD_PROVIDER(), Slic3r::MachineObject::printer_agent_id, Slic3r::MachineObject::printer_type, Slic3r::MachineObject::set_access_code(), Slic3r::MachineObject::set_bind_status(), Slic3r::MachineObject::set_dev_id(), Slic3r::MachineObject::set_dev_name(), Slic3r::trace(), and userMachineList.

Referenced by Slic3r::GUI::SelectMachinePopup::update_user_devices(), Slic3r::GUI::SelectMObjectPopup::update_user_devices(), update_user_machine_list_info(), Slic3r::GUI::SelectMachineDialog::update_user_printer(), Slic3r::GUI::SendToPrinterDialog::update_user_printer(), and Slic3r::GUI::SyncAmsInfoDialog::update_user_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

query_bind_status()

int Slic3r::DeviceManager::query_bind_status	(	std::string &	msg,
		const std::string &	provider )

    {
        if (!m_agent)
        {
            msg = "";
            return -1;
        }
 
        BOOST_LOG_TRIVIAL(trace) << "DeviceManager::query_bind_status";
        std::map<std::string, MachineObject*>::iterator it;
        std::vector<std::string> query_list;
        for (it = localMachineList.begin(); it != localMachineList.end(); it++)
        {
            query_list.push_back(it->first);
        }
 
        unsigned int http_code;
        std::string http_body;
        int result = m_agent->query_bind_status(query_list, &http_code, &http_body, provider);
 
        if (result < 0)
        {
            msg = (boost::format("code=%1%,body=%2") % http_code % http_body).str();
        }
        else
        {
            msg = "";
            try
            {
                json j = json::parse(http_body);
                if (j.contains("bind_list"))
                {
 
                    for (auto& item : j["bind_list"])
                    {
                        auto it = localMachineList.find(item["dev_id"].get<std::string>());
                        if (it != localMachineList.end())
                        {
                            if (!item["user_id"].is_null())
                                it->second->bind_user_id = item["user_id"].get<std::string>();
                            if (!item["user_name"].is_null())
                                it->second->bind_user_name = item["user_name"].get<std::string>();
                            else
                                it->second->bind_user_name = "Free";
                        }
                    }
                }
            }
            catch (...)
            {
                ;
            }
        }
        return result;
    }

References localMachineList, m_agent, and Slic3r::trace().

Here is the call graph for this function:

record_user_last_machine()

void Slic3r::DeviceManager::record_user_last_machine

(

const std::string &

dev_id

)

    {
        if (AppConfig* config = get_app_config()) {
            config->set("user_last_selected_machine", dev_id);
        }
    }

References get_app_config().

Referenced by set_selected_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

reload_printer_settings()

void Slic3r::DeviceManager::reload_printer_settings

(

)

    {
        for (auto obj : this->userMachineList) { obj.second->reload_printer_settings(); };
    }

References userMachineList.

set_agent()

void Slic3r::DeviceManager::set_agent

(

NetworkAgent *

agent

)

    {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": updating agent for "
                                << localMachineList.size() << " local and "
                                << userMachineList.size() << " user machines";
 
        // First real agent after an agent-less construction (network plugin wasn't ready at
        // startup): run the persisted-LAN-printer load the constructor had to skip. See
        // load_local_machines_from_config().
        const bool first_real_agent = (m_agent == nullptr && agent != nullptr);
        m_agent = agent;
 
        std::lock_guard<std::mutex> lock(listMutex);
        for (auto& it : localMachineList) {
            if (it.second) {
                it.second->set_agent(agent);
            }
        }
        for (auto& it : userMachineList) {
            if (it.second) {
                it.second->set_agent(agent);
            }
        }
 
        if (first_real_agent) {
            load_local_machines_from_config();
        }
    }

References listMutex, load_local_machines_from_config(), localMachineList, m_agent, and userMachineList.

Here is the call graph for this function:

set_local_selected_machine()

void Slic3r::DeviceManager::set_local_selected_machine ( std::string dev_id )

inline

{ local_selected_machine = dev_id; };

References local_selected_machine.

set_selected_machine()

bool Slic3r::DeviceManager::set_selected_machine

(

std::string

dev_id

)

    {
        BOOST_LOG_TRIVIAL(info) << "set_selected_machine=" << dev_id
            << " cur_selected=" << selected_machine;
        auto my_machine_list = get_my_machine_list(get_current_printer_agent_id());
        auto it = my_machine_list.find(dev_id);
        BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: set_selected_machine lookup dev_id=" << dev_id
                                << " found=" << (it != my_machine_list.end())
                                << " my_machine_count=" << my_machine_list.size()
                                << " current_agent=" << get_current_printer_agent_id()
                                << " provider=" << GUI::wxGetApp().get_printer_cloud_provider();
        if (it != my_machine_list.end() && it->second) {
            BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: target machine dev_id=" << it->second->get_dev_id()
                                    << " printer_agent_id=" << it->second->printer_agent_id
                                    << " connection_type=" << it->second->connection_type()
                                    << " dev_connection_type=" << it->second->dev_connection_type;
        } else if (!dev_id.empty()) {
            BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: target machine was not found in the current agent's machine list";
            return false;
        }
 
        // disconnect last if dev_id difference from previous one
        auto last_selected = my_machine_list.find(selected_machine);
        if (last_selected != my_machine_list.end() && selected_machine != dev_id)
        {
            if (last_selected->second->connection_type() == "lan")
            {
                m_agent->disconnect_printer();
            }
            else if (last_selected->second->connection_type() == "cloud") {
                const int result = m_agent->set_user_selected_machine("");
                BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: cleared previous cloud selection dev_id="
                                        << selected_machine << " result=" << result;
            }
        }
 
        // connect curr
        if (it != my_machine_list.end())
        {
            if (selected_machine == dev_id)
            {
                // same dev_id, cloud => reset update time
                if (it->second->connection_type() != "lan")
                {
                    BOOST_LOG_TRIVIAL(info) << "set_selected_machine: same cloud machine, dev_id =" << dev_id
                        << ", just reset update time";
 
                    // only reset update time
                    it->second->reset_update_time();
 
                    // check subscribe state
                    Slic3r::GUI::wxGetApp().on_start_subscribe_again(dev_id);
 
                    return true;
                }
                // same dev_id, lan => disconnect and reconnect
                else
                {
                    BOOST_LOG_TRIVIAL(info) << "set_selected_machine: same lan machine, dev_id =" << dev_id
                        << ", disconnect and reconnect";
 
                    // lan mode printer reconnect printer
                    if (m_agent)
                    {
                        m_agent->disconnect_printer();
                        it->second->reset();
 
                        it->second->connect();
                        it->second->set_lan_mode_connection_state(true);
                    }
                }
            }
            else
            {
                if (m_agent)
                {
                    if (it->second->connection_type() != "lan" || it->second->connection_type().empty())
                    {
                        // diff dev_id, cloud => set_user_selected_machine(new)
                        BOOST_LOG_TRIVIAL(info) << "set_selected_machine: select new cloud machine, dev_id =" << dev_id;
                        const int result = m_agent->set_user_selected_machine(dev_id);
                        BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: set new cloud selection dev_id="
                                                << dev_id << " result=" << result;
                        it->second->reset();
                    }
                    else
                    {
                        BOOST_LOG_TRIVIAL(info) << "set_selected_machine: select new lan machine, dev_id =" << dev_id;
                        it->second->reset();
                        it->second->connect();
                        it->second->set_lan_mode_connection_state(true);
                    }
                }
            }
            for (auto& data : it->second->m_nozzle_filament_data)
            {
                data.second.checked_filament.clear();
            }
        }
 
        if (selected_machine != dev_id) {
            OnSelectedMachineChanged(selected_machine, dev_id);
        }
 
        selected_machine = dev_id;
        record_user_last_machine(selected_machine);
        BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: DeviceManager selection complete selected_machine="
                                << selected_machine;
        return true;
    }

References get_current_printer_agent_id(), get_my_machine_list(), m_agent, OnSelectedMachineChanged(), record_user_last_machine(), selected_machine, and Slic3r::trace().

Referenced by load_last_machine(), Slic3r::GUI::MObjectPanel::on_mouse_left_up(), Slic3r::GUI::MonitorPanel::on_select_printer(), Slic3r::GUI::SelectMachineDialog::on_selection_changed(), Slic3r::GUI::SendToPrinterDialog::on_selection_changed(), Slic3r::UserManager::parse_json(), Slic3r::GUI::Plater::print_job_finished(), and Slic3r::GUI::CalibrationPanel::update_all().

Here is the call graph for this function:

Here is the caller graph for this function:

start_refresher()

void Slic3r::DeviceManager::start_refresher

(

)

{ if (m_refresher) m_refresher->Start(); }

References m_refresher.

stop_refresher()

void Slic3r::DeviceManager::stop_refresher

(

)

{ if (m_refresher) m_refresher->Stop(); }

References m_refresher.

subscribe_device_list()

void Slic3r::DeviceManager::subscribe_device_list

(

std::vector< std::string >

dev_list

)

    {
        std::vector<std::string> unsub_list;
        subscribe_list_cache.clear();
        for (auto& it : subscribe_list_cache)
        {
            if (it != selected_machine)
            {
                unsub_list.push_back(it);
                BOOST_LOG_TRIVIAL(trace) << "subscribe_device_list: unsub dev id = " << it;
            }
        }
        BOOST_LOG_TRIVIAL(trace) << "subscribe_device_list: unsub_list size = " << unsub_list.size();
 
        if (!selected_machine.empty())
        {
            subscribe_list_cache.push_back(selected_machine);
        }
        for (auto& it : dev_list)
        {
            subscribe_list_cache.push_back(it);
            BOOST_LOG_TRIVIAL(trace) << "subscribe_device_list: sub dev id = " << it;
        }
        BOOST_LOG_TRIVIAL(trace) << "subscribe_device_list: sub_list size = " << subscribe_list_cache.size();
        if (!unsub_list.empty())
            m_agent->del_subscribe(unsub_list);
        if (!dev_list.empty())
            m_agent->add_subscribe(subscribe_list_cache);
    }

References m_agent, selected_machine, subscribe_list_cache, and Slic3r::trace().

Referenced by Slic3r::GUI::CloudTaskManagerPage::refresh_user_device(), Slic3r::GUI::LocalTaskManagerPage::refresh_user_device(), Slic3r::GUI::MultiMachineManagerPage::refresh_user_device(), Slic3r::GUI::MultiMachinePickPage::refresh_user_device(), Slic3r::GUI::SendMultiMachinePage::refresh_user_device(), Slic3r::GUI::CloudTaskManagerPage::Show(), Slic3r::GUI::LocalTaskManagerPage::Show(), Slic3r::GUI::MultiMachineManagerPage::Show(), Slic3r::GUI::MultiMachinePickPage::Show(), and Slic3r::GUI::SendMultiMachinePage::Show().

Here is the call graph for this function:

Here is the caller graph for this function:

update_local_machine() [1/2]

void Slic3r::DeviceManager::update_local_machine ( const MachineObject & m )

static

    {
        update_local_machine(m, GUI::wxGetApp().app_config);
    }

References update_local_machine().

Referenced by insert_local_device(), on_machine_alive(), Slic3r::MachineObject::parse_json(), Slic3r::MachineObject::set_access_code(), and update_local_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

update_local_machine() [2/2]

void Slic3r::DeviceManager::update_local_machine ( const MachineObject & m, AppConfig * config )

static

    {
        if (config) {
            if (m.is_lan_mode_printer()) {
                if (m.has_access_right()) {
                    BBLocalMachine local_machine;
                    local_machine.dev_id           = m.get_dev_id();
                    local_machine.dev_name         = m.get_dev_name();
                    local_machine.dev_ip           = m.get_dev_ip();
                    local_machine.printer_type     = m.printer_type;
                    local_machine.printer_agent_id = m.printer_agent_id;
                    local_machine.access_code      = m.get_access_code();
                    config->update_local_machine(local_machine);
                }
            } else {
                config->erase_local_machine(m.get_dev_id());
            }
        }
    }

References Slic3r::BBLocalMachine::access_code, Slic3r::BBLocalMachine::dev_id, Slic3r::BBLocalMachine::dev_ip, Slic3r::BBLocalMachine::dev_name, Slic3r::AppConfig::erase_local_machine(), Slic3r::MachineObject::get_access_code(), Slic3r::MachineObject::get_dev_id(), Slic3r::MachineObject::get_dev_ip(), Slic3r::MachineObject::get_dev_name(), Slic3r::MachineObject::has_access_right(), Slic3r::MachineObject::is_lan_mode_printer(), Slic3r::BBLocalMachine::printer_agent_id, Slic3r::MachineObject::printer_agent_id, Slic3r::BBLocalMachine::printer_type, Slic3r::MachineObject::printer_type, and Slic3r::AppConfig::update_local_machine().

Here is the call graph for this function:

update_user_machine_list_info()

void Slic3r::DeviceManager::update_user_machine_list_info

(

const std::string &

provider

)

    {
        if (!m_agent) return;
 
        BOOST_LOG_TRIVIAL(debug) << "update_user_machine_list_info";
        unsigned int http_code;
        std::string body;
        int result = m_agent->get_user_print_info(&http_code, &body, provider);
        BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: get_user_print_info provider=" << provider
                                << " result=" << result << " http_code=" << http_code
                                << " body_bytes=" << body.size();
        if (result == 0)
        {
            // parse_user_print_info and on_machine_alive (SSDP for discovery) both mutate the same userMachineList map.
            // on_machine_alive mutates the map on the UI thread, do the same for parse_user_print_info.
            BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: queueing parse_user_print_info on UI thread";
            Slic3r::GUI::wxGetApp().CallAfter([this, body]() { parse_user_print_info(body); });
        }
    }

References m_agent, parse_user_print_info(), and Slic3r::trace().

Referenced by modify_device_name(), Slic3r::GUI::GUI_App::on_user_login_handle(), Slic3r::UserManager::parse_json(), and Slic3r::GUI::BindJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

DeviceManagerRefresher

friend class DeviceManagerRefresher

friend

References DeviceManagerRefresher.

Referenced by DeviceManager(), and DeviceManagerRefresher.

GUI::GUI_App

friend class GUI::GUI_App

friend

Member Data Documentation

device_subseries

std::map<std::string, std::vector<std::string> > Slic3r::DeviceManager::device_subseries

Referenced by parse_user_print_info().

listMutex

std::mutex Slic3r::DeviceManager::listMutex

private

Referenced by parse_user_print_info(), and set_agent().

local_selected_machine

std::string Slic3r::DeviceManager::local_selected_machine

private

Referenced by clean_user_info(), get_local_selected_machine(), and set_local_selected_machine().

localMachineList

std::map<std::string, MachineObject*> Slic3r::DeviceManager::localMachineList

private

Referenced by ~DeviceManager(), clean_user_info(), clear_other_devices(), erase_local_machine(), get_local_machine(), get_local_machinelist(), get_my_machine_list(), get_selected_machine(), insert_local_device(), load_local_machines_from_config(), on_machine_alive(), query_bind_status(), and set_agent().

m_agent

NetworkAgent* Slic3r::DeviceManager::m_agent { nullptr }

private

{ nullptr };

Referenced by DeviceManager(), add_user_subscribe(), del_user_subscribe(), EnableMultiMachine(), get_agent(), get_current_printer_agent_id(), get_user_last_machine(), get_user_machine(), insert_local_device(), load_local_machines_from_config(), modify_device_name(), on_machine_alive(), OnSelectedMachineChanged(), parse_user_print_info(), query_bind_status(), set_agent(), set_selected_machine(), subscribe_device_list(), and update_user_machine_list_info().

m_app_config

AppConfig* Slic3r::DeviceManager::m_app_config { nullptr }

private

{ nullptr };

Referenced by DeviceManager(), and get_app_config().

m_enable_mutil_machine

bool Slic3r::DeviceManager::m_enable_mutil_machine = false

private

Referenced by EnableMultiMachine(), and IsMultiMachineEnabled().

m_refresher

DeviceManagerRefresher* Slic3r::DeviceManager::m_refresher { nullptr }

private

{ nullptr };

Referenced by DeviceManager(), ~DeviceManager(), start_refresher(), and stop_refresher().

selected_machine

std::string Slic3r::DeviceManager::selected_machine

private

Referenced by clean_user_info(), get_selected_machine(), OnMachineBindStateChanged(), set_selected_machine(), and subscribe_device_list().

subscribe_list_cache

std::vector<std::string> Slic3r::DeviceManager::subscribe_list_cache

Referenced by subscribe_device_list().

userMachineList

std::map<std::string, MachineObject*> Slic3r::DeviceManager::userMachineList

private

Referenced by ~DeviceManager(), add_user_subscribe(), clean_user_info(), del_user_subscribe(), erase_user_machine(), get_first_online_user_machine(), get_my_cloud_machine_list(), get_my_machine_list(), get_user_machine(), get_user_machinelist(), load_last_machine(), on_machine_alive(), parse_user_print_info(), reload_printer_settings(), and set_agent().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceCore/DevManager.h
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceCore/DevManager.cpp