feat: Isolate devices across different printer agents

2026-09-17 05:52:39 +00:00 · 2026-08-06 16:11:44 +08:00
parent b2e05d0683
commit 159e577543
9 changed files with 157 additions and 32 deletions
@@ -10,20 +10,36 @@
 #include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/Plater.hpp"
+#include "slic3r/Utils/NetworkAgentFactory.hpp"

 #include "libslic3r/Time.hpp"

 using namespace nlohmann;

 namespace {
-    // Orca: access_code and user_access_code used to be separate AppConfig keys before the two
-    // fields were merged; fall back to the legacy key so existing users' saved codes aren't lost.
-    std::string get_access_code_with_legacy_fallback(Slic3r::AppConfig* config, const std::string& dev_id)
+    // Orca: access_code lives on BBLocalMachine::access_code (keyed by dev_id via
+    // get_local_machines(), scoped by the record's own printer_agent_id field) - so binding a
+    // printer under one agent doesn't silently appear as already-bound under a different,
+    // independent agent. This only covers LAN devices (BBLocalMachine's own scope); access_code
+    // and user_access_code used to be the only, flat dev_id-only AppConfig keys before
+    // BBLocalMachine::access_code existed, and codes saved back then are still stored flat (no
+    // agent association at all). Since BBL was the only agent that existed at the time, honor
+    // those flat legacy keys as implicitly BBL's - but only for the BBL agent, so they aren't
+    // leaked to other agents that never bound the device themselves.
+    std::string get_access_code_with_legacy_fallback(Slic3r::AppConfig* config, const std::string& dev_id, const std::string& agent_id)
    {
-        std::string code = config->get("access_code", dev_id);
-        if (code.empty())
-            code = config->get("user_access_code", dev_id);
-        return code;
+        const auto& machines = config->get_local_machines();
+        auto        it       = machines.find(dev_id);
+        if (it != machines.end() && it->second.printer_agent_id == agent_id && !it->second.access_code.empty())
+            return it->second.access_code;
+
+        if (agent_id == Slic3r::BBL_PRINTER_AGENT_ID || agent_id.empty()) {
+            std::string code = config->get("access_code", dev_id);
+            if (code.empty())
+                code = config->get("user_access_code", dev_id);
+            return code;
+        }
+        return "";
    }
 }

@@ -55,12 +71,13 @@ namespace Slic3r
                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), false);
+            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 {
@@ -77,10 +94,12 @@ namespace Slic3r
            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.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 {
@@ -143,6 +162,14 @@ namespace Slic3r
        }
    }

+    std::string 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 : "";
+    }
+
    void DeviceManager::EnableMultiMachine(bool enable)
    {
        m_agent->enable_multi_machine(enable);
@@ -339,6 +366,7 @@ namespace Slic3r
                /* 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;
@@ -350,7 +378,7 @@ namespace Slic3r
                //load access code
                AppConfig* config = Slic3r::GUI::wxGetApp().app_config;
                if (config) {
-                    obj->set_access_code(get_access_code_with_legacy_fallback(config, dev_id), false);
+                    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));

@@ -379,6 +407,7 @@ namespace Slic3r
            obj = it->second;
        } 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())
@@ -505,16 +534,26 @@ namespace Slic3r
        OnSelectedMachineChanged(previous_selected_machine, selected_machine);
    }

-    void DeviceManager::clear_other_devices()
+    void DeviceManager::clear_other_devices(const std::string& target_agent_id)
    {
        // why: on agent swap, keep "My Devices" but drop the transient "Other Devices"
        // Those belong to the previous agent's network scan; the new agent's start_discovery re-populates its own.
+        //
+        // Also drop "My Devices" stamped by a different agent than the one we're swapping to
+        // (target_agent_id, passed by the caller since the live agent hasn't been repointed yet
+        // at this point): otherwise a device first discovered under agent A survives every swap
+        // with a stale printer_agent_id, stays hidden from every agent's filtered list, and only
+        // gets re-tagged if something happens to delete and re-create it (e.g. account logout).
+        // Dropping it here instead lets the new agent's start_discovery re-insert and re-stamp it
+        // like any other fresh device.
        const auto my = get_my_machine_list();
        for (auto it = localMachineList.begin(); it != localMachineList.end();)
        {
-            if (my.find(it->first) == my.end())
+            const bool is_my_device = my.find(it->first) != my.end();
+            const bool agent_mismatch = !target_agent_id.empty() && it->second &&
+                                         it->second->printer_agent_id != target_agent_id;
+            if (!is_my_device || agent_mismatch)
            {
-                // not a "My Device" -> an "Other Device"
                delete it->second;
                it = localMachineList.erase(it);
            }
@@ -697,13 +736,16 @@ namespace Slic3r
            m_agent->add_subscribe(subscribe_list_cache);
    }

-    std::map<std::string, MachineObject*> DeviceManager::get_my_machine_list()
+    std::map<std::string, MachineObject*> 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 && !it->second->is_lan_mode_printer())
+            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));
            }
@@ -711,7 +753,10 @@ namespace Slic3r

        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())
+            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())
@@ -723,12 +768,15 @@ namespace Slic3r
        return result;
    }

-    std::map<std::string, MachineObject*> DeviceManager::get_my_cloud_machine_list()
+    std::map<std::string, MachineObject*> 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 && !it->second->is_lan_mode_printer()) { result.emplace(*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;
    }
@@ -801,6 +849,7 @@ namespace Slic3r
                    else
                    {
                        obj = new MachineObject(this, m_agent, "", "", "");
+                        obj->printer_agent_id = get_current_printer_agent_id();
                        if (m_agent)
                        {
                            obj->set_bind_status(m_agent->get_user_name(provider));