mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-05-14 09:02:06 +00:00
925 lines
35 KiB
C++
925 lines
35 KiB
C++
#include <nlohmann/json.hpp>
|
|
#include "DevManager.h"
|
|
#include "DevUtil.h"
|
|
|
|
// TODO: remove this include
|
|
#include "slic3r/GUI/DeviceManager.hpp"
|
|
#include "slic3r/GUI/I18N.hpp"
|
|
#include "slic3r/GUI/GUI_App.hpp"
|
|
#include "slic3r/GUI/Plater.hpp"
|
|
|
|
#include "libslic3r/Time.hpp"
|
|
|
|
using namespace nlohmann;
|
|
|
|
namespace Slic3r
|
|
{
|
|
DeviceManager::DeviceManager(NetworkAgent* agent)
|
|
{
|
|
m_agent = agent;
|
|
m_refresher = new DeviceManagerRefresher(this);
|
|
|
|
DevPrinterConfigUtil::InitFilePath(resources_dir());
|
|
|
|
// Load saved local machines
|
|
if (agent) {
|
|
AppConfig* config = GUI::wxGetApp().app_config;
|
|
const auto local_machines = config->get_local_machines();
|
|
for (auto& it : local_machines) {
|
|
const auto& m = it.second;
|
|
MachineObject* obj = new MachineObject(this, m_agent, m.dev_name, m.dev_id, m.dev_ip);
|
|
obj->printer_type = m.printer_type;
|
|
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(config->get("access_code", m.dev_id), false);
|
|
obj->set_user_access_code(config->get("user_access_code", m.dev_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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DeviceManager::update_local_machine(const MachineObject& m)
|
|
{
|
|
AppConfig* config = GUI::wxGetApp().app_config;
|
|
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;
|
|
config->update_local_machine(local_machine);
|
|
}
|
|
} else {
|
|
config->erase_local_machine(m.get_dev_id());
|
|
}
|
|
}
|
|
}
|
|
|
|
DeviceManager::~DeviceManager()
|
|
{
|
|
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();
|
|
}
|
|
|
|
void DeviceManager::set_agent(NetworkAgent* agent)
|
|
{
|
|
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": updating agent for "
|
|
<< localMachineList.size() << " local and "
|
|
<< userMachineList.size() << " user machines";
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DeviceManager::EnableMultiMachine(bool enable)
|
|
{
|
|
m_agent->enable_multi_machine(enable);
|
|
m_enable_mutil_machine = enable;
|
|
}
|
|
|
|
void DeviceManager::start_refresher() { m_refresher->Start(); }
|
|
void DeviceManager::stop_refresher() { m_refresher->Stop(); }
|
|
|
|
|
|
void DeviceManager::keep_alive()
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
void DeviceManager::check_pushing()
|
|
{
|
|
keep_alive();
|
|
MachineObject* obj = this->get_selected_machine();
|
|
|
|
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 && !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");
|
|
}
|
|
}
|
|
}
|
|
|
|
void 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>();
|
|
|
|
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()) {
|
|
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);
|
|
if (it != localMachineList.end()) {
|
|
// update properties
|
|
/* ip changed */
|
|
obj = it->second;
|
|
|
|
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();
|
|
obj->m_is_online = 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->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;
|
|
obj->m_is_online = true;
|
|
|
|
//load access code
|
|
AppConfig* config = Slic3r::GUI::wxGetApp().app_config;
|
|
if (config) {
|
|
obj->set_access_code(Slic3r::GUI::wxGetApp().app_config->get("access_code", dev_id), false);
|
|
obj->set_user_access_code(Slic3r::GUI::wxGetApp().app_config->get("user_access_code", dev_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;
|
|
}
|
|
update_local_machine(*obj);
|
|
}
|
|
catch (...) {
|
|
;
|
|
}
|
|
}
|
|
|
|
MachineObject* 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;
|
|
} else {
|
|
obj = new MachineObject(this, m_agent, machine.dev_name, machine.dev_id, machine.dev_ip);
|
|
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);
|
|
obj->set_user_access_code(access_code, false);
|
|
|
|
update_local_machine(*obj);
|
|
|
|
return obj;
|
|
}
|
|
|
|
int DeviceManager::query_bind_status(std::string& msg)
|
|
{
|
|
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);
|
|
|
|
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;
|
|
}
|
|
|
|
MachineObject* DeviceManager::get_user_machine(std::string dev_id)
|
|
{
|
|
if (!m_agent || !m_agent->is_user_login())
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
std::map<std::string, MachineObject*>::iterator it = userMachineList.find(dev_id);
|
|
if (it == userMachineList.end()) return nullptr;
|
|
return it->second;
|
|
}
|
|
|
|
MachineObject* DeviceManager::get_my_machine(std::string dev_id)
|
|
{
|
|
auto list = get_my_machine_list();
|
|
auto it = list.find(dev_id);
|
|
if (it != list.end())
|
|
{
|
|
return it->second;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void DeviceManager::clean_user_info()
|
|
{
|
|
BOOST_LOG_TRIVIAL(trace) << "DeviceManager::clean_user_info";
|
|
// reset selected_machine
|
|
selected_machine = "";
|
|
local_selected_machine = "";
|
|
|
|
OnSelectedMachineChanged(selected_machine, "");
|
|
|
|
// 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();
|
|
}
|
|
|
|
bool 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();
|
|
auto it = my_machine_list.find(dev_id);
|
|
|
|
// 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") {
|
|
m_agent->set_user_selected_machine("");
|
|
}
|
|
}
|
|
|
|
// 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();
|
|
|
|
#if !BBL_RELEASE_TO_PUBLIC
|
|
it->second->connect(Slic3r::GUI::wxGetApp().app_config->get("enable_ssl_for_mqtt") == "true" ? true : false);
|
|
#else
|
|
it->second->connect(it->second->local_use_ssl);
|
|
#endif
|
|
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;
|
|
m_agent->set_user_selected_machine(dev_id);
|
|
it->second->reset();
|
|
}
|
|
else
|
|
{
|
|
BOOST_LOG_TRIVIAL(info) << "set_selected_machine: select new lan machine, dev_id =" << dev_id;
|
|
it->second->reset();
|
|
#if !BBL_RELEASE_TO_PUBLIC
|
|
it->second->connect(Slic3r::GUI::wxGetApp().app_config->get("enable_ssl_for_mqtt") == "true" ? true : false);
|
|
#else
|
|
it->second->connect(it->second->local_use_ssl);
|
|
#endif
|
|
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;
|
|
return true;
|
|
}
|
|
|
|
MachineObject* DeviceManager::get_selected_machine()
|
|
{
|
|
if (selected_machine.empty()) return nullptr;
|
|
|
|
MachineObject* obj = get_user_machine(selected_machine);
|
|
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;
|
|
}
|
|
|
|
void 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;
|
|
}
|
|
m_agent->add_subscribe(dev_list);
|
|
}
|
|
|
|
|
|
void 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;
|
|
}
|
|
m_agent->del_subscribe(dev_list);
|
|
}
|
|
|
|
void 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);
|
|
}
|
|
|
|
std::map<std::string, MachineObject*> DeviceManager::get_my_machine_list()
|
|
{
|
|
std::map<std::string, MachineObject*> result;
|
|
|
|
for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
|
|
{
|
|
if (it->second && !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 && 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;
|
|
}
|
|
|
|
std::map<std::string, MachineObject*> DeviceManager::get_my_cloud_machine_list()
|
|
{
|
|
std::map<std::string, MachineObject*> result;
|
|
for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
|
|
{
|
|
if (it->second && !it->second->is_lan_mode_printer()) { result.emplace(*it); }
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::string 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 "";
|
|
}
|
|
|
|
void DeviceManager::modify_device_name(std::string dev_id, std::string dev_name)
|
|
{
|
|
BOOST_LOG_TRIVIAL(trace) << "modify_device_name";
|
|
if (m_agent)
|
|
{
|
|
int result = m_agent->modify_printer_name(dev_id, dev_name);
|
|
if (result == 0)
|
|
{
|
|
update_user_machine_list_info();
|
|
}
|
|
}
|
|
}
|
|
|
|
void 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);
|
|
|
|
#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);
|
|
}
|
|
else
|
|
{
|
|
obj = new MachineObject(this, m_agent, "", "", "");
|
|
if (m_agent)
|
|
{
|
|
obj->set_bind_status(m_agent->get_user_name());
|
|
}
|
|
|
|
if (obj->get_dev_ip().empty())
|
|
{
|
|
obj->get_dev_ip() = Slic3r::GUI::wxGetApp().app_config->get("ip_address", dev_id);
|
|
}
|
|
userMachineList.insert(std::make_pair(dev_id, obj));
|
|
}
|
|
|
|
if (!obj) continue;
|
|
|
|
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 std::pair<std::string, std::vector<std::string>> &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);
|
|
}
|
|
}
|
|
|
|
//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++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (std::exception& e)
|
|
{
|
|
BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " exception=" << e.what();
|
|
}
|
|
}
|
|
|
|
void DeviceManager::update_user_machine_list_info()
|
|
{
|
|
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);
|
|
if (result == 0)
|
|
{
|
|
parse_user_print_info(body);
|
|
}
|
|
}
|
|
|
|
void DeviceManager::load_last_machine()
|
|
{
|
|
// Get all available machines, include cloud machines and lan machines that have access right
|
|
auto all_machines = get_my_machine_list();
|
|
if (all_machines.empty())
|
|
return;
|
|
|
|
// Then connect to the machine we last selected if available
|
|
const std::string last_monitor_machine = m_agent ? m_agent->get_user_selected_machine() : "";
|
|
const auto last_machine = all_machines.find(last_monitor_machine);
|
|
if (last_machine != all_machines.end()) {
|
|
this->set_selected_machine(last_machine->second->get_dev_id());
|
|
} else {
|
|
// If not, then select the first available one
|
|
this->set_selected_machine(all_machines.begin()->second->get_dev_id());
|
|
}
|
|
}
|
|
|
|
void DeviceManager::OnMachineBindStateChanged(MachineObject* obj, const std::string& new_state)
|
|
{
|
|
if (!obj) { return; }
|
|
if (obj->get_dev_id() == selected_machine)
|
|
{
|
|
if (new_state == "free") { OnSelectedMachineLost(); }
|
|
}
|
|
}
|
|
|
|
void DeviceManager::OnSelectedMachineLost()
|
|
{
|
|
GUI::wxGetApp().sidebar().update_sync_status(nullptr);
|
|
GUI::wxGetApp().sidebar().load_ams_list(nullptr);
|
|
}
|
|
|
|
void DeviceManager::OnSelectedMachineChanged(const std::string& /*pre_dev_id*/,
|
|
const std::string& /*new_dev_id*/)
|
|
{
|
|
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_);
|
|
}
|
|
};
|
|
}
|
|
|
|
void DeviceManager::reload_printer_settings()
|
|
{
|
|
for (auto obj : this->userMachineList) { obj.second->reload_printer_settings(); };
|
|
}
|
|
|
|
|
|
DeviceManagerRefresher::DeviceManagerRefresher(DeviceManager* manger) : wxObject()
|
|
{
|
|
m_manager = manger;
|
|
m_timer = new wxTimer();
|
|
m_timer->Bind(wxEVT_TIMER, &DeviceManagerRefresher::on_timer, this);
|
|
}
|
|
|
|
DeviceManagerRefresher::~DeviceManagerRefresher()
|
|
{
|
|
m_timer->Stop();
|
|
delete m_timer;
|
|
}
|
|
|
|
void DeviceManagerRefresher::on_timer(wxTimerEvent& event)
|
|
{
|
|
if (!m_manager) { return; }
|
|
|
|
NetworkAgent* agent = m_manager->get_agent();
|
|
if (!agent) { return; }
|
|
|
|
// reset to active
|
|
Slic3r::GUI::wxGetApp().reset_to_active();
|
|
|
|
MachineObject* obj = m_manager->get_selected_machine();
|
|
if (!obj) { return; }
|
|
|
|
// check valid machine
|
|
if (obj && m_manager->get_my_machine(obj->get_dev_id()) == nullptr)
|
|
{
|
|
m_manager->set_selected_machine("");
|
|
agent->set_user_selected_machine("");
|
|
return;
|
|
}
|
|
|
|
// do some refresh
|
|
if (Slic3r::GUI::wxGetApp().is_user_login())
|
|
{
|
|
m_manager->check_pushing();
|
|
try
|
|
{
|
|
agent->refresh_connection();
|
|
}
|
|
catch (...)
|
|
{
|
|
;
|
|
}
|
|
}
|
|
|
|
// certificate
|
|
agent->install_device_cert(obj->get_dev_id(), obj->is_lan_mode_printer());
|
|
}
|
|
} |