Run the Cross-Process Lock Test on Every Platform

The test that checks the guard yields to a lock held elsewhere forked a
child to hold it, so it was left out on Windows. The OS lock belongs to
the handle on Windows and to the open file description elsewhere, so a
second handle in the same process is refused like another instance
would be. The test now holds the lock that way and runs everywhere.

.github/workflows/ofl-ota-cronjob.yml

@@ -146,7 +146,7 @@ jobs:
                 "repos/${{ github.repository }}/actions/workflows/post_merge_profiles.yml/runs" \
                 -f branch="$branch" -f event=workflow_dispatch -f per_page=100)"
               run_id="$(jq -r --arg marker "[OFL cron $dispatch_id]" \
-                '[.workflow_runs[] | select((.display_title // "") | contains($marker))]
+                '[.workflow_runs[] | select((.display_title // "") | contains($marker))] \
                 | sort_by(.created_at) | last | .id // empty' <<< "$runs_json")"
               [ -n "$run_id" ] && break
               sleep 5

.github/workflows/pr-label-bot.yml

@@ -35,7 +35,6 @@ jobs:
               // kind of change
               'crash',
               'bug-fix',
-              'SECURITY',
               'enhancement',
               'QoL',
               'optimization',
@@ -194,7 +193,6 @@ jobs:
               // kind of change
               'crash',
               'bug-fix',
-              'SECURITY',
               'enhancement',
               'QoL',
               'optimization',

CMakeLists.txt

@@ -834,37 +834,6 @@ find_package(OpenSSL REQUIRED)
 find_package(CURL REQUIRED)
 find_package(Freetype REQUIRED)
 
-if (SLIC3R_GUI)
-    # LibDataChannel's installed export references its bundled dependencies,
-    # but does not install their CMake targets. Recreate those targets from
-    # the same dependency prefix before loading the LibDataChannel config.
-    if (NOT TARGET Usrsctp::usrsctp)
-        find_library(_ORCA_USRSCTP_LIBRARY NAMES usrsctp
-            PATHS "${CMAKE_PREFIX_PATH}/lib" NO_DEFAULT_PATH)
-        if (_ORCA_USRSCTP_LIBRARY)
-            add_library(Usrsctp::usrsctp UNKNOWN IMPORTED GLOBAL)
-            set_target_properties(Usrsctp::usrsctp PROPERTIES
-                IMPORTED_LOCATION "${_ORCA_USRSCTP_LIBRARY}"
-                IMPORTED_LINK_INTERFACE_LANGUAGES C
-                INTERFACE_LINK_LIBRARIES "Threads::Threads")
-        endif()
-    endif()
-
-    if (NOT TARGET LibJuice::LibJuice)
-        find_library(_ORCA_LIBJUICE_LIBRARY NAMES juice
-            PATHS "${CMAKE_PREFIX_PATH}/lib" NO_DEFAULT_PATH)
-        if (_ORCA_LIBJUICE_LIBRARY)
-            add_library(LibJuice::LibJuice UNKNOWN IMPORTED GLOBAL)
-            set_target_properties(LibJuice::LibJuice PROPERTIES
-                IMPORTED_LOCATION "${_ORCA_LIBJUICE_LIBRARY}"
-                IMPORTED_LINK_INTERFACE_LANGUAGES C
-                INTERFACE_LINK_LIBRARIES "Threads::Threads")
-        endif()
-    endif()
-
-    find_package(LibDataChannel CONFIG REQUIRED)
-endif()
-
 
 add_library(libcurl INTERFACE)
 target_link_libraries(libcurl INTERFACE CURL::libcurl)
@@ -1145,7 +1114,6 @@ function(orcaslicer_copy_dlls target config postfix output_dlls)
     endif ()
     file(COPY ${_occt_dlls}
             ${CMAKE_PREFIX_PATH}/bin/freetype.dll
-            ${CMAKE_PREFIX_PATH}/bin/avformat-61.dll
             ${CMAKE_PREFIX_PATH}/bin/avcodec-61.dll
             ${CMAKE_PREFIX_PATH}/bin/swresample-5.dll
             ${CMAKE_PREFIX_PATH}/bin/swscale-8.dll
@@ -1158,7 +1126,6 @@ function(orcaslicer_copy_dlls target config postfix output_dlls)
         ${_out_dir}/WebView2Loader.dll
 
         ${_out_dir}/freetype.dll
-        ${_out_dir}/avformat-61.dll
         ${_out_dir}/avcodec-61.dll
         ${_out_dir}/swresample-5.dll
         ${_out_dir}/swscale-8.dll
@@ -1182,10 +1149,7 @@ function(orcaslicer_copy_sos target config postfix output_sos)
         set(_out_dir "${CMAKE_CURRENT_BINARY_DIR}")
     endif ()
 
-    file(COPY ${CMAKE_PREFIX_PATH}/lib/libavformat.so
-            ${CMAKE_PREFIX_PATH}/lib/libavformat.so.61
-            ${CMAKE_PREFIX_PATH}/lib/libavformat.so.61.1.100
-            ${CMAKE_PREFIX_PATH}/lib/libavcodec.so
+    file(COPY ${CMAKE_PREFIX_PATH}/lib/libavcodec.so
             ${CMAKE_PREFIX_PATH}/lib/libavcodec.so.61
             ${CMAKE_PREFIX_PATH}/lib/libavcodec.so.61.3.100
             ${CMAKE_PREFIX_PATH}/lib/libavutil.so
@@ -1200,9 +1164,6 @@ function(orcaslicer_copy_sos target config postfix output_sos)
          DESTINATION ${_out_dir})
 
     set(${output_sos}
-        ${_out_dir}/libavformat.so
-        ${_out_dir}/libavformat.so.61
-        ${_out_dir}/libavformat.so.61.1.100
         ${_out_dir}/libavcodec.so
         ${_out_dir}/libavcodec.so.61
         ${_out_dir}/libavcodec.so.61.3.100
@@ -1332,8 +1293,6 @@ endif ()
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
     set(LIBRARY_FILES
-    ${LIBDIR_BIN}/libavformat.so.61
-    ${LIBDIR_BIN}/libavformat.so.61.1.100
     ${LIBDIR_BIN}/libavcodec.so.61
     ${LIBDIR_BIN}/libavcodec.so.61.3.100
     ${LIBDIR_BIN}/libavutil.so.59

deps/CMakeLists.txt

@@ -164,7 +164,7 @@ if (NOT _is_multi AND NOT CMAKE_BUILD_TYPE)
 endif ()
 
 function(orcaslicer_add_cmake_project projectname)
-    cmake_parse_arguments(P_ARGS "FORWARD_CONFIG" "INSTALL_DIR;BUILD_COMMAND;INSTALL_COMMAND;SOURCE_DIR" "CMAKE_ARGS" ${ARGN})
+    cmake_parse_arguments(P_ARGS "FORWARD_CONFIG" "INSTALL_DIR;BUILD_COMMAND;INSTALL_COMMAND" "CMAKE_ARGS" ${ARGN})
 
     # MSVC is true for clang-cl as well, so the sub-build toolchain has to key on the
     # generator. A non-Visual-Studio superbuild passes its own generator down, and with
@@ -210,18 +210,12 @@ function(orcaslicer_add_cmake_project projectname)
       set(_build_j "-j${NPROC}")
     endif ()
 
-    set(_source_dir_arg "")
-    if (P_ARGS_SOURCE_DIR)
-        set(_source_dir_arg SOURCE_DIR ${P_ARGS_SOURCE_DIR})
-    endif ()
-
 if (NOT IS_CROSS_COMPILE OR NOT APPLE)
     ExternalProject_Add(
         dep_${projectname}
         EXCLUDE_FROM_ALL    ON
         INSTALL_DIR         ${DESTDIR}
         DOWNLOAD_DIR        ${DEP_DOWNLOAD_DIR}/${projectname}
-        ${_source_dir_arg}
         ${_gen}
         CMAKE_ARGS
             -DCMAKE_POLICY_VERSION_MINIMUM=3.5
@@ -255,14 +249,12 @@ if (NOT IS_CROSS_COMPILE OR NOT APPLE)
         # note for future devs: shared libs may actually create a size reduction
         # but orcaslicer_deps tends to get really funny regarding linking after that (notably boost)
         # so, as much as I would like to use that, it's not happening
-        if (NOT P_ARGS_SOURCE_DIR)
-            ExternalProject_Add_Step(dep_${projectname} free_download_space
-                    DEPENDEES download # do after download
-                    COMMENT "Freeing Space: Removing source archive"
-                    WORKING_DIRECTORY ${DEP_DOWNLOAD_DIR}
-                    COMMAND ${CMAKE_COMMAND} -E rm -rf ${projectname}
-            )
-        endif ()
+        ExternalProject_Add_Step(dep_${projectname} free_download_space
+                DEPENDEES download # do after download
+                COMMENT "Freeing Space: Removing source archive"
+                WORKING_DIRECTORY ${DEP_DOWNLOAD_DIR}
+                COMMAND ${CMAKE_COMMAND} -E rm -r ${projectname}
+        )
         ExternalProject_Add_Step(dep_${projectname} free_build_space
                 DEPENDEES install # do after install
                 COMMENT "Freeing Space: Removing source and build files"
@@ -276,7 +268,6 @@ else()
         EXCLUDE_FROM_ALL    ON
         INSTALL_DIR         ${DESTDIR}
         DOWNLOAD_DIR        ${DEP_DOWNLOAD_DIR}/${projectname}
-        ${_source_dir_arg}
         ${_gen}
         CMAKE_ARGS
             -DCMAKE_POLICY_VERSION_MINIMUM=3.5
@@ -405,6 +396,10 @@ include(libnoise/libnoise.cmake)
 
 include(Draco/Draco.cmake)
 
+include(FFMPEG/FFMPEG.cmake)
+include(Assimp/Assimp.cmake)
+
+
 # I *think* 1.1 is used for *just* md5 hashing?
 # 3.1 has everything in the right place, but the md5 funcs used are deprecated
 # a grep across the repo shows it is used for other things
@@ -415,12 +410,6 @@ if(NOT OPENSSL_FOUND)
     set(OPENSSL_PKG dep_OpenSSL)
 endif()
 
-include(FFMPEG/FFMPEG.cmake)
-include(Assimp/Assimp.cmake)
-
-include(DataChannel/DataChannel.cmake)
-set(DATACHANNEL_PKG dep_DataChannel)
-
 # we don't want to load a "wrong" openssl when loading curl
 # so, just don't even bother
 # ...i think this is how it works? change if wrong
@@ -494,7 +483,6 @@ set(_dep_list
     dep_wxInspector
     dep_FFMPEG
     dep_Assimp
-    ${DATACHANNEL_PKG}
     )
 
 if (MSVC)

deps/DataChannel/DataChannel.cmake

@@ -1,37 +0,0 @@
-# libdatachannel is the native ICE/DTLS/SCTP implementation used by the
-# GUI WebRTC camera controller. Keep the source revision fixed: the signaling
-# protocol is evolving independently of this transport dependency.
-#
-# It vendors plog, usrsctp and libjuice as git submodules, which a plain
-# GitHub tag tarball does not include. The flatpak sandbox has no network
-# access during the build, so there the manifest itself clones the repo
-# (submodules and all) into the dependency download directory before the
-# sandbox closes. ExternalProject_Add is pointed at that existing checkout
-# instead of being given its own network-dependent download method.
-if (FLATPAK)
-    set(_datachannel_source
-        SOURCE_DIR ${DEP_DOWNLOAD_DIR}/DataChannel
-    )
-else()
-    set(_datachannel_source
-        GIT_REPOSITORY https://github.com/paullouisageneau/libdatachannel.git
-        GIT_TAG v0.24.5
-        GIT_SHALLOW ON
-        GIT_SUBMODULES_RECURSE ON
-    )
-endif()
-
-orcaslicer_add_cmake_project(DataChannel
-    DEPENDS ${OPENSSL_PKG}
-    CMAKE_ARGS
-        -DNO_EXAMPLES=ON
-        -DNO_TESTS=ON
-        -DNO_WEBSOCKET=ON
-        -DNO_MEDIA=ON
-        -DUSE_NICE=OFF
-        -DUSE_SYSTEM_JUICE=OFF
-        -DUSE_SYSTEM_USRSCTP=OFF
-        -DOPENSSL_ROOT_DIR:PATH=${DESTDIR}
-        -DOPENSSL_USE_STATIC_LIBS=ON
-    ${_datachannel_source}
-)

deps/FFMPEG/FFMPEG.cmake

@@ -1,26 +1,14 @@
 set(_conf_cmd ./configure)
 
-set(_ffmpeg_depends)
-set(_ffmpeg_configure_command ${_conf_cmd})
-if (TARGET dep_OpenSSL)
-    set(_ffmpeg_depends DEPENDS dep_OpenSSL)
-    set(_ffmpeg_configure_command
-        ${CMAKE_COMMAND} -E env
-        "PKG_CONFIG_PATH=${DESTDIR}/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}"
-        ${_conf_cmd}
-    )
-endif()
-
 if (MSVC)
     set(_source_dir "${CMAKE_BINARY_DIR}/dep_FFMPEG-prefix/src/dep_FFMPEG")
 
-    set(PREBUILD_URL_arm64 "https://github.com/Noisyfox/FFmpeg-Builds-Orca/releases/download/autobuild-2026-09-18-16-50/ffmpeg-n7.0.3-33-g887d4b4919-winarm64-orca-shared-7.0.zip")
-    set(PREBUILD_HASH_arm64 "da480cbb39680056de824c57ec4dc3bd577b479ebbc310ff1f9dc55cf014b4c1")
-    set(PREBUILD_URL_x64 "https://github.com/Noisyfox/FFmpeg-Builds-Orca/releases/download/autobuild-2026-09-18-16-50/ffmpeg-n7.0.3-33-g887d4b4919-win64-orca-shared-7.0.zip")
-    set(PREBUILD_HASH_x64 "85da19daf198f5548259d8aabb349db84997a3f6e6886d8d7764114add9c6dae")
+    set(PREBUILD_URL_arm64 "https://github.com/Noisyfox/FFmpeg-Builds-Orca/releases/download/autobuild-2026-07-17-14-28/ffmpeg-n7.0.3-31-g9b6ffd74b5-winarm64-orca-shared-7.0.zip")
+    set(PREBUILD_HASH_arm64 "12f4140279f2f8469885e1b5b2e8be9d788882914c21523cacd56989f3548054")
+    set(PREBUILD_URL_x64 "https://github.com/Noisyfox/FFmpeg-Builds-Orca/releases/download/autobuild-2026-07-17-14-28/ffmpeg-n7.0.3-31-g9b6ffd74b5-win64-orca-shared-7.0.zip")
+    set(PREBUILD_HASH_x64 "e65916020ddb9ef84b2666dfbcbfc9b1d67f69d15b4a66db53754637bf2d498c")
 
     ExternalProject_Add(dep_FFMPEG
-        ${_ffmpeg_depends}
         URL ${PREBUILD_URL_${DEPS_ARCH}}
         URL_HASH SHA256=${PREBUILD_HASH_${DEPS_ARCH}}
         DOWNLOAD_DIR ${DEP_DOWNLOAD_DIR}/FFMPEG
@@ -33,8 +21,6 @@ if (MSVC)
     )
 
 else ()
-    set(_openssl_cmd --enable-openssl)
-
     if (APPLE)
         set(_minos_cmd
             "--extra-cflags=-mmacosx-version-min=${DEP_OSX_TARGET}"
@@ -66,11 +52,10 @@ else ()
     endif()
 
     ExternalProject_Add(dep_FFMPEG
-        ${_ffmpeg_depends}
         URL https://github.com/FFmpeg/FFmpeg/archive/refs/tags/n7.0.3.tar.gz
         URL_HASH SHA256=DEEDCABE339165214A3637DF4C86A507AEF0D793CF8774FF68735F4737E8DDBC
         DOWNLOAD_DIR ${DEP_DOWNLOAD_DIR}/FFMPEG
-        CONFIGURE_COMMAND ${_ffmpeg_configure_command}
+        CONFIGURE_COMMAND ${_conf_cmd}
             ${_cross_cmd}
             ${_pic_cmd}
             ${_arch_cmd}
@@ -78,21 +63,20 @@ else ()
             "--prefix=${DESTDIR}"
             ${_link_cmd}
             ${_minos_cmd}
-            ${_openssl_cmd}
             --disable-doc
             --enable-small
             --disable-outdevs
             --disable-filters
             --enable-filter=*null*,afade,*fifo,*format,*resample,aeval,allrgb,allyuv,atempo,pan,*bars,color,*key,crop,draw*,eq*,framerate,*_qsv,*_vaapi,*v4l2*,hw*,scale,volume,test*
             --disable-protocols
-            --enable-protocol=file,fd,pipe,http,https,rtp,tcp,udp
+            --enable-protocol=file,fd,pipe,rtp,udp
             --disable-muxers
             --enable-muxer=rtp
             --disable-encoders
             --disable-decoders
             --enable-decoder=*aac*,h264*,mp3*,mjpeg,rv*
             --disable-demuxers
-            --enable-demuxer=h264,mp3,mov,mpjpeg,rtsp,sdp
+            --enable-demuxer=h264,mp3,mov
             --disable-zlib
             --disable-avdevice
         BUILD_IN_SOURCE ON

docs/HLSD/printer-agent.md

@@ -1,240 +0,0 @@
-# Printer agents
-
-Printer agents isolate printer-specific communication from the rest of OrcaSlicer. The GUI and
-`DeviceManager` operate on a shared set of printer operations and device state; a selected printer
-agent implements those operations for a particular printer ecosystem. The agent boundary allows
-Bambu, Moonraker-based printers, built-in integrations, and Python-provided integrations to use the
-same application workflow without making the GUI understand every printer protocol.
-
-The current boundary is an adapter boundary around the existing application contract. In particular,
-some request fields and message payloads still use the Bambu-shaped representation that existing
-`MachineObject` and `DeviceManager` code consumes. The printer agent is responsible for translating
-that representation into the protocol spoken by its printer. This is an intentional compatibility
-constraint of the current design; the interface is not yet a neutral printer protocol.
-
-The v1 dialect migration path is deliberately narrow. `DeviceManager` currently speaks the Bambu JSON
-dialect because that is the payload shape already used throughout the command and state workflow. The
-v1 `OrcaPrinterAgent` also accepts that Bambu dialect. Its transport path places the small translation
-needed for the target printer at `deliver_to_sink`, keeping the compatibility code at the edge rather
-than spreading it through `DeviceManager` or the agent interface.
-
-The eventual direction is for `DeviceManager` to produce an Orca JSON dialect. The Bambu agent will then
-own the translation from Orca JSON to Bambu's protocol, while `OrcaPrinterAgent` can forward the Orca
-payload directly to its sink. The v1 translation at `deliver_to_sink` can then be removed without
-changing `DeviceManager`, the command callers, or the rest of the agent workflow.
-
-## Components
-
-The system has four relevant layers:
-
-```text
-GUI / DeviceManager / MachineObject
-              |
-        NetworkAgent
-          /       \
- IPrinterAgent   ICloudServiceAgent
-      |                 |
- printer protocol   authentication and cloud services
-```
-
-### `DeviceManager` and `MachineObject`
-
-`DeviceManager` owns the application-facing printer workflow. It maintains `MachineObject` instances,
-updates their state, filters devices for the active printer agent, and initiates operations such as
-homing, temperature changes, printing, subscriptions, and camera playback.
-
-`MachineObject` remains the shared state model used by the GUI. It does not contain the implementation
-of a printer protocol. When a device is discovered or returned by a cloud query, the device is tagged
-with the active `printer_agent_id`. Device lists and selected-machine operations use that tag to avoid
-sending an operation through an agent that does not own the device.
-
-### `NetworkAgent`
-
-`NetworkAgent` is the façade used by the GUI and `DeviceManager`. It owns:
-
-- the currently selected `IPrinterAgent`;
-- the registered cloud-service instances, indexed by provider;
-- callbacks shared by the active printer agent and the application;
-- the forwarding methods for printer commands and cloud operations.
-
-There is one active printer agent for the currently selected printer preset. Switching the preset
-increments the machine-list generation, disconnects the old printer agent, removes its callbacks, and
-installs the newly selected agent. The façade then forwards printer operations to that agent.
-
-Cloud operations are selected separately using a provider key. `NetworkAgent` forwards a cloud request
-to the matching `ICloudServiceAgent`, and forwards cloud camera operations with a device ID. The
-printer agent receives a cloud-agent pointer through `set_cloud_agent()` when it is created, allowing
-printer communication to obtain cloud tokens without depending on a concrete cloud implementation.
-
-### `IPrinterAgent`
-
-`IPrinterAgent` is the printer-facing contract. It covers:
-
-- cloud-relay and direct-LAN message delivery;
-- LAN connection, discovery, binding, and certificates;
-- printer subscriptions and callbacks;
-- print operations;
-- filament synchronization;
-- camera capability and local camera URL reporting;
-- printer command methods.
-
-Concrete built-in implementations include the Bambu wrapper, the native Orca/Moonraker path, and
-other printer-agent implementations registered by the application. A printer agent may use either
-the cloud agent, a direct LAN connection, or both.
-
-### `ICloudServiceAgent`
-
-`ICloudServiceAgent` owns authentication and services provided by a cloud backend. It covers login
-state, tokens, user and printer lists, settings synchronization, model services, cloud messages, and
-cloud camera operations.
-
-Cloud camera operations are device-scoped:
-
-- `get_camera_url(dev_id, callback)` obtains a stream URL for one device;
-- `create_camera_signaling_channel(dev_id)` creates signaling for one device where the provider
-  supports it.
-
-This is separate from the local camera URL exposed by `IPrinterAgent`, which is currently scoped to
-the active printer agent because a normal LAN agent represents one physical printer connection.
-
-## Agent registration and selection
-
-`NetworkAgentFactory` maintains the printer-agent registry. Each registry entry contains an agent ID,
-a display name, and a factory function. Built-in agents register during application initialization.
-Python printer-agent capabilities register dynamically and contribute an agent ID and factory entry.
-
-The selected printer preset contains the printer-agent choice. If no explicit choice is stored, the
-application preserves the existing default behavior: Bambu presets select the Bambu agent and other
-presets select the native Orca agent. When a preset is changed, `GUI_App` resolves the effective agent
-ID, obtains the corresponding cloud agent, creates the printer agent through the registry, and installs
-it in `NetworkAgent`.
-
-The registry rejects conflicting agent IDs. This matters for Python plugins because an agent ID is the
-stable identity used by presets and device ownership; two enabled plugin capabilities must not claim
-the same ID.
-
-## Message and command flow
-
-There are two low-level message paths:
-
-- `send_message()` publishes a command through the printer's cloud relay;
-- `send_message_to_printer()` sends a command directly to the printer over the LAN path.
-
-Both paths accept a JSON string, quality-of-service and flag values, and return the existing network
-status code domain. The agent owns the conversion from that JSON contract to its native transport.
-
-The typed `command_*` methods are the application-facing convenience layer. The five generic defaults
-currently implemented by `IPrinterAgent` construct the existing JSON dialect and route through the
-same message path:
-
-| Method | Default operation |
-| --- | --- |
-| `command_xyz_abs()` | Send `G90` for absolute positioning |
-| `command_auto_leveling()` | Send `G29` for bed leveling |
-| `command_go_home()` | Use the supported homing operation or send `G28` |
-| `command_set_bed()` | Use the supported bed control or send `M140` |
-| `command_set_nozzle()` | Send `M104` for nozzle temperature |
-
-These are compatibility defaults for common printer workflows, not a guarantee that every firmware
-implements every command identically. An agent can override a method when its protocol needs another
-operation. For example, a Klipper configuration may use `BED_MESH_CALIBRATE` instead of `G29`.
-
-The remaining common command methods default to `ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED` because their
-existing behavior is vendor-specific or has no portable implementation:
-
-- AMS RFID refresh;
-- AMS calibration;
-- AMS tray selection;
-- camera start;
-- axis control.
-
-The methods remain on the common interface so an agent that supports them can override them explicitly.
-`sequence_id` remains part of the command contract because `DeviceManager` creates and tracks it as
-the command ID.
-
-## Device ownership and stale responses
-
-Printer-agent ownership is represented by `printer_agent_id` on device records and `MachineObject`
-instances. The active agent ID is attached when a device is discovered, returned by a cloud list, or
-reused after a preset switch. Local-machine configuration also persists the agent ID so a saved LAN
-device is not silently reused by an unrelated agent.
-
-Cloud printer-list responses carry three pieces of request context added by `NetworkAgent`:
-
-```text
-provider   cloud provider used for the request
-agent_id   active printer agent when the request was made
-generation machine-list generation when the request was made
-```
-
-`DeviceManager` accepts the response only when those values still match the current provider, active
-agent, and generation. This prevents a slow response from the previous preset or provider from
-repopulating the current device list.
-
-The provider mapping is currently selected by `GUI_App`: the Bambu agent maps to the Bambu cloud
-provider and other agents map to the Orca cloud provider. The generation check protects that existing
-selection from races; it does not make cloud-provider ownership intrinsic to an agent. Cloud-printer
-ownership and the broader Orca cloud services are therefore still separate architectural concerns.
-
-## Python printer agents
-
-`PrinterAgentPluginCapability` implements `IPrinterAgent` directly. The live capability object is
-registered with `NetworkAgentFactory` and handed out as the printer agent when its agent ID is selected.
-The plugin receives the selected `ICloudServiceAgent` through `set_cloud_agent()` just like a built-in
-printer agent.
-
-Python plugins must implement the core communication and lifecycle methods required by the interface,
-including agent metadata, printer connection, discovery callbacks, and the two message-send methods.
-Methods that are meaningful only to a particular printer are optional overrides where the C++ base
-class provides a default.
-
-All ten `command_*` methods are available in the Python binding and in the trampoline. Their override
-status is intentionally optional:
-
-- the five generic commands use the C++ default when Python does not override them;
-- the five vendor-specific commands return `NOT_SUPPORTED` unless Python supplies an implementation;
-- a Python implementation can replace either behavior for its own protocol.
-
-The Python camera binding exposes HTTP, HTTPS, RTSP, and HTTP-snapshot modes. WebRTC remains a
-built-in C++ camera mode, but is not exposed as a Python mode because the current Python capability
-does not provide the corresponding cloud signaling-channel contract.
-
-## Camera playback boundary
-
-The camera stream mode describes how a stream is obtained; it does not by itself define ownership of
-the wxWidgets view that renders it. `MediaPlayCtrl` selects and tears down the active backend, while
-the wx parent owns the child window or renderer. This is important because a web view, native media
-control, and frame-based/WebRTC renderer have different wx window-lifetime requirements.
-
-Cloud URL and signaling requests are routed through `NetworkAgent` to the cloud provider selected for
-the device. Local URL requests are routed to the active printer agent. The distinction keeps cloud
-account services device-scoped while preserving the current one-LAN-agent/one-printer model.
-
-## Compatibility constraints
-
-The printer-agent boundary intentionally preserves several existing application contracts:
-
-- Bambu-shaped JSON is still the shared command representation;
-- existing network status codes are reused, with Orca-specific unsupported/capability errors added
-  in the Orca-reserved range;
-- `MachineObject` remains the shared device-state model;
-- preset and local-machine data retain compatibility with the existing agent-selection behavior;
-- Python plugins use the existing capability and pybind11 registration system.
-
-The agent abstraction is therefore responsible for containing vendor differences, not for pretending
-that all vendor protocols are identical. The planned Orca JSON dialect is the protocol-neutral command
-model for the `DeviceManager`/agent boundary. Once it is introduced, Bambu-specific translation remains
-inside the Bambu agent and the Orca agent's v1 sink adapter can be removed as a self-contained cleanup.
-
-## Main implementation locations
-
-- [`IPrinterAgent`](../../src/slic3r/Utils/IPrinterAgent.hpp) — printer-agent contract and generic command defaults
-- [`ICloudServiceAgent`](../../src/slic3r/Utils/ICloudServiceAgent.hpp) — cloud service and per-device
-  cloud camera contract
-- [`NetworkAgent`](../../src/slic3r/Utils/NetworkAgent.hpp) — façade and dispatch between active agents
-- [`NetworkAgentFactory`](../../src/slic3r/Utils/NetworkAgentFactory.hpp) — built-in and Python agent registry
-- [`DeviceManager`](../../src/slic3r/GUI/DeviceCore/DevManager.cpp) — device ownership, filtering, and
-  stale-response checks
-- [`PrinterAgentPluginCapability`](../../src/slic3r/plugin/pluginTypes/printerAgent/PrinterAgentPluginCapability.cpp)
-  — Python bindings
-- [`MediaPlayCtrl`](../../src/slic3r/GUI/MediaPlayCtrl.cpp) — camera backend selection and playback lifecycle

resources/profiles/OrcaFilamentLibrary.json

@@ -1,6 +1,6 @@
 {
 	"name": "OrcaFilamentLibrary",
-	"version": "02.04.00.17",
+	"version": "02.04.00.16",
 	"force_update": "0",
 	"description": "Orca Filament Library",
 	"filament_list": [

resources/profiles/OrcaFilamentLibrary/filament/Elegoo/Elegoo PLA @base.json

@@ -6,7 +6,7 @@
 	"filament_id": "OFvgE0Zh",
 	"instantiation": "false",
 	"fan_cooling_layer_time": [
-		"85"
+		"81"
 	],
 	"fan_min_speed": [
 		"50"

resources/web/dialog/PluginsDialog/index.js

@@ -575,7 +575,7 @@ function CapabilityCanRun(plugin, capability) {
 }
 
 function IsPluginChecked(plugin) {
-  return plugin.is_loaded;
+  return GetStatus(plugin) === "Activated";
 }
 
 function HasMixedCapabilityState(plugin) {
@@ -1347,8 +1347,6 @@ function StatusDescription(plugin) {
       return "This plugin is still loading.";
     case "Error":
       return "This plugin is blocked until its error is fixed.";
-    case "RuntimeError":
-      return "This plugin is loaded but a capability reported an error.";
     case "Inactive":
     default:
       return "This plugin is inactive. Activate it to install or load it.";

resources/web/dialog/PluginsDialog/styles.css

@@ -424,11 +424,6 @@ body.pane-resizing {
   font-weight: 600;
 }
 
-.status-cell.status-runtimeerror {
-  color: var(--plugin-status-warn);
-  font-weight: 600;
-}
-
 .status-cell.status-loading {
   color: var(--plugin-status-warn);
   font-weight: 600;
@@ -685,11 +680,6 @@ body.pane-resizing {
   color: var(--plugin-status-danger);
 }
 
-.detail-status-chip.status-runtimeerror {
-  background: var(--plugin-status-warn-bg);
-  color: var(--plugin-status-warn);
-}
-
 .detail-status-chip.status-loading {
   background: var(--plugin-status-warn-bg);
   color: var(--plugin-status-warn);

scripts/flatpak/com.orcaslicer.OrcaSlicer.yml

@@ -331,15 +331,6 @@ modules:
         sha256: deedcabe339165214a3637df4c86a507aef0d793cf8774ff68735f4737e8ddbc
         dest: external-packages/FFMPEG
 
-      # libdatachannel v0.24.5
-      # The Git checkout includes the submodules that are missing from the
-      # GitHub source archive. DataChannel.cmake consumes it as SOURCE_DIR.
-      - type: git
-        url: https://github.com/paullouisageneau/libdatachannel.git
-        tag: v0.24.5
-        commit: 443f6934d9007eb7076ab7825ba330f355fcbead
-        dest: external-packages/DataChannel
-
       # ---------------------------------------------------------------
       # Fallback archives for deps normally provided by the GNOME SDK.
       # These are only used if find_package() fails to locate them.

src/OrcaSlicer.cpp

@@ -1913,8 +1913,7 @@ int CLI::run(int argc, char **argv)
                         old_printable_width = static_cast<int>(old_printable_bbox.size().x());
                         old_printable_depth = static_cast<int>(old_printable_bbox.size().y());
                     }
-                    if (config.option<ConfigOptionFloat>("printable_height"))
-                        old_printable_height = (int)(config.opt_float("printable_height"));
+                    old_printable_height = (int)(config.opt_float("printable_height"));
 
                     if (config.option<ConfigOptionFloat>("extruder_clearance_height_to_rod"))
                         old_height_to_rod = config.opt_float("extruder_clearance_height_to_rod");
@@ -2117,14 +2116,9 @@ int CLI::run(int argc, char **argv)
 
     // One resolver for the whole run, so presets from the same vendor tree share its load.
     std::unique_ptr<PresetBundle> system_preset_resolver;
-    auto ensure_system_preset_resolver = [&system_preset_resolver]() -> PresetBundle & {
-        if (!system_preset_resolver)
-            system_preset_resolver = std::make_unique<PresetBundle>();
-        return *system_preset_resolver;
-    };
-    auto resolve_preset = [&ensure_cli_preset_bundle, &ensure_system_preset_resolver](const std::string &file, DynamicPrintConfig &config,
-                                                                                      std::string &config_type, const std::string &config_from,
-                                                                                      bool probe_type, std::string &error) {
+    auto resolve_preset = [&ensure_cli_preset_bundle, &system_preset_resolver](const std::string &file, DynamicPrintConfig &config,
+                                                                               std::string &config_type, const std::string &config_from,
+                                                                               bool probe_type, std::string &error) {
         const auto *inherits = config.option<ConfigOptionString>(BBL_JSON_KEY_INHERITS);
         if (!probe_type && (inherits == nullptr || inherits->value.empty()))
             return true;
@@ -2132,7 +2126,9 @@ int CLI::run(int argc, char **argv)
         PresetBundle                 *bundle = nullptr;
         bool                          allow_source_manifest = false;
         if (config_from == "system") {
-            bundle                = &ensure_system_preset_resolver();
+            if (!system_preset_resolver)
+                system_preset_resolver = std::make_unique<PresetBundle>();
+            bundle                = system_preset_resolver.get();
             allow_source_manifest = true;
         } else {
             bundle = ensure_cli_preset_bundle(error);
@@ -3124,44 +3120,6 @@ int CLI::run(int argc, char **argv)
         return 0;
     };
 
-    // Load the project's printer and process settings as the GUI loads its presets: over the default preset,
-    // with every key the project does not list as changed, including keys saved before an option existed,
-    // taken from its current system preset.
-    auto load_project_preset = [this, &ensure_system_preset_resolver, &current_different_settings, filament_count](const std::string &system_name, Preset::Type type) {
-        if (system_name.empty())
-            return;
-        // Preset bookkeeping the CLI keeps in its own groups, e.g. inherits_group and print_compatible_printers.
-        static const std::set<std::string> bookkeeping_keys = {"inherits", "compatible_printers", "compatible_prints", "compatible_printers_condition",
-                                                               "compatible_prints_condition", "print_settings_id", "printer_settings_id"};
-        const size_t       index = type == Preset::TYPE_PRINTER ? filament_count + 1 : 0;
-        PresetBundle      &resolver = ensure_system_preset_resolver();
-        DynamicPrintConfig system_config;
-        t_config_option_keys keys;
-        const DynamicPrintConfig config = Preset::load_external_config(type,
-            type == Preset::TYPE_PRINTER ? resolver.printers.default_preset_for(m_print_config).config : resolver.prints.default_preset().config,
-            m_print_config, PresetBundle::project_different_keys(index < current_different_settings.size() ? current_different_settings[index] : std::string()),
-            [&](const std::string &) -> DynamicPrintConfig * {
-                std::string error;
-                if (resolver.resolve_system_preset(system_config, type, system_name, config_substitution_rule, error))
-                    return &system_config;
-                BOOST_LOG_TRIVIAL(warning) << boost::format("CLI: system preset '%1%' not resolved (%2%); the project keeps its values") % system_name % error;
-                return nullptr;
-            }, &keys);
-        for (const std::string &key : keys) {
-            const ConfigOption *opt = config.option(key);
-            const ConfigOption *old = m_print_config.option(key);
-            if (bookkeeping_keys.count(key) != 0 || opt == nullptr || (old != nullptr && *old == *opt))
-                continue;
-            BOOST_LOG_TRIVIAL(info) << boost::format("CLI: %1% from '%2%': %3% -> %4%") % key % system_name % (old ? old->serialize() : std::string("(missing)")) % opt->serialize();
-            m_print_config.set_key_value(key, opt->clone());
-        }
-    };
-    // The --uptodate path refreshes the project from its own system configs.
-    if (new_printer_name.empty() && load_machine_config.empty())
-        load_project_preset(current_printer_system_name, Preset::TYPE_PRINTER);
-    if (new_process_name.empty() && load_process_config.empty())
-        load_project_preset(current_process_system_name, Preset::TYPE_PRINT);
-
     std::vector<std::string>& different_settings = m_print_config.option<ConfigOptionStrings>("different_settings_to_system", true)->values;
     std::vector<std::string>& inherits_group = m_print_config.option<ConfigOptionStrings>("inherits_group", true)->values;
     inherits_group.resize(filament_count + 2, std::string());

src/libslic3r/AppConfig.cpp

@@ -5,6 +5,7 @@
 //BBS
 #include "Preset.hpp"
 #include "Exception.hpp"
+#include "InstanceLock.hpp"
 #include "LocalesUtils.hpp"
 #include "Thread.hpp"
 #include "format.hpp"
@@ -743,10 +744,13 @@ static bool verify_config_file_checksum(boost::nowide::ifstream &ifs)
 
 
 #ifdef USE_JSON_CONFIG
-std::string AppConfig::load()
+std::string AppConfig::load(bool read_only)
 {
     json j;
 
+    // Keep another instance from replacing or restoring the file mid-read.
+    InstanceLock instance_lock(read_only ? std::string() : lock_path());
+
     // 1) Read the complete config file into a boost::property_tree.
     namespace pt = boost::property_tree;
     pt::ptree tree;
@@ -996,7 +1000,6 @@ void AppConfig::save()
     // The config is first written to a file with a PID suffix and then moved
     // to avoid race conditions with multiple instances of Slic3r
     const auto path = config_path();
-    std::string path_pid = (boost::format("%1%.%2%") % path % get_current_pid()).str();
 
     json j;
 
@@ -1126,43 +1129,18 @@ void AppConfig::save()
 
         j["local_machines"][local_machine.first] = m_json;
     }
-    boost::nowide::ofstream c;
-    c.open(path_pid, std::ios::out | std::ios::trunc);
-    c << j.dump(1, '\t') << std::endl;
-
-#ifdef WIN32
-    // WIN32 specific: The final "rename_file()" call is not safe in case of an application crash, there is no atomic "rename file" API
-    // provided by Windows (sic!). Therefore we save a MD5 checksum to be able to verify file corruption. In addition,
-    // we save the config file into a backup first before moving it to the final destination.
-    c << appconfig_md5_hash_line(j.dump(1, '\t'));
-#endif
-
-    c.close();
-    if (c.fail()) {
-      BOOST_LOG_TRIVIAL(error) << "Failed to write new configuration to " << path_pid << "; aborting attempt to overwrite original configuration";
-      return;
-    }
-
-#ifdef WIN32
-    // Make a backup of the configuration file before copying it to the final destination.
-    std::string error_message;
-    std::string backup_path = (boost::format("%1%.bak") % path).str();
-    // Copy configuration file with PID suffix into the configuration file with "bak" suffix.
-    if (copy_file(path_pid, backup_path, error_message, false) != SUCCESS)
-        BOOST_LOG_TRIVIAL(error) << "Copying from " << path_pid << " to " << backup_path << " failed. Failed to create a backup configuration.";
-#endif
-
-    // Rename the config atomically.
-    // On Windows, the rename is likely NOT atomic, thus it may fail if PrusaSlicer crashes on another thread in the meanwhile.
-    // To cope with that, we already made a backup of the config on Windows.
-    rename_file(path_pid, path);
-    m_dirty = false;
+    const std::string config_str = j.dump(1, '\t');
+    if (write_config_file(path, config_str + "\n", config_str))
+        m_dirty = false;
 }
 
 #else
 
-std::string AppConfig::load()
+std::string AppConfig::load(bool read_only)
 {
+    // Keep another instance from replacing or restoring the file mid-read.
+    InstanceLock instance_lock(read_only ? std::string() : lock_path());
+
     // 1) Read the complete config file into a boost::property_tree.
     namespace pt = boost::property_tree;
     pt::ptree tree;
@@ -1300,7 +1278,6 @@ void AppConfig::save()
     // The config is first written to a file with a PID suffix and then moved
     // to avoid race conditions with multiple instances of Slic3r
     const auto path = config_path();
-    std::string path_pid = (boost::format("%1%.%2%") % path % get_current_pid()).str();
 
     std::stringstream config_ss;
     if (m_mode == EAppMode::Editor)
@@ -1336,39 +1313,39 @@ void AppConfig::save()
     // One empty line before the MD5 sum.
     config_ss << std::endl;
 
-    std::string config_str = config_ss.str();
-    boost::nowide::ofstream c;
-    c.open(path_pid, std::ios::out | std::ios::trunc);
-    c << config_str;
-#ifdef WIN32
-    // WIN32 specific: The final "rename_file()" call is not safe in case of an application crash, there is no atomic "rename file" API
-    // provided by Windows (sic!). Therefore we save a MD5 checksum to be able to verify file corruption. In addition,
-    // we save the config file into a backup first before moving it to the final destination.
-    c << appconfig_md5_hash_line(config_str);
-#endif
-    c.close();
-    if (c.fail()) {
-      BOOST_LOG_TRIVIAL(error) << "Failed to write new configuration to " << path_pid << "; aborting attempt to overwrite original configuration";
-      return;
-    }
-
-#ifdef WIN32
-    // Make a backup of the configuration file before copying it to the final destination.
-    std::string error_message;
-    std::string backup_path = (boost::format("%1%.bak") % path).str();
-    // Copy configuration file with PID suffix into the configuration file with "bak" suffix.
-    if (copy_file(path_pid, backup_path, error_message, false) != SUCCESS)
-        BOOST_LOG_TRIVIAL(error) << "Copying from " << path_pid << " to " << backup_path << " failed. Failed to create a backup configuration.";
-#endif
-
-    // Rename the config atomically.
-    // On Windows, the rename is likely NOT atomic, thus it may fail if PrusaSlicer crashes on another thread in the meanwhile.
-    // To cope with that, we already made a backup of the config on Windows.
-    rename_file(path_pid, path);
-    m_dirty = false;
+    const std::string config_str = config_ss.str();
+    if (write_config_file(path, config_str, config_str))
+        m_dirty = false;
 }
 #endif
 
+bool AppConfig::write_config_file(const std::string &path, std::string body, const std::string &checksum_source)
+{
+    // Everything before this is assembly; only the writes need the other instances kept out.
+    InstanceLock instance_lock(lock_path());
+#ifdef WIN32
+    // WIN32 specific: the final replace is not safe in case of an application crash, there is no atomic "rename file" API
+    // provided by Windows (sic!). Therefore we save a MD5 checksum to be able to verify file corruption. In addition,
+    // we save the config file into a backup first before moving it to the final destination.
+    body += appconfig_md5_hash_line(checksum_source);
+#endif
+    // Not flushed to the device: the idle handler saves on the GUI thread after
+    // any change, and the rename already gives a complete old or new file.
+    if (const std::error_code ec = write_file_atomically(path, body)) {
+        BOOST_LOG_TRIVIAL(error) << "Failed to write the configuration " << path << ": " << ec.message() << "; trying again in 10 s";
+        m_retry_save_at = std::chrono::steady_clock::now() + std::chrono::seconds(10);
+        return false;
+    }
+    m_retry_save_at = {};
+#ifdef WIN32
+    // Written after the config, so the backup never holds a state that was not confirmed written.
+    const std::string backup_path = (boost::format("%1%.bak") % path).str();
+    if (const std::error_code ec = write_file_atomically(backup_path, body))
+        BOOST_LOG_TRIVIAL(error) << "Failed to write the backup configuration " << backup_path << ": " << ec.message();
+#endif
+    return true;
+}
+
 bool AppConfig::get_variant(const std::string &vendor, const std::string &model, const std::string &variant) const
 {
     const auto it_v = m_vendors.find(vendor);
@@ -1857,6 +1834,11 @@ void AppConfig::reset_selections()
     }
 }
 
+std::string AppConfig::lock_path()
+{
+    return Slic3r::data_dir().empty() ? std::string() : config_path() + ".lock";
+}
+
 std::string AppConfig::config_path()
 {
 #ifdef USE_JSON_CONFIG
@@ -1893,7 +1875,7 @@ bool AppConfig::exists()
 
 std::string AppConfig::load_if_exists()
 {
-    return boost::filesystem::exists(loading_path()) ? load() : std::string();
+    return boost::filesystem::exists(loading_path()) ? load(/*read_only=*/true) : std::string();
 }
 
 }; // namespace Slic3r

src/libslic3r/AppConfig.hpp

@@ -2,6 +2,7 @@
 #define slic3r_AppConfig_hpp_
 
 #include <set>
+#include <chrono>
 #include <map>
 #include <string>
 #include "nlohmann/json.hpp"
@@ -122,14 +123,18 @@ public:
 
 	// Load the slic3r.ini from a user profile directory (or a datadir, if configured).
 	// Return an error string, or an empty string on success.
-	std::string         load();
+	std::string         load(bool read_only = false);
 	// Treat a missing config as default state; otherwise load it normally.
+	// The CLI's load: it never saves, so it takes no lock and creates no lock file.
 	std::string         load_if_exists();
 	// Store the slic3r.ini into a user profile directory (or a datadir, if configured).
 	void 			   	save();
 
 	// Does this config need to be saved?
 	bool 				dirty() const { return m_dirty; }
+	// False for ten seconds after a failed write, so the idle handler does not
+	// repeat a hopeless attempt on every event; an explicit save() always tries.
+	bool 				save_due() const { return std::chrono::steady_clock::now() >= m_retry_save_at; }
 
 
 	void				set_dirty() { m_dirty = true; }
@@ -339,6 +344,8 @@ public:
 
 	// Get the default config path from Slic3r::data_dir().
 	std::string			config_path();
+	// Lock file guarding config_path() against other running instances; empty without a data dir.
+	std::string			lock_path();
 
 	// Returns true if the user's data directory comes from before Slic3r 1.40.0 (no updating)
 	bool 				legacy_datadir() const { return m_legacy_datadir; }
@@ -449,8 +456,16 @@ private:
 
 	// Preset for each machine
 	MachineSettingMap											m_printer_settings;
+	// Writes the assembled config text, and on Windows its checksum and a backup copy; false when the
+	// config itself could not be written, in which case the caller stays dirty and retries. `checksum_source`
+	// is the text load() will verify, which for the JSON config ends before the trailing newline.
+	bool												write_config_file(const std::string &path, std::string body, const std::string &checksum_source);
+
 	// Has any value been modified since the config.ini has been last saved or loaded?
 	bool														m_dirty;
+	// After a failed write, save_due() is false for the next ten seconds, so the
+	// idle handler does not repeat a hopeless write on every event.
+	std::chrono::steady_clock::time_point						m_retry_save_at{};
 	// Original version found in the ini file before it was overwritten
 	Semver                                                      m_orig_version;
 	// Whether the existing version is before system profiles & configuration updating

src/libslic3r/CMakeLists.txt

@@ -306,6 +306,8 @@ set(lisbslic3r_sources
     Geometry/VoronoiUtils.cpp
     Geometry/VoronoiUtils.hpp
     Geometry/VoronoiVisualUtils.hpp
+    InstanceLock.cpp
+    InstanceLock.hpp
     Int128.hpp
     KDTreeIndirect.hpp
     Layer.cpp

src/libslic3r/Config.cpp

@@ -1538,12 +1538,10 @@ void ConfigBase::save_to_json(const std::string &file, const std::string &name,
     // Serialize first: if that throws (invalid UTF-8), the existing file stays untouched.
     std::ostringstream ss;
     this->save_to_json(ss, name, from, version);
-    boost::nowide::ofstream c;
-    c.open(file, std::ios::out | std::ios::trunc);
-    c << ss.str();
-    c.close();
-
-    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%file;
+    if (const std::error_code ec = write_file_atomically(file, ss.str()))
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": failed to save config to %1%: %2%") % file % ec.message();
+    else
+        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%file;
 }
 
 void ConfigBase::save_to_json(std::ostream &os, const std::string &name, const std::string &from, const std::string &version, bool replace_invalid_utf8) const

src/libslic3r/Fill/FillGyroid.cpp

@@ -5,7 +5,6 @@
 #include <cmath>
 #include <algorithm>
 #include <iostream>
-#include <limits>
 #include "FillBase.hpp"
 #include "FillGyroid.hpp"
 
@@ -124,41 +123,44 @@ static inline double f(double x, double z_sin, double z_cos, bool vertical, bool
     }
 }
 
-// Repeats one period of a wave from the last sample at or before x_min to the first one at or after x_max.
 static inline Polyline make_wave(
-    const std::vector<Vec2d>& one_period, double x_min, double x_max, double offset, double scaleFactor, bool vertical)
+    const std::vector<Vec2d>& one_period, double width, double height, double offset, double scaleFactor,
+    double z_cos, double z_sin, bool vertical, bool flip)
 {
-    const double period = one_period.back().x();
-    // The last sample of a period is the first one of the next.
-    const size_t n  = one_period.size() - 1;
-    double       x0 = std::floor(x_min / period) * period;
-    size_t       i  = 0;
-    while (i + 1 < n && x0 + one_period[i + 1].x() <= x_min)
-        ++i;
+    std::vector<Vec2d> points = one_period;
+    double period = points.back()(0);
+    if (width != period) // do not extend if already truncated
+    {
+        points.reserve(one_period.size() * size_t(floor(width / period)));
+        points.pop_back();
 
+        size_t n = points.size();
+        do {
+            points.emplace_back(points[points.size()-n].x() + period, points[points.size()-n].y());
+        } while (points.back()(0) < width - EPSILON);
+
+        points.emplace_back(Vec2d(width, f(width, z_sin, z_cos, vertical, flip)));
+    }
+
+    // and construct the final polyline to return:
     Polyline polyline;
-    polyline.points.reserve(size_t((x_max - x0) / period + 1.) * n + 1);
-    for (;;) {
-        Vec2d      point(x0 + one_period[i].x(), one_period[i].y() + offset);
-        const bool last = point.x() >= x_max;
+    polyline.points.reserve(points.size());
+    for (auto& point : points) {
+        point(1) += offset;
+        point(1) = std::clamp(double(point.y()), 0., height);
         if (vertical)
             std::swap(point(0), point(1));
         polyline.points.emplace_back((point * scaleFactor).cast<coord_t>());
-        if (last)
-            break;
-        if (++i == n) {
-            i = 0;
-            x0 += period;
-        }
     }
+
     return polyline;
 }
 
-static std::vector<Vec2d> make_one_period(double scaleFactor, double z_cos, double z_sin, bool vertical, bool flip, double tolerance)
+static std::vector<Vec2d> make_one_period(double width, double scaleFactor, double z_cos, double z_sin, bool vertical, bool flip, double tolerance)
 {
     std::vector<Vec2d> points;
     double dx = M_PI_2; // exact coordinates on main inflexion lobes
-    double limit = 2*M_PI;
+    double limit = std::min(2*M_PI, width);
     points.reserve(coord_t(ceil(limit / tolerance / 3)));
 
     for (double x = 0.; x < limit - EPSILON; x += dx) {
@@ -237,8 +239,7 @@ static inline double compute_omega_factor(double density_adjusted, double line_s
     return std::clamp(raw, 1.0, 2.0);
 }
 
-// Waves covering bbox, with the pattern anchored at origin.
-static Polylines make_gyroid_waves(double gridZ, double density_adjusted, double line_spacing, const BoundingBox &bbox, const Point &origin)
+static Polylines make_gyroid_waves(double gridZ, double density_adjusted, double line_spacing, double width, double height)
 {
     const double scaleFactor = scale_(line_spacing) / density_adjusted;
 
@@ -253,36 +254,29 @@ static Polylines make_gyroid_waves(double gridZ, double density_adjusted, double
     const double z_cos = cos(z);
 
     bool vertical = (std::abs(z_sin) <= std::abs(z_cos));
-    // Range to cover in pattern units, with the waves running along x.
-    Vec2d lo = (bbox.min - origin).cast<double>() / scaleFactor;
-    Vec2d hi = (bbox.max - origin).cast<double>() / scaleFactor;
     double lower_bound = 0.;
+    double upper_bound = height;
     bool flip = true;
     if (vertical) {
         flip = false;
         lower_bound = -M_PI;
-        std::swap(lo(0), lo(1));
-        std::swap(hi(0), hi(1));
+        upper_bound = width - M_PI_2;
+        std::swap(width,height);
     }
 
-    std::vector<Vec2d> one_period_odd = make_one_period(scaleFactor, z_cos, z_sin, vertical, flip, tolerance); // creates one period of the waves, so it doesn't have to be recalculated all the time
+    std::vector<Vec2d> one_period_odd = make_one_period(width, scaleFactor, z_cos, z_sin, vertical, flip, tolerance); // creates one period of the waves, so it doesn't have to be recalculated all the time
     flip = !flip;                                                                   // even polylines are a bit shifted
-    std::vector<Vec2d> one_period_even = make_one_period(scaleFactor, z_cos, z_sin, vertical, flip, tolerance);
-
-    // Every wave spans [offset + f_min, offset + f_max] across.
-    double f_min = std::numeric_limits<double>::max();
-    double f_max = std::numeric_limits<double>::lowest();
-    for (const std::vector<Vec2d> *one_period : { &one_period_odd, &one_period_even })
-        for (const Vec2d &point : *one_period) {
-            f_min = std::min(f_min, point.y());
-            f_max = std::max(f_max, point.y());
-        }
-
+    std::vector<Vec2d> one_period_even = make_one_period(width, scaleFactor, z_cos, z_sin, vertical, flip, tolerance);
     Polylines result;
-    for (int i = int(std::ceil((lo.y() - f_max - lower_bound) / M_PI)); lower_bound + i * M_PI + f_min <= hi.y(); ++i) {
-        Polyline &wave = result.emplace_back(make_wave(i % 2 == 0 ? one_period_odd : one_period_even, lo.x(), hi.x(),
-                                                       lower_bound + i * M_PI, scaleFactor, vertical));
-        wave.translate(origin);
+
+    for (double y0 = lower_bound; y0 < upper_bound + EPSILON; y0 += M_PI) {
+        // creates odd polylines
+        result.emplace_back(make_wave(one_period_odd, width, height, y0, scaleFactor, z_cos, z_sin, vertical, flip));
+        // creates even polylines
+        y0 += M_PI;
+        if (y0 < upper_bound + EPSILON) {
+            result.emplace_back(make_wave(one_period_even, width, height, y0, scaleFactor, z_cos, z_sin, vertical, flip));
+        }
     }
 
     return result;
@@ -308,12 +302,12 @@ void FillGyroid::_fill_surface_single(
     // Distance between the gyroid waves in scaled coordinates.
     coord_t     distance = coord_t(scale_(this->spacing) / density_adjusted);
 
-    // Anchor the pattern to our grid module; the 10-line shift keeps its established phase.
-    const coord_t shift  = coord_t(10 * scale_(this->spacing));
-    const Point   origin = align_to_grid(bb.min, Point(2*M_PI*distance, 2*M_PI*distance)) - Point(shift, shift);
+    // align bounding box to a multiple of our grid module
+    bb.merge(align_to_grid(bb.min, Point(2*M_PI*distance, 2*M_PI*distance)));
 
-    // Keep the pattern ends and the multiline copies outside the contour.
-    bb.offset(scale_(this->spacing * params.multiline));
+    // Expand the bounding box to avoid artifacts at the edges
+    coord_t expand = 10 * (scale_(this->spacing));
+    bb.offset(expand); 
 
     // generate pattern
     Polylines polylines;
@@ -333,14 +327,23 @@ void FillGyroid::_fill_surface_single(
         const float density_factor = std::max(0.001f, float(params.density * DensityAdjust / params.multiline));
         const float period         = float(2.0 * M_PI) * float(this->spacing) / density_factor;
 
-        // A cell of margin for the rings closed along the raster border, and a fixed sampling grid for every region.
-        const coord_t cell = scaled(marchsq::GyroidField::gsizef);
-        bb.offset(cell);
-        bb.merge(align_to_grid(bb.min, Point(cell, cell)));
+        // bb is already expanded above by 10 * scale_(spacing) for edge artifacts;
+        // skip a second offset here to avoid raster-area bloat in the marching squares pass.
         marchsq::GyroidField sf(bb, this->z, period, float(omega));
         polylines = marchsq::get_gyroid_polylines(sf, SCALED_SPARSE_INFILL_RESOLUTION);
     } else {
-        polylines = make_gyroid_waves(scale_(this->z), density_adjusted, this->spacing, bb, origin);
+        polylines = make_gyroid_waves(
+            scale_(this->z),
+            density_adjusted,
+            this->spacing,
+            ceil(bb.size()(0) / distance) + 1.,
+            ceil(bb.size()(1) / distance) + 1.);
+
+        // The parametric generator produces wave coords relative to the grid origin;
+        // shift them into absolute layer coords. The marching-squares branch above
+        // already emits absolute coords via GyroidField::to_Point, so it skips this.
+        for (Polyline &pl : polylines)
+            pl.translate(bb.min);
     }
 
     // Apply multiline offset if needed

src/libslic3r/InstanceLock.cpp

@@ -0,0 +1,165 @@
+#include "InstanceLock.hpp"
+
+#include <map>
+#include <memory>
+#include <system_error>
+#include <thread>
+
+#include <boost/filesystem.hpp>
+#include <boost/log/trivial.hpp>
+#include <boost/nowide/fstream.hpp>
+#ifdef _WIN32
+#include <boost/interprocess/sync/file_lock.hpp>
+#include <boost/nowide/convert.hpp>
+#else
+#include <cerrno>
+#include <fcntl.h>
+#include <sys/file.h>
+#include <unistd.h>
+#endif
+
+namespace Slic3r {
+
+#ifdef _WIN32
+// LockFileEx, held by this handle alone.
+using NativeFileLock = boost::interprocess::file_lock;
+#else
+// flock(2) rather than an fcntl lock: it belongs to this open file description,
+// so any other code in the process that opens and closes the lock file, as a
+// backup or an export walking the data dir might, cannot drop it. An fcntl
+// lock would go with the first such close.
+class NativeFileLock
+{
+public:
+    explicit NativeFileLock(const char *path) : m_fd(::open(path, O_RDWR | O_CREAT | O_CLOEXEC, 0644))
+    {
+        if (m_fd < 0)
+            throw std::system_error(errno, std::generic_category(), path);
+    }
+    ~NativeFileLock() { ::close(m_fd); }
+    bool try_lock()
+    {
+        if (::flock(m_fd, LOCK_EX | LOCK_NB) == 0)
+            return true;
+        // A signal (a child exiting, for one) interrupts the call like any other; the caller polls again.
+        if (errno == EWOULDBLOCK || errno == EINTR)
+            return false;
+        throw std::system_error(errno, std::generic_category(), "flock");
+    }
+    void unlock() { ::flock(m_fd, LOCK_UN); }
+private:
+    int m_fd;
+};
+#endif
+
+// One slot per lock file, shared by every guard in the process: one lock
+// object per path behind a mutex is what makes the guard re-entrant and safe
+// to use from the preset sync thread and the GUI thread at once. The lock
+// file is opened by the outermost guard and closed when it goes, so the file
+// is never held open between guards: whatever is at the path is what gets
+// locked, and a data dir can be removed once nothing is saving into it. The
+// file is kept rather than deleted on release because the lock state lives in
+// the kernel on the open file, and deleting it would let a third instance
+// lock a fresh file while the second still holds the old one.
+struct InstanceLock::Slot
+{
+    std::recursive_mutex mutex;
+    // Non-null exactly while this process holds the file lock.
+    std::unique_ptr<NativeFileLock> file_lock;
+    int  depth{0};
+    // Until this point, after a guard could not open, lock or wait out the
+    // file, guards do not touch it.
+    std::chrono::steady_clock::time_point cooldown_until{};
+};
+
+InstanceLock::Slot &InstanceLock::slot_for(const std::string &lock_file_path)
+{
+    // Never freed: a save during static destruction still needs its slot.
+    static auto *registry_mutex = new std::mutex();
+    static auto *registry       = new std::map<std::string, std::unique_ptr<Slot>>();
+
+    std::lock_guard<std::mutex> guard(*registry_mutex);
+    std::unique_ptr<Slot> &slot = (*registry)[lock_file_path];
+    if (! slot)
+        slot = std::make_unique<Slot>();
+    return *slot;
+}
+
+// Starts the cool-down. Called with the slot mutex held.
+void InstanceLock::defer(Slot &slot, const std::string &reason)
+{
+    slot.cooldown_until = std::chrono::steady_clock::now() + cooldown;
+    BOOST_LOG_TRIVIAL(warning) << reason << "; proceeding without the lock for the next " << cooldown.count() << " ms";
+}
+
+// Creates the lock file if needed and opens it, or starts the cool-down.
+// Called with the slot mutex held.
+bool InstanceLock::open_lock_file(Slot &slot, const std::string &lock_file_path)
+{
+    try {
+#ifdef _WIN32
+        // The lock opens an existing file; created once, on the first miss.
+        const std::wstring wide_path = boost::nowide::widen(lock_file_path);
+        try {
+            slot.file_lock = std::make_unique<NativeFileLock>(wide_path.c_str());
+        } catch (const std::exception &) {
+            boost::nowide::ofstream(lock_file_path, std::ios::app).close();
+            slot.file_lock = std::make_unique<NativeFileLock>(wide_path.c_str());
+        }
+#else
+        slot.file_lock = std::make_unique<NativeFileLock>(lock_file_path.c_str());
+#endif
+        return true;
+    } catch (const std::exception &e) {
+        defer(slot, "Cannot open lock file " + lock_file_path + ": " + e.what() + " (check its owner and permissions)");
+        return false;
+    }
+}
+
+InstanceLock::InstanceLock(const std::string &lock_file_path, std::chrono::milliseconds timeout)
+{
+    if (lock_file_path.empty())
+        return;
+    m_slot       = &slot_for(lock_file_path);
+    m_slot_guard = std::unique_lock<std::recursive_mutex>(m_slot->mutex);
+    const auto now = std::chrono::steady_clock::now();
+    if (m_slot->depth == 0 && now >= m_slot->cooldown_until && open_lock_file(*m_slot, lock_file_path)) {
+        const auto deadline = now + timeout;
+        bool       taken    = false;
+        for (;;) {
+            try {
+                if ((taken = m_slot->file_lock->try_lock()))
+                    break;
+            } catch (const std::exception &e) {
+                defer(*m_slot, "Cannot lock " + lock_file_path + ": " + e.what());
+                break;
+            }
+            if (std::chrono::steady_clock::now() >= deadline) {
+                defer(*m_slot, "Another instance has held " + lock_file_path + " for over " + std::to_string(timeout.count()) + " ms");
+                break;
+            }
+            std::this_thread::sleep_for(std::chrono::milliseconds(5));
+        }
+        if (! taken)
+            m_slot->file_lock.reset();
+    }
+    // Counted last, so a throw above leaves the slot exactly as it was found.
+    ++ m_slot->depth;
+    m_locked = m_slot->file_lock != nullptr;
+}
+
+InstanceLock::~InstanceLock()
+{
+    if (m_slot == nullptr)
+        return;
+    if (-- m_slot->depth == 0 && m_slot->file_lock) {
+        try {
+            m_slot->file_lock->unlock();
+        } catch (const std::exception &e) {
+            BOOST_LOG_TRIVIAL(warning) << "Cannot unlock instance lock: " << e.what();
+        }
+        m_slot->file_lock.reset();
+    }
+}
+
+} // namespace Slic3r

src/libslic3r/InstanceLock.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <chrono>
+#include <mutex>
+#include <string>
+
+namespace Slic3r {
+
+// Scoped write lock on a file shared by every running instance of the
+// application, such as the app config or the user preset directory: threads
+// of this process are serialised through a recursive mutex, other processes
+// through an advisory OS file lock on `lock_file_path`. The lock file is
+// created on first use and kept; the OS releases the lock when its holder
+// exits, so a crashed instance never leaves a stale lock behind.
+//
+// Best effort: when the lock file cannot be opened or locked, or another
+// instance still holds it after `timeout`, the guard keeps only the in-process
+// mutex, locked() reports false and the write proceeds, since a hung instance
+// must never block another one from saving. For `cooldown` afterwards guards
+// leave the file alone. The wait for the in-process mutex is bounded only by
+// the longest critical section, so a guard covers a few file operations and
+// nothing slower.
+//
+// Lock order: the preset collection mutex may be held when a guard is taken
+// (set_sync_info_and_save() calls save_info() under it), never the reverse;
+// that is why the guards sit at the leaf readers and writers and why a guard
+// must not be added around save_user_presets(), which takes the collection
+// mutex through delete_preset().
+class InstanceLock
+{
+public:
+    // Long against a critical section of milliseconds, short against the GUI
+    // thread, which is where most guards are taken.
+    static constexpr std::chrono::milliseconds default_timeout{1000};
+    // Long enough that a holder stuck in a debugger does not cost a stall per
+    // save; mutable so tests can shorten it.
+    static inline std::chrono::milliseconds cooldown{10000};
+
+    // An empty path makes the guard a no-op.
+    explicit InstanceLock(const std::string &lock_file_path, std::chrono::milliseconds timeout = default_timeout);
+    ~InstanceLock();
+
+    InstanceLock(const InstanceLock &) = delete;
+    InstanceLock &operator=(const InstanceLock &) = delete;
+
+    // True while this process holds the cross-process file lock.
+    bool locked() const { return m_locked; }
+
+private:
+    struct Slot;
+    static Slot &slot_for(const std::string &lock_file_path);
+    static bool  open_lock_file(Slot &slot, const std::string &lock_file_path);
+    static void  defer(Slot &slot, const std::string &reason);
+
+    Slot *m_slot{nullptr};
+    std::unique_lock<std::recursive_mutex> m_slot_guard;
+    bool  m_locked{false};
+};
+
+} // namespace Slic3r

src/libslic3r/Preset.cpp

@@ -51,6 +51,9 @@
 #include "libslic3r.h"
 #include "LifecycleEvents.hpp"
 #include "Utils.hpp"
+#include "InstanceLock.hpp"
+
+#include <sstream>
 #include "Time.hpp"
 #include "PlaceholderParser.hpp"
 #include "libslic3r/GCode/Thumbnails.hpp"
@@ -107,6 +110,32 @@ std::string get_preset_canonical_name(const std::string &preset_bare_name, const
     }
 }
 
+std::string user_presets_lock_path(bool read_only)
+{
+    return read_only || data_dir().empty() ? std::string() : (fs::path(data_dir()) / (PRESET_USER_DIR ".lock")).string();
+}
+
+// Removes a preset file the scan could not load, and its .info, under the lock.
+// The scan passes read_only when it could not take the lock, since the file may
+// then be another instance's fresh write that it merely raced.
+static void remove_preset_files(const std::string &preset_file, bool read_only)
+{
+    if (read_only)
+        return;
+    InstanceLock instance_lock(user_presets_lock_path());
+    // A symlink whose target is missing stays, since the target may come back; one
+    // that cannot even be followed is removed like any other unreadable file.
+    auto remove = [](const fs::path &file) {
+        boost::system::error_code ec;
+        if (fs::status(file, ec).type() != fs::file_not_found)
+            fs::remove(file, ec);
+    };
+    fs::path file_path(preset_file);
+    remove(file_path);
+    file_path.replace_extension(".info");
+    remove(file_path);
+}
+
 std::string get_preset_bare_name(const std::string &canonical_name)
 {
     const auto pos = canonical_name.find_last_of('/');
@@ -649,18 +678,20 @@ void Preset::save_info(std::string file)
         file = idx_file.string();
     }
 
-    boost::nowide::ofstream c;
-    c.open(file, std::ios::out | std::ios::trunc);
     std::string sync_info_to_save;
     //BBS: hold is used for stop requesting to server this time
     if (this->sync_info.compare("hold") != 0)
         sync_info_to_save = this->sync_info;
+    std::ostringstream c;
     c << "sync_info" << " = " << sync_info_to_save << std::endl;
     c << "user_id" << " = " << this->user_id << std::endl;
     c << "setting_id" << " = " << this->setting_id << std::endl;
     c << "base_id" << " = " << this->base_id << std::endl;
     c << "updated_time" << " = " << std::to_string(this->updated_time) << std::endl;
-    c.close();
+
+    InstanceLock instance_lock(user_presets_lock_path());
+    if (const std::error_code ec = write_file_atomically(file, c.str()))
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to save " << file << ": " << ec.message();
 }
 
 void Preset::remove_files(bool cloud_already_deleted)
@@ -669,6 +700,7 @@ void Preset::remove_files(bool cloud_already_deleted)
     if (this->is_project_embedded) {
         return;
     }
+    InstanceLock instance_lock(user_presets_lock_path());
     // Erase the preset file.
     boost::nowide::remove(this->file.c_str());
     fs::path idx_path(this->file);
@@ -686,11 +718,11 @@ void Preset::remove_files(bool cloud_already_deleted)
 }
 
 //BBS: add logic for only difference save
-void Preset::save(DynamicPrintConfig* parent_config)
+bool Preset::save(DynamicPrintConfig* parent_config)
 {
     //BBS: add project embedded preset logic
     if (this->is_project_embedded)
-        return;
+        return true;
     //BBS: change to json format
     //this->config.save(this->file);
     std::string from_str;
@@ -705,12 +737,16 @@ void Preset::save(DynamicPrintConfig* parent_config)
     else
         from_str = std::string("Default");
 
-    boost::filesystem::create_directories(fs::path(this->file).parent_path());
     const std::string bare_name = get_preset_bare_name(this->name);
 
+    // What gets written: the diff against the parent, the config plus its
+    // filament id, or the config as is. Built before the lock is taken so the
+    // exclusive window covers only the file writes.
+    DynamicPrintConfig        temp_config;
+    const DynamicPrintConfig *to_save = &this->config;
+
     //BBS: only save difference if it has parent
     if (parent_config) {
-        DynamicPrintConfig temp_config;
         std::vector<std::string> dirty_options = config.diff(*parent_config);
 
         std::string extruder_id_name, extruder_variant_name;
@@ -746,13 +782,22 @@ void Preset::save(DynamicPrintConfig* parent_config)
                     opt_dst->set(opt_src);
             }
         }
-        temp_config.save_to_json(this->file, bare_name, from_str, this->version.to_string());
+        to_save = &temp_config;
     } else if (!filament_id.empty() && inherits().empty()) {
-        DynamicPrintConfig temp_config = config;
+        temp_config = config;
         temp_config.set_key_value(BBL_JSON_KEY_FILAMENT_ID, new ConfigOptionString(filament_id));
-        temp_config.save_to_json(this->file, bare_name, from_str, this->version.to_string());
-    } else {
-        this->config.save_to_json(this->file, bare_name, from_str, this->version.to_string());
+        to_save = &temp_config;
+    }
+
+    std::ostringstream json;
+    to_save->save_to_json(json, bare_name, from_str, this->version.to_string());
+
+    InstanceLock instance_lock(user_presets_lock_path());
+    boost::filesystem::create_directories(fs::path(this->file).parent_path());
+    if (const std::error_code ec = write_file_atomically(this->file, json.str())) {
+        // No .info either: one without its preset reads as a cloud deletion request.
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to save " << this->file << ": " << ec.message();
+        return false;
     }
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " save config for: " << this->name << " and filament_id: " << filament_id << " and base_id: " << this->base_id;
 
@@ -762,6 +807,7 @@ void Preset::save(DynamicPrintConfig* parent_config)
         idx_file.replace_extension(".info");
         this->save_info(idx_file.string());
     }
+    return true;
 }
 
 void Preset::reload(Preset const &parent)
@@ -773,6 +819,7 @@ void Preset::reload(Preset const &parent)
     std::string                        reason;
     ForwardCompatibilitySubstitutionRule substitution_rule    = ForwardCompatibilitySubstitutionRule::Disable;
     try {
+        InstanceLock instance_lock(user_presets_lock_path());
         ConfigSubstitutions                config_substitutions = config.load_from_json(file, substitution_rule, key_values, reason);
         this->config = parent.config;
         this->config.apply(std::move(config));
@@ -976,37 +1023,6 @@ void Preset::get_extruder_names_and_keysets(Type type, std::string& extruder_id_
     }
 }
 
-DynamicPrintConfig Preset::load_external_config(Type type, const DynamicPrintConfig &default_config, const DynamicPrintConfig &project_config,
-                                                const std::set<std::string> &different_settings_list,
-                                                const std::function<DynamicPrintConfig *(const std::string &inherits)> &find_base,
-                                                t_config_option_keys *keys)
-{
-    // Load the preset over a default preset, so that the missing fields are filled in from the default preset.
-    DynamicPrintConfig cfg(default_config);
-    // SoftFever: ignore print connection info from project
-    auto        cfg_keys = cfg.keys();
-    cfg_keys.erase(std::remove_if(cfg_keys.begin(), cfg_keys.end(),
-                              [](std::string &val) {
-                                return val == "print_host" || val == "print_host_webui" || val == "printhost_apikey" ||
-                                       val == "printhost_cafile" || val == "printhost_user" || val == "printhost_password" || val == "printhost_port";
-                              }),
-               cfg_keys.end());
-    cfg.apply_only(project_config, cfg_keys, true);
-
-    //add different settings check logic, replace the old system preset's default value with new system preset's default values
-    if (!different_settings_list.empty()) {
-        if (DynamicPrintConfig *base_config = find_base(Preset::inherits(cfg))) {
-            std::string extruder_id_name, extruder_variant_name;
-            std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
-            Preset::get_extruder_names_and_keysets(type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
-            cfg.update_non_diff_values_to_base_config(*base_config, cfg_keys, different_settings_list, extruder_id_name, extruder_variant_name, *key_set1, *key_set2);
-        }
-    }
-    if (keys)
-        *keys = std::move(cfg_keys);
-    return cfg;
-}
-
 bool Preset::has_lidar(PresetBundle *preset_bundle)
 {
     bool has_lidar = false;
@@ -1702,6 +1718,22 @@ std::string PresetCollection::canonical_preset_name(const std::string &name, con
     return get_preset_canonical_name(parsed.bare, origin);
 }
 
+PresetCollection::PresetFilesOnDisk PresetCollection::PresetFilesOnDisk::read(const boost::filesystem::path &file)
+{
+    auto read_if_present = [](const fs::path &path) -> std::optional<std::string> {
+        std::string bytes;
+        try {
+            load_string_file(path, bytes);
+        } catch (const std::exception &) {
+            return std::nullopt;
+        }
+        return bytes;
+    };
+    fs::path info_path(file);
+    info_path.replace_extension(".info");
+    return { read_if_present(file), read_if_present(info_path) };
+}
+
 PresetCollection::UserPresetLoad PresetCollection::resolve_user_preset(
     const boost::filesystem::path &file, const std::string &canonical_name,
     const PresetOrigin &load_origin, ForwardCompatibilitySubstitutionRule substitution_rule,
@@ -1713,6 +1745,9 @@ PresetCollection::UserPresetLoad PresetCollection::resolve_user_preset(
     Preset &preset = out.preset;
     preset.bundle_id = load_origin.bundle_id;
     preset.file = file.string();
+    // Before either file is parsed, so a save that lands during the parse still shows
+    // up as a difference when commit compares.
+    out.on_disk = PresetFilesOnDisk::read(file);
     // Load the preset file, apply preset values on top of defaults.
     try {
         fs::path idx_path(preset.file);
@@ -1825,14 +1860,8 @@ void PresetCollection::commit_user_preset(UserPresetLoad &&loaded, std::deque<Pr
         ++m_errors;
         BOOST_LOG_TRIVIAL(error) << error;
     }
-    if (loaded.discard_file && !read_only) {
-        fs::path file_path(loaded.preset.file);
-        if (fs::exists(file_path))
-            fs::remove(file_path);
-        file_path.replace_extension(".info");
-        if (fs::exists(file_path))
-            fs::remove(file_path);
-    }
+    if (loaded.discard_file)
+        remove_preset_files(loaded.preset.file, read_only);
     if (!loaded.install)
         return;
 
@@ -1840,9 +1869,12 @@ void PresetCollection::commit_user_preset(UserPresetLoad &&loaded, std::deque<Pr
         if (loaded.save_compatible_printers) {
             // A filesystem error from the rewrite is counted, and the preset still loads.
             try {
-                if (!read_only)
-                    preset.save(nullptr);
-                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " added compatible_printers for preset: " << preset.name;
+                if (read_only)
+                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " added compatible_printers for preset: " << preset.name << " (not written back)";
+                else if (preset.save(nullptr))
+                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " added compatible_printers for preset: " << preset.name;
+                else
+                    ++m_errors; // save() logged why
             } catch (const std::runtime_error &err) {
                 ++m_errors;
                 BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " can not write compatible_printers back to " << preset.file << ": " << err.what();
@@ -1928,11 +1960,32 @@ void PresetCollection::load_presets(
             return this->resolve_user_preset(files[i].path, files[i].canonical_name, resolved_origin, substitution_rule,
                                              extruder_id_name, extruder_variant_name, key_set1, key_set2);
         },
-        [&](size_t, UserPresetLoad &&loaded) {
+        [&](size_t i, UserPresetLoad &&loaded) {
+            // Resolve read the files without the lock, so another instance may have saved
+            // over them since. A file that changed is resolved again under the lock before
+            // commit removes or rewrites it, which also keeps its .json and .info from two
+            // different saves apart. Without the lock nothing is checked, so commit leaves
+            // the files alone.
+            const std::string lock_path = user_presets_lock_path(read_only);
+            InstanceLock      instance_lock(lock_path);
+            if (instance_lock.locked()) {
+                const PresetFilesOnDisk   on_disk = PresetFilesOnDisk::read(files[i].path);
+                boost::system::error_code ec;
+                // The link itself, and a stat error counts as present, so a file that is
+                // there but cannot be read is still counted and removed by commit.
+                if (! on_disk.json && fs::symlink_status(files[i].path, ec).type() == fs::file_not_found)
+                    return; // removed by another instance since it was read
+                if (! (on_disk == loaded.on_disk)) {
+                    CNumericLocalesSetter locales_setter;
+                    loaded = this->resolve_user_preset(files[i].path, files[i].canonical_name, resolved_origin, substitution_rule,
+                                                       extruder_id_name, extruder_variant_name, key_set1, key_set2);
+                }
+            }
+            const bool leave_files = read_only || (! lock_path.empty() && ! instance_lock.locked());
             // Committing can remove an unreadable preset's file, and a filesystem error
             // there is reported without stopping the rest of the directory.
             try {
-                this->commit_user_preset(std::move(loaded), presets_loaded, substitutions, preset_loaded_fn, read_only);
+                this->commit_user_preset(std::move(loaded), presets_loaded, substitutions, preset_loaded_fn, leave_files);
             } catch (const std::runtime_error &err) {
                 errors_cummulative += err.what();
                 errors_cummulative += "\n";
@@ -2242,7 +2295,10 @@ void PresetCollection::set_sync_info_and_save(std::string name, std::string sett
             preset->setting_id = setting_id;
             if (update_time > 0)
                 preset->updated_time = update_time;
-            preset->sync_info == "update" ? preset->save(nullptr) : preset->save_info();
+            if (preset->sync_info == "update")
+                preset->save(nullptr);
+            else
+                preset->save_info();
             break;
         }
     }
@@ -2671,6 +2727,20 @@ std::pair<Preset*, bool> PresetCollection::load_external_preset(
     const Semver                file_version,
     const std::string           filament_id)
 {
+    // Load the preset over a default preset, so that the missing fields are filled in from the default preset.
+    DynamicPrintConfig cfg(this->default_preset_for(combined_config).config);
+    // SoftFever: ignore print connection info from project
+    auto        keys = cfg.keys();
+    keys.erase(std::remove_if(keys.begin(), keys.end(),
+                              [](std::string &val) {
+                                return val == "print_host" || val == "print_host_webui" || val == "printhost_apikey" ||
+                                       val == "printhost_cafile" || val == "printhost_user" || val == "printhost_password" || val == "printhost_port";
+                              }),
+               keys.end());
+    cfg.apply_only(combined_config, keys, true);
+    std::string                 &inherits = Preset::inherits(cfg);
+
+    //add different settings check logic, replace the old system preset's default value with new system preset's default values
     std::deque<Preset>::iterator it       = this->find_preset_internal(original_name);
     bool                         found    = it != m_presets.end() && it->name == original_name;
     if (! found) {
@@ -2679,25 +2749,24 @@ std::pair<Preset*, bool> PresetCollection::load_external_preset(
         found = it != m_presets.end();
     }
 
-    t_config_option_keys keys;
-    DynamicPrintConfig cfg = Preset::load_external_config(m_type, this->default_preset_for(combined_config).config, combined_config, different_settings_list,
-        [this, &original_name, &path, found, it](const std::string &inherits) -> DynamicPrintConfig * {
-            if (!inherits.empty()) {
-                auto iter = this->find_preset_internal(inherits);
-                if (iter == m_presets.end() || iter->name != inherits)
-                    iter = this->find_preset_renamed(inherits);
-                if (iter == m_presets.end())
-                    return nullptr;
-                BOOST_LOG_TRIVIAL(info) << "load_external_preset" << boost::format(": change preset %1% inherit %2% 's value to %3% 's values")%original_name %inherits %path;
-                return &iter->config;
-            }
-            if (found && it->is_system) {
-                BOOST_LOG_TRIVIAL(info) << "load_external_preset" << boost::format(": change preset %1% 's value to %2% 's values")%original_name %path;
-                return &it->config;
-            }
-            return nullptr;
-        }, &keys);
-    std::string                 &inherits = Preset::inherits(cfg);
+    std::string extruder_id_name, extruder_variant_name;
+    std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
+    Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
+
+    if (!inherits.empty() && (different_settings_list.size() > 0)) {
+        auto iter = this->find_preset_internal(inherits);
+        if (iter == m_presets.end() || iter->name != inherits)
+            iter = this->find_preset_renamed(inherits);
+        if (iter != m_presets.end()) {
+            //std::vector<std::string> dirty_options = cfg.diff(iter->config);
+            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": change preset %1% inherit %2% 's value to %3% 's values")%original_name %inherits %path;
+            cfg.update_non_diff_values_to_base_config(iter->config, keys, different_settings_list, extruder_id_name, extruder_variant_name, *key_set1, *key_set2);
+        }
+    }
+    else if (found && it->is_system && (different_settings_list.size() > 0)) {
+        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": change preset %1% 's value to %2% 's values")%original_name %path;
+        cfg.update_non_diff_values_to_base_config(it->config, keys, different_settings_list, extruder_id_name, extruder_variant_name, *key_set1, *key_set2);
+    }
 
     //BBS: add config related logs
     BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" enter, type %1% , path %2%, name %3%, original_name %4%, inherits %5%")%Preset::get_type_string(m_type) %path %name %original_name %inherits;
@@ -4311,8 +4380,15 @@ void PhysicalPrinter::update_preset_names_in_config()
     }
 }
 
+void PhysicalPrinter::save(DynamicPrintConfig* /* parent_config */)
+{
+    InstanceLock instance_lock(user_presets_lock_path());
+    this->config.save_to_json(this->file, std::string("Physical_Printer"), std::string("User"), std::string(SLIC3R_VERSION));
+}
+
 void PhysicalPrinter::save(const std::string& file_name_from, const std::string& file_name_to)
 {
+    InstanceLock instance_lock(user_presets_lock_path());
     // rename the file
     boost::nowide::rename(file_name_from.data(), file_name_to.data());
     this->file = file_name_to;
@@ -4444,6 +4520,7 @@ void PhysicalPrinterCollection::load_printers(
                 continue;
             }
             try {
+                InstanceLock instance_lock(user_presets_lock_path());
                 PhysicalPrinter printer(name, this->default_config());
                 printer.file = dir_entry.path().string();
                 // Load the preset file, apply preset values on top of defaults.
@@ -4636,7 +4713,10 @@ bool PhysicalPrinterCollection::delete_printer(const std::string& name)
 
     const PhysicalPrinter& printer = *it;
     // Erase the preset file.
-    boost::nowide::remove(printer.file.c_str());
+    {
+        InstanceLock instance_lock(user_presets_lock_path());
+        boost::nowide::remove(printer.file.c_str());
+    }
     m_printers.erase(it);
     return true;
 }
@@ -4648,7 +4728,10 @@ bool PhysicalPrinterCollection::delete_selected_printer()
     const PhysicalPrinter& printer = this->get_selected_printer();
 
     // Erase the preset file.
-    boost::nowide::remove(printer.file.c_str());
+    {
+        InstanceLock instance_lock(user_presets_lock_path());
+        boost::nowide::remove(printer.file.c_str());
+    }
     // Remove the preset from the list.
     m_printers.erase(m_printers.begin() + m_idx_selected);
     // unselect all printers

src/libslic3r/Preset.hpp

@@ -8,6 +8,7 @@
 #include <unordered_set>
 #include <functional>
 #include <mutex>
+#include <optional>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/property_tree/ptree_fwd.hpp>
@@ -330,7 +331,8 @@ public:
 
     //BBS: add logic for only difference save
     //if parent_config is null, save all keys, otherwise, only save difference
-    void                save(DynamicPrintConfig* parent_config);
+    // Returns false when the preset file could not be written.
+    bool                save(DynamicPrintConfig* parent_config);
     void                reload(Preset const & parent);
 
     // Return a label of this preset, consisting of a name and a "(modified)" suffix, if this preset is dirty.
@@ -403,15 +405,6 @@ public:
     std::string get_current_printer_type(PresetBundle *preset_bundle); // get current preset type
 
     static void get_extruder_names_and_keysets(Type type, std::string& extruder_id_name, std::string& extruder_variant_name, std::set<std::string>** p_key_set1, std::set<std::string>** p_key_set2);
-    // Config of a preset loaded from a project or config file: the project's values over the type's
-    // default preset config, without the print-host keys. When different_settings_list is not empty,
-    // every key not listed in it is then refreshed from the base system preset, which find_base returns
-    // for the project's "inherits" (nullptr when there is none), with the listed per-variant values
-    // mapped onto the base's extruder variants. keys, if given, receives the keys taken from the project.
-    static DynamicPrintConfig load_external_config(Type type, const DynamicPrintConfig &default_config, const DynamicPrintConfig &project_config,
-                                                   const std::set<std::string> &different_settings_list,
-                                                   const std::function<DynamicPrintConfig *(const std::string &inherits)> &find_base,
-                                                   t_config_option_keys *keys = nullptr);
     std::string get_printer_id() const { return vendor ? vendor->id : ""; }
 
     bool has_lidar(PresetBundle *preset_bundle);
@@ -497,6 +490,12 @@ std::string get_preset_canonical_name(const std::string &preset_bare_name, const
 // Tail segment of a canonical name — what's written to the bundle's .json filename and JSON "name" field.
 std::string get_preset_bare_name(const std::string &canonical_name);
 
+// Lock file guarding every user preset file under data_dir() against other
+// running instances and the preset sync thread. Empty without a data dir, and
+// for a read-only load (the CLI), which never rewrites or deletes and may run
+// many jobs on one data dir.
+std::string user_presets_lock_path(bool read_only = false);
+
 // Resolve an origin from a directory path when the caller passes Kind::Auto.
 PresetOrigin detect_origin_from_path(const boost::filesystem::path &path, const PresetOrigin &explicit_origin = PresetOrigin());
 
@@ -906,6 +905,16 @@ protected:
     void            set_custom_preset_alias(Preset &preset);
 
 private:
+    // A preset file and its .info as read from disk, std::nullopt for one that is missing.
+    struct PresetFilesOnDisk
+    {
+        std::optional<std::string> json;
+        std::optional<std::string> info;
+
+        static PresetFilesOnDisk read(const boost::filesystem::path &file);
+        bool operator==(const PresetFilesOnDisk &rhs) const { return json == rhs.json && info == rhs.info; }
+    };
+
     // One preset file read and flattened against the presets already in this
     // collection, before anything the collection shares has been touched.
     struct UserPresetLoad
@@ -923,6 +932,9 @@ private:
         bool        discard_file { false };
         // The .info file read beside the preset, which commit logs.
         std::string info_file;
+        // Both files as they were before the preset was read from them. Resolve runs
+        // without the instance lock, so commit compares this with the disk under it.
+        PresetFilesOnDisk on_disk;
         // Counted and logged by commit, in the order the directory listed the files.
         std::vector<std::string>   errors;
         PresetsConfigSubstitutions substitutions;
@@ -1111,7 +1123,7 @@ public:
 
     //BBS: change to json format
     //void                save() { this->config.save(this->file); }
-    void                save(DynamicPrintConfig* parent_config) { this->config.save_to_json(this->file, std::string("Physical_Printer"), std::string("User"), std::string(SLIC3R_VERSION)); }
+    void                save(DynamicPrintConfig* parent_config);
     void                save(const std::string& file_name_from, const std::string& file_name_to);
 
     void                update_from_preset(const Preset& preset);

src/libslic3r/PresetBundle.cpp

@@ -1,3 +1,4 @@
+#include <atomic>
 #include <cassert>
 #include <chrono>
 #include <ctime>
@@ -13,6 +14,7 @@
 #include "libslic3r.h"
 #include "I18N.hpp"
 #include "Utils.hpp"
+#include "InstanceLock.hpp"
 #include "LocalesUtils.hpp"
 #include "Model.hpp"
 #include "TriangleSelector.hpp"
@@ -581,20 +583,18 @@ bool PresetBundle::resolve_preset_config(DynamicPrintConfig &config, Preset::Typ
 const PresetBundle *PresetBundle::load_source_vendor(const boost::filesystem::path &root_dir,
                                                     const std::string &vendor_id,
                                                     ForwardCompatibilitySubstitutionRule compatibility_rule,
-                                                    std::string &error, bool allow_cache)
+                                                    std::string &error)
 {
-    auto key = std::make_tuple(root_dir.string(), vendor_id, compatibility_rule, allow_cache);
+    auto key = std::make_tuple(root_dir.string(), vendor_id, compatibility_rule);
     if (auto it = m_source_vendor_bundles.find(key); it != m_source_vendor_bundles.end())
         return it->second.get();
 
     // The library loads with no base of its own, so the tree a vendor inherits from
     // is the same one that resolves the library's own presets.
-    const std::string   library_file = std::string(ORCA_FILAMENT_LIBRARY);
-    const PresetBundle *library      = nullptr;
+    const PresetBundle *library = nullptr;
     if (vendor_id != ORCA_FILAMENT_LIBRARY &&
-        (boost::filesystem::is_regular_file(root_dir / (library_file + ".json")) ||
-         (allow_cache && boost::filesystem::is_regular_file(root_dir / (library_file + ".opc"))))) {
-        library = load_source_vendor(root_dir, ORCA_FILAMENT_LIBRARY, compatibility_rule, error, allow_cache);
+        boost::filesystem::is_regular_file(root_dir / (std::string(ORCA_FILAMENT_LIBRARY) + ".json"))) {
+        library = load_source_vendor(root_dir, ORCA_FILAMENT_LIBRARY, compatibility_rule, error);
         if (library == nullptr) {
             error = "OrcaFilamentLibrary contains invalid presets";
             return nullptr;
@@ -603,7 +603,7 @@ const PresetBundle *PresetBundle::load_source_vendor(const boost::filesystem::pa
 
     auto bundle = std::make_unique<PresetBundle>();
     bundle->m_preserve_vendor_source_paths = true;
-    bundle->load_vendor_configs_from_json(root_dir.string(), vendor_id, LoadSystem, compatibility_rule, library, allow_cache);
+    bundle->load_vendor_configs_from_json(root_dir.string(), vendor_id, LoadSystem, compatibility_rule, library, false);
     if (bundle->error_count() != 0) {
         error = "Vendor bundle contains invalid presets";
         return nullptr;
@@ -646,43 +646,6 @@ bool PresetBundle::resolve_preset_config_type(DynamicPrintConfig &config, Preset
     return true;
 }
 
-bool PresetBundle::resolve_system_preset(DynamicPrintConfig &config, Preset::Type type, const std::string &name,
-                                         ForwardCompatibilitySubstitutionRule compatibility_rule, std::string &error)
-{
-    const std::string vendor_id = find_preset_vendor(name, type);
-    if (vendor_id.empty()) {
-        error = "No vendor lists the preset";
-        return false;
-    }
-    // Release builds ship a vendor as its preset cache alone, without the profile JSONs.
-    auto installed = [&vendor_id](const fs::path &root) {
-        return fs::is_regular_file(root / (vendor_id + ".json")) || fs::is_regular_file(root / (vendor_id + ".opc"));
-    };
-    fs::path root_dir = fs::path(data_dir()) / PRESET_SYSTEM_DIR;
-    if (!installed(root_dir))
-        root_dir = fs::path(resources_dir()) / PRESET_PROFILES_DIR;
-    const bool cache_only = !fs::is_regular_file(root_dir / (vendor_id + ".json"));
-
-    try {
-        const PresetBundle *vendor = load_source_vendor(root_dir, vendor_id, compatibility_rule, error, cache_only);
-        if (vendor == nullptr)
-            return false;
-        const PresetCollection &collection = type == Preset::TYPE_PRINTER ? vendor->printers :
-                                             type == Preset::TYPE_PRINT   ? vendor->prints : vendor->filaments;
-        const Preset *preset = collection.find_preset(name, false);
-        if (preset == nullptr) {
-            error = "Preset was not found in its vendor bundle";
-            return false;
-        }
-        config = preset->config;
-    } catch (const std::exception &ex) {
-        error = ex.what();
-        return false;
-    }
-    error.clear();
-    return true;
-}
-
 PresetBundle::PresetBundle(const PresetBundle &rhs)
 {
     *this = rhs;
@@ -1272,6 +1235,13 @@ PresetsConfigSubstitutions PresetBundle::load_user_presets(std::string user, For
 
     const auto user_load_t0 = std::chrono::steady_clock::now();
 
+    // Reads one bundle's metadata under the lock, per file, so the lock is never
+    // held when bundles.WriteLock() is taken afterwards.
+    auto load_bundle_metadata = [read_only](const fs::path &metadata_file, BundleMetadata &metadata) {
+        InstanceLock instance_lock(user_presets_lock_path(read_only));
+        return metadata.load_from_json(metadata_file.string());
+    };
+
     // Load bundle metadata from _local directory first
     fs::path local_dir(folder / PRESET_LOCAL_DIR);
     if (fs::exists(local_dir)) {
@@ -1285,7 +1255,7 @@ PresetsConfigSubstitutions PresetBundle::load_user_presets(std::string user, For
             if (!fs::exists(metadata_file)) continue;
 
             BundleMetadata metadata;
-            if (!metadata.load_from_json(metadata_file.string())) continue;
+            if (!load_bundle_metadata(metadata_file, metadata)) continue;
             metadata.print_presets.clear();
             metadata.filament_presets.clear();
             metadata.printer_presets.clear();
@@ -1320,7 +1290,7 @@ PresetsConfigSubstitutions PresetBundle::load_user_presets(std::string user, For
             if (!fs::exists(metadata_file)) continue;
 
             BundleMetadata metadata;
-            if (!metadata.load_from_json(metadata_file.string())) continue;
+            if (!load_bundle_metadata(metadata_file, metadata)) continue;
             metadata.print_presets.clear();
             metadata.filament_presets.clear();
             metadata.printer_presets.clear();
@@ -1654,10 +1624,12 @@ PresetsConfigSubstitutions PresetBundle::import_presets(std::vector<std::string>
             if (ec) BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " create directory failed: " << ec.message();
             //create temp folder
             //std::string user_default_temp_dir = data_dir() + "/" + PRESET_USER_DIR + "/" + DEFAULT_USER_FOLDER_NAME + "/" + "temp";
-            fs::path temp_folder(configs_folder / "temp");
+            // Under cache/, per process and per import, so two instances importing
+            // at once do not clear each other's extraction and no preset scan reads it.
+            static std::atomic<unsigned> import_counter{0};
+            fs::path temp_folder(fs::path(data_dir()) / "cache" / ("import." + std::to_string(get_current_pid()) + "." + std::to_string(import_counter++)));
             std::string user_default_temp_dir = temp_folder.make_preferred().string();
-            if (fs::exists(temp_folder)) fs::remove_all(temp_folder);
-            fs::create_directory(temp_folder, ec);
+            fs::create_directories(temp_folder, ec);
             if (ec) BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " create directory failed: " << ec.message();
 
             file = boost::filesystem::path(file).make_preferred().string();
@@ -1669,6 +1641,9 @@ PresetsConfigSubstitutions PresetBundle::import_presets(std::vector<std::string>
             status        = mz_zip_reader_init_cfile(&zip_archive, zipFile, 0, MZ_ZIP_FLAG_CASE_SENSITIVE | MZ_ZIP_FLAG_IGNORE_PATH);
             if (MZ_FALSE == status) {
                 BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " Failed to initialize reader ZIP archive";
+                if (zipFile != nullptr)
+                    std::fclose(zipFile);
+                fs::remove_all(temp_folder, ec);
                 return substitutions;
             } else {
                 BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " Success to initialize reader ZIP archive";
@@ -2276,10 +2251,9 @@ void PresetBundle::remove_user_presets_directory(const std::string preset_folder
         return;
     }
     BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" enter, delete directory : %1%") % dir_user_presets;
-    fs::path folder(dir_user_presets);
-    if (fs::exists(folder)) {
-        fs::remove_all(folder);
-    }
+    boost::system::error_code ec;
+    InstanceLock instance_lock(user_presets_lock_path());
+    fs::remove_all(fs::path(dir_user_presets), ec);
 }
 
 void PresetBundle::update_system_preset_setting_ids(std::map<std::string, std::map<std::string, std::string>>& system_presets)
@@ -3954,6 +3928,7 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
     ConfigOptionStrings *filament_color_type = project_config.option<ConfigOptionStrings>("filament_colour_type");
     ConfigOptionInts *   filament_map = project_config.option<ConfigOptionInts>("filament_map");
     ConfigOptionInts *   filament_volume_map = project_config.option<ConfigOptionInts>("filament_volume_map");
+
     // Snapshot and temporarily strip mixed filament slots so AMS sync operates on physical
     // filaments only. A mixed slot is virtual and has no tray to sync against; leaving it in
     // would let AMS mapping overwrite it and would break the physical-first slot ordering the
@@ -4703,15 +4678,6 @@ const std::set<std::string> ignore_settings_list ={
     "print_settings_id", "filament_settings_id", "printer_settings_id"
 };
 
-std::set<std::string> PresetBundle::project_different_keys(const std::string &different_settings)
-{
-    std::vector<std::string> keys;
-    Slic3r::unescape_strings_cstyle(different_settings, keys);
-    std::set<std::string> keys_set(keys.begin(), keys.end());
-    keys_set.insert(ignore_settings_list.begin(), ignore_settings_list.end());
-    return keys_set;
-}
-
 DynamicPrintConfig PresetBundle::full_fff_config(bool apply_extruder, std::optional<std::vector<int>> filament_maps_new, std::optional<std::vector<int>> filament_volume_maps_new) const
 {
     DynamicPrintConfig out;
@@ -5419,7 +5385,15 @@ void PresetBundle::load_config_file_config(const std::string &name_or_path, bool
         if (!is_published) {
             //BBS: add different settings logic
             BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": load print preset from print_settings_id");
-            std::set<std::string> print_different_keys_set = project_different_keys(different_values[0]);
+            std::vector<std::string> print_different_keys_vector;
+            std::string print_different_settings = different_values[0];
+            Slic3r::unescape_strings_cstyle(print_different_settings, print_different_keys_vector);
+            std::set<std::string> print_different_keys_set(print_different_keys_vector.begin(), print_different_keys_vector.end());
+            //if (!has_different_settings_to_system) {
+            //    print_different_keys_set.clear();
+            //}
+            //else
+                print_different_keys_set.insert(ignore_settings_list.begin(), ignore_settings_list.end());
             if (!print_compatible_printers.empty()) {
                 ConfigOptionStrings* compatible_printers = config.option<ConfigOptionStrings>("compatible_printers", true);
                 compatible_printers->values = print_compatible_printers;
@@ -5430,7 +5404,15 @@ void PresetBundle::load_config_file_config(const std::string &name_or_path, bool
             //clear compatible printers
             clear_compatible_printers(config);
 
-            std::set<std::string> printer_different_keys_set = project_different_keys(different_values[num_filaments + 1]);
+            std::vector<std::string> printer_different_keys_vector;
+            std::string printer_different_settings = different_values[num_filaments + 1];
+            Slic3r::unescape_strings_cstyle(printer_different_settings, printer_different_keys_vector);
+            std::set<std::string> printer_different_keys_set(printer_different_keys_vector.begin(), printer_different_keys_vector.end());
+            //if (!has_different_settings_to_system) {
+            //    printer_different_keys_set.clear();
+            //}
+            //else
+                printer_different_keys_set.insert(ignore_settings_list.begin(), ignore_settings_list.end());
             //BBS: add config related logs
             BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": load printer preset from printer_settings_id");
             load_preset(this->printers, num_filaments + 1, "printer_settings_id", printer_different_keys_set, std::string());
@@ -5449,7 +5431,15 @@ void PresetBundle::load_config_file_config(const std::string &name_or_path, bool
     			Preset                *loaded = nullptr;
 
                 //BBS: add different settings logic
-                std::set<std::string> filament_different_keys_set = project_different_keys(different_values[1]);
+                std::vector<std::string> filament_different_keys_vector;
+                std::string filament_different_settings = different_values[1];
+                Slic3r::unescape_strings_cstyle(filament_different_settings, filament_different_keys_vector);
+                std::set<std::string> filament_different_keys_set(filament_different_keys_vector.begin(), filament_different_keys_vector.end());
+                //if (!has_different_settings_to_system) {
+                //    filament_different_keys_set.clear();
+                //}
+                //else
+                    filament_different_keys_set.insert(ignore_settings_list.begin(), ignore_settings_list.end());
 
                 std::string filament_id = filament_ids[0];
                 //BBS: add config related logs
@@ -5512,7 +5502,15 @@ void PresetBundle::load_config_file_config(const std::string &name_or_path, bool
                     cfg.opt_string("inherits", true)                      = inherits_values[i + 1];
 
                     //BBS: add different settings logic
-                    std::set<std::string> filament_different_keys_set = project_different_keys(different_values[i+1]);
+                    std::vector<std::string> filament_different_keys_vector;
+                    std::string filament_different_settings = different_values[i+1];
+                    Slic3r::unescape_strings_cstyle(filament_different_settings, filament_different_keys_vector);
+                    std::set<std::string> filament_different_keys_set(filament_different_keys_vector.begin(), filament_different_keys_vector.end());
+                    //if (!has_different_settings_to_system) {
+                    //    filament_different_keys_set.clear();
+                    //}
+                    //else
+                        filament_different_keys_set.insert(ignore_settings_list.begin(), ignore_settings_list.end());
 
                     std::string filament_id = filament_ids[i];
 
@@ -8202,9 +8200,13 @@ bool BundleMetadata::save_to_json(const std::string& path) const
         j["filament_presets"] = strip_prefix(this->filament_presets);                                                                                                                                                                                                                       
         j["printer_presets"] = strip_prefix(this->printer_presets);
 
-        boost::nowide::ofstream ofs(path);
-        ofs << j.dump(4);
-        return ofs.good();
+        const std::string content = j.dump(4);
+        InstanceLock instance_lock(user_presets_lock_path());
+        if (const std::error_code ec = write_file_atomically(path, content)) {
+            BOOST_LOG_TRIVIAL(error) << "Failed to save bundle metadata to " << path << ": " << ec.message();
+            return false;
+        }
+        return true;
     } catch (const std::exception& e) {
         BOOST_LOG_TRIVIAL(error) << "Failed to save bundle metadata to " << path << ": " << e.what();
         return false;

src/libslic3r/PresetBundle.hpp

@@ -235,9 +235,6 @@ public:
 
     // ORCA: utility function to find the vendor for a given preset name
     static std::string find_preset_vendor(const std::string& preset_name, Preset::Type type);
-    // Keys a project keeps when its presets are loaded: those listed in its escaped
-    // "different_settings_to_system" entry for the preset, plus the preset bookkeeping keys.
-    static std::set<std::string> project_different_keys(const std::string &different_settings);
 
     PresetBundle();
     PresetBundle(const PresetBundle &rhs);
@@ -277,10 +274,6 @@ public:
                                     const std::string &source_file,
                                     ForwardCompatibilitySubstitutionRule compatibility_rule,
                                     std::string &error, bool allow_source_manifest = true);
-    // Resolve a system preset by name. The vendor tree is read from data_dir()/system when installed
-    // there, as the GUI reads it, and from the bundled profiles otherwise.
-    bool resolve_system_preset(DynamicPrintConfig &config, Preset::Type type, const std::string &name,
-                               ForwardCompatibilitySubstitutionRule compatibility_rule, std::string &error);
 
     // Load selections (current print, current filaments, current printer) from config.ini
     // This is done just once on application start up.
@@ -815,14 +808,13 @@ private:
     // Vendor trees loaded by resolve_preset_config's manifest path, so every preset
     // resolved through this bundle shares one load per source root and vendor. The
     // filament library is one such tree, shared by every vendor under its root.
-    // A tree read from its preset cache is kept apart: its presets carry no source file.
-    std::map<std::tuple<std::string, std::string, ForwardCompatibilitySubstitutionRule, bool>, std::unique_ptr<PresetBundle>>
+    std::map<std::tuple<std::string, std::string, ForwardCompatibilitySubstitutionRule>, std::unique_ptr<PresetBundle>>
         m_source_vendor_bundles;
 
     const PresetBundle *load_source_vendor(const boost::filesystem::path &root_dir,
                                            const std::string &vendor_id,
                                            ForwardCompatibilitySubstitutionRule compatibility_rule,
-                                           std::string &error, bool allow_cache = false);
+                                           std::string &error);
 
     // Orca: validation only - flag any printer with two or more compatible
     // filament presets sharing one filament_id (ambiguous AMS subtype match).

src/libslic3r/PresetCacheFormat.cpp

@@ -400,46 +400,24 @@ bool write_cache_blob(const std::string& path, const std::string& blob)
 {
     boost::crc_32_type crc;
     crc.process_bytes(blob.data(), blob.size());
-    // Written beside the target and moved into place, as AppConfig::save does:
-    // a cache is truncated and rewritten in full, so a write that dies partway
-    // would otherwise leave a header claiming more body than the file holds.
-    // The PID suffix also keeps two instances writing the same vendor from
-    // interleaving.
-    const std::string tmp_path = path + "." + std::to_string(get_current_pid()) + ".tmp";
+    // Written beside the target and moved into place: a cache is truncated and
+    // rewritten in full, so a write that dies partway would otherwise leave a
+    // header claiming more body than the file holds.
     try {
         boost::filesystem::create_directories(boost::filesystem::path(path).parent_path());
-        {
-            boost::nowide::ofstream ofs(tmp_path, std::ios::binary | std::ios::trunc);
-            if (!ofs.is_open()) {
-                BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: cannot open for writing: " << tmp_path;
-                return false;
-            }
-            CacheFileHeader fhdr;
-            fhdr.magic     = CACHE_MAGIC;
-            fhdr.version   = CACHE_VERSION;
-            fhdr.data_size = static_cast<uint64_t>(blob.size());
-            fhdr.crc32     = crc.checksum();
-            ofs.write(reinterpret_cast<const char*>(&fhdr), sizeof(fhdr));
-            ofs.write(blob.data(), static_cast<std::streamsize>(blob.size()));
-            ofs.close();   // flush; close() raises failbit on error
-            if (! ofs.good()) {
-                BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: write failed (" << tmp_path << ")";
-                boost::system::error_code ec;
-                boost::filesystem::remove(tmp_path, ec);
-                return false;
-            }
-        }
-        if (const std::error_code ec = rename_file(tmp_path, path)) {
-            BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: could not move " << tmp_path << " into place: " << ec.message();
-            boost::system::error_code rm;
-            boost::filesystem::remove(tmp_path, rm);
+        CacheFileHeader fhdr;
+        fhdr.magic     = CACHE_MAGIC;
+        fhdr.version   = CACHE_VERSION;
+        fhdr.data_size = static_cast<uint64_t>(blob.size());
+        fhdr.crc32     = crc.checksum();
+        const std::string_view header(reinterpret_cast<const char*>(&fhdr), sizeof(fhdr));
+        if (const std::error_code ec = write_file_atomically(path, { header, std::string_view(blob) }, /*binary=*/true)) {
+            BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: write failed (" << path << "): " << ec.message();
             return false;
         }
         return true;
     } catch (const std::exception& e) {
         BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: write failed (" << path << "): " << e.what();
-        boost::system::error_code ec;
-        boost::filesystem::remove(tmp_path, ec);
         return false;
     }
 }

src/libslic3r/PrintConfig.cpp

@@ -12595,7 +12595,6 @@ OtherSlicingStatesConfigDef::OtherSlicingStatesConfigDef()
 
     new_def("initial_no_support_extruder", coInt, "Initial no support extruder", "Zero-based index of the first extruder used for printing without support. Same as initial_no_support_tool.");
     new_def("in_head_wrap_detect_zone", coBool, "In head wrap detect zone", "Indicates if the first layer overlaps with the head wrap zone.");
-    new_def("curr_bed_type", coString, "Current bed type", "Name of the currently selected bed plate type (e.g. 'Textured PEI Plate', 'Smooth High Temp Plate').");
 }
 
 PrintStatisticsConfigDef::PrintStatisticsConfigDef()

src/libslic3r/Utils.hpp

@@ -8,6 +8,8 @@
 #include <functional>
 #include <type_traits>
 #include <system_error>
+#include <initializer_list>
+#include <string_view>
 #include <regex>
 
 #include <boost/system/error_code.hpp>
@@ -224,6 +226,21 @@ extern std::vector<std::string> split_string(const std::string &str, char delimi
 // On Windows, the file explorer (or anti-virus or whatever else) often locks the file
 // for a short while, so the file may not be movable. Retry while we see recoverable errors.
 extern std::error_code rename_file(const std::string &from, const std::string &to);
+// Write `chunks`, in order, to `path` through a temporary file beside it that is
+// then renamed over the target, so a concurrent reader sees the old or the new
+// file, never a partial one. The temporary is removed on failure and an existing
+// target keeps its permissions. Text mode unless `binary`, so Windows writes CRLF
+// as the streams this replaces did. A target that is not a regular file (a
+// device or pipe) is written in place, since replacing it would change what it
+// is, and so is an existing target beside which no temporary can be created or
+// whose replace the filesystem refuses; a symlink is followed and the file it
+// names is replaced. On Windows a reader holding the
+// target open without sharing its deletion, which the C runtime does not, makes
+// the replace fall back to the in-place write too, so an unlocked reader there
+// can still see a partial file.
+extern std::error_code write_file_atomically(const std::string &path, std::initializer_list<std::string_view> chunks, bool binary = false);
+inline std::error_code write_file_atomically(const std::string &path, const std::string &content, bool binary = false)
+	{ return write_file_atomically(path, { std::string_view(content) }, binary); }
 
 enum CopyFileResult {
 	SUCCESS = 0,

src/libslic3r/utils.cpp

@@ -9,6 +9,8 @@
 #include <stdio.h>
 #include <filesystem>
 #include <sstream>
+#include <cerrno>
+#include <mutex>
 #include <iomanip>
 #include <algorithm>
 #include <cmath>
@@ -703,13 +705,99 @@ namespace WindowsSupport
 std::error_code rename_file(const std::string &from, const std::string &to)
 {
 #ifdef _WIN32
+	// Retries and moves an open destination aside itself.
 	return WindowsSupport::rename(from, to);
 #else
-	boost::nowide::remove(to.c_str());
-	return std::make_error_code(static_cast<std::errc>(boost::nowide::rename(from.c_str(), to.c_str())));
+	// rename(2) replaces an existing target atomically; removing it first would
+	// leave a window in which the file does not exist at all.
+	if (boost::nowide::rename(from.c_str(), to.c_str()) == 0)
+		return {};
+	const int err = errno;
+	// Some mounts (sshfs, gvfs, MTP and a few SMB setups) refuse to replace an
+	// existing target in one step, each with the error it sees fit; every error
+	// is worth the remove-then-rename this always did, except the ones no retry
+	// can help: nothing at the source, a different device, or a directory where
+	// a file was expected and the reverse.
+	const bool worth_retrying = err != ENOENT && err != EXDEV && err != ENOTDIR && err != EISDIR;
+	if (worth_retrying && boost::nowide::remove(to.c_str()) == 0 && boost::nowide::rename(from.c_str(), to.c_str()) == 0)
+		return {};
+	return std::make_error_code(static_cast<std::errc>(err));
 #endif
 }
 
+static std::error_code write_whole_file(const std::string &path, std::initializer_list<std::string_view> chunks, bool binary)
+{
+	errno = 0;
+	FILE *file = boost::nowide::fopen(path.c_str(), binary ? "wb" : "w");
+	if (file == nullptr)
+		return std::make_error_code(errno != 0 ? static_cast<std::errc>(errno) : std::errc::io_error);
+	bool ok = true;
+	for (const std::string_view chunk : chunks)
+		ok = ok && std::fwrite(chunk.data(), 1, chunk.size(), file) == chunk.size();
+	ok = ok && std::fflush(file) == 0;
+	const int err = ok ? 0 : errno;
+	ok = std::fclose(file) == 0 && ok;
+	if (ok)
+		return {};
+	return std::make_error_code(err != 0 ? static_cast<std::errc>(err) : std::errc::io_error);
+}
+
+// The in-place fallback truncates the target, so two threads of this process
+// on the same file must not both be in it. One mutex for all such writes: they
+// are the rare case. Never freed, like the InstanceLock registry, so a save
+// during static destruction still finds it.
+static std::error_code write_in_place(const std::string &path, std::initializer_list<std::string_view> chunks, bool binary)
+{
+	static auto *mutex = new std::mutex();
+	std::lock_guard<std::mutex> guard(*mutex);
+	return write_whole_file(path, chunks, binary);
+}
+
+std::error_code write_file_atomically(const std::string &path, std::initializer_list<std::string_view> chunks, bool binary)
+{
+	boost::system::error_code bec;
+	const boost::filesystem::file_status target = boost::filesystem::symlink_status(path, bec);
+	const bool target_exists = ! bec && boost::filesystem::exists(target);
+	if (target_exists && boost::filesystem::is_symlink(target)) {
+		// A config or preset kept in a dotfiles repository: the link stays,
+		// the file it points to is replaced like any other.
+		const boost::filesystem::path resolved = boost::filesystem::canonical(path, bec);
+		if (! bec && boost::filesystem::is_regular_file(resolved, bec))
+			return write_file_atomically(resolved.string(), chunks, binary);
+	}
+	if (target_exists && ! boost::filesystem::is_regular_file(target))
+		return write_in_place(path, chunks, binary);
+
+	// Unique per process and per call, so two threads writing one target
+	// without a lock never share a temporary.
+	static std::atomic<unsigned> counter{0};
+	const std::string tmp_path = path + "." + std::to_string(get_current_pid()) + "." + std::to_string(counter++) + ".tmp";
+	if (const std::error_code ec = write_whole_file(tmp_path, chunks, binary)) {
+		boost::nowide::remove(tmp_path.c_str());
+		if (! target_exists)
+			return ec;
+		// A directory that lets this process write its files but not create
+		// one: losing the save is worse than a reader seeing a partial file.
+		BOOST_LOG_TRIVIAL(warning) << "Cannot create a temporary beside " << path << " (" << ec.message() << "); writing in place";
+		return write_in_place(path, chunks, binary);
+	}
+#ifndef _WIN32
+	// Not on Windows, where a read-only bit on the temporary would stop the rename itself.
+	if (target_exists)
+		boost::filesystem::permissions(tmp_path, target.permissions(), bec);
+#endif
+	if (const std::error_code ec = rename_file(tmp_path, path)) {
+		boost::nowide::remove(tmp_path.c_str());
+		// A reader on Windows holding the target open without FILE_SHARE_DELETE,
+		// or a mount that cannot replace a file at all. Losing the save is worse
+		// than a reader seeing a partial file, so write in place the way this
+		// used to work before the atomic path existed.
+		BOOST_LOG_TRIVIAL(warning) << "Cannot replace " << path << " (" << ec.message() << "); writing in place";
+		return write_in_place(path, chunks, binary);
+	}
+	return {};
+}
+
 #ifdef __linux__
 // Copied from boost::filesystem.
 // Called by copy_file_linux() in case linux sendfile() API is not supported.

src/slic3r/CMakeLists.txt

@@ -236,7 +236,6 @@ set(SLIC3R_GUI_SOURCES
     GUI/GLToolbar.hpp
     GUI/ImageDPIFrame.cpp
     GUI/ImageDPIFrame.hpp
-    GUI/IMediaController.hpp
     GUI/GUI_App.cpp
     GUI/GUI_App.hpp
     GUI/GUI_AuxiliaryList.cpp
@@ -366,8 +365,6 @@ set(SLIC3R_GUI_SOURCES
     GUI/MediaFilePanel.h
     GUI/MediaPlayCtrl.cpp
     GUI/MediaPlayCtrl.h
-    GUI/WebRtcMediaController.cpp
-    GUI/WebRtcMediaController.hpp
     GUI/MeshUtils.cpp
     GUI/MeshUtils.hpp
     GUI/ModelMall.cpp
@@ -563,8 +560,6 @@ set(SLIC3R_GUI_SOURCES
     GUI/WebUserLoginDialog.hpp
     GUI/WebViewDialog.cpp
     GUI/WebViewDialog.hpp
-    GUI/WebMediaController.hpp
-    GUI/WebMediaController.cpp
     GUI/Widgets/AMSControl.cpp
     GUI/Widgets/AMSControl.hpp
     GUI/Widgets/AMSItem.cpp
@@ -759,7 +754,6 @@ set(SLIC3R_GUI_SOURCES
     Utils/NetworkAgentFactory.cpp
     Utils/ICloudServiceAgent.hpp
     Utils/IPrinterAgent.hpp
-    Utils/ICameraSignalingChannel.hpp
     Utils/OrcaCloudServiceAgent.cpp
     Utils/OrcaCloudServiceAgent.hpp
     Utils/OrcaPrinterAgent.cpp
@@ -904,7 +898,7 @@ target_include_directories(libslic3r_gui PRIVATE Utils ${CMAKE_CURRENT_BINARY_DI
 
 if (WIN32)
     target_include_directories(libslic3r_gui SYSTEM PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../deps/WebView2/include)
-    target_link_libraries(libslic3r_gui Advapi32 Crypt32)
+    target_link_libraries(libslic3r_gui Advapi32)
 endif()
 
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SLIC3R_GUI_SOURCES})
@@ -930,7 +924,7 @@ else()
     set(_opengl_link_lib OpenGL::GL)
 endif()
 
-target_link_libraries(libslic3r_gui libslic3r cereal::cereal imgui imguizmo minilzo libvgcode md4c-html glad ${_opengl_link_lib} hidapi mdns ${wxWidgets_LIBRARIES} glfw libcurl OpenSSL::SSL OpenSSL::Crypto LibDataChannel::LibDataChannel noise::noise pybind11::embed)
+target_link_libraries(libslic3r_gui libslic3r cereal::cereal imgui imguizmo minilzo libvgcode md4c-html glad ${_opengl_link_lib} hidapi mdns ${wxWidgets_LIBRARIES} glfw libcurl OpenSSL::SSL OpenSSL::Crypto noise::noise pybind11::embed)
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
     # Linux finds wxWidgets in module mode, whose include dirs and definitions
@@ -987,32 +981,29 @@ endif ()
 
 if (APPLE)
     # Static FFmpeg from the deps install: nothing to bundle into the .app,
-    # no rpath/install_name handling. Order matters: avformat -> avcodec -> swscale -> avutil.
-    find_library(LIBAVFORMAT_LIBRARY NAMES libavformat.a PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
+    # no rpath/install_name handling. Order matters: avcodec -> swscale -> avutil.
     find_library(LIBAVCODEC_LIBRARY NAMES libavcodec.a PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBSWSCALE_LIBRARY NAMES libswscale.a PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBAVUTIL_LIBRARY NAMES libavutil.a PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
-    if (NOT LIBAVFORMAT_LIBRARY OR NOT LIBAVCODEC_LIBRARY OR NOT LIBSWSCALE_LIBRARY OR NOT LIBAVUTIL_LIBRARY)
-        message(FATAL_ERROR "Static FFmpeg (libavformat.a/libavcodec.a/libswscale.a/libavutil.a) not found under ${CMAKE_PREFIX_PATH}/lib. Rebuild the deps — FFMPEG builds static-only on macOS.")
+    if (NOT LIBAVCODEC_LIBRARY OR NOT LIBSWSCALE_LIBRARY OR NOT LIBAVUTIL_LIBRARY)
+        message(FATAL_ERROR "Static FFmpeg (libavcodec.a/libswscale.a/libavutil.a) not found under ${CMAKE_PREFIX_PATH}/lib. Rebuild the deps — FFMPEG builds static-only on macOS.")
     endif ()
-    target_link_libraries(libslic3r_gui ${LIBAVFORMAT_LIBRARY} ${LIBAVCODEC_LIBRARY} ${LIBSWSCALE_LIBRARY} ${LIBAVUTIL_LIBRARY})
+    target_link_libraries(libslic3r_gui ${LIBAVCODEC_LIBRARY} ${LIBSWSCALE_LIBRARY} ${LIBAVUTIL_LIBRARY})
     target_include_directories(libslic3r_gui SYSTEM PRIVATE ${CMAKE_PREFIX_PATH}/include)
 elseif (WIN32)
     # Prebuilt shared FFmpeg from the deps install. Windows has no pkg-config,
     # so resolve the import libraries out of the deps prefix directly; the DLLs
     # are copied next to the executable by the top level CMakeLists.
-    find_library(LIBAVFORMAT_LIBRARY NAMES avformat PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBAVCODEC_LIBRARY NAMES avcodec PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBSWSCALE_LIBRARY NAMES swscale PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBAVUTIL_LIBRARY NAMES avutil PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
-    if (NOT LIBAVFORMAT_LIBRARY OR NOT LIBAVCODEC_LIBRARY OR NOT LIBSWSCALE_LIBRARY OR NOT LIBAVUTIL_LIBRARY)
-        message(FATAL_ERROR "FFmpeg (avformat/avcodec/swscale/avutil) not found under ${CMAKE_PREFIX_PATH}/lib. Rebuild the deps.")
+    if (NOT LIBAVCODEC_LIBRARY OR NOT LIBSWSCALE_LIBRARY OR NOT LIBAVUTIL_LIBRARY)
+        message(FATAL_ERROR "FFmpeg (avcodec/swscale/avutil) not found under ${CMAKE_PREFIX_PATH}/lib. Rebuild the deps.")
     endif ()
-    target_link_libraries(libslic3r_gui ${LIBAVFORMAT_LIBRARY} ${LIBAVCODEC_LIBRARY} ${LIBSWSCALE_LIBRARY} ${LIBAVUTIL_LIBRARY})
+    target_link_libraries(libslic3r_gui ${LIBAVCODEC_LIBRARY} ${LIBSWSCALE_LIBRARY} ${LIBAVUTIL_LIBRARY})
     target_include_directories(libslic3r_gui SYSTEM PRIVATE ${CMAKE_PREFIX_PATH}/include)
 else ()
     pkg_check_modules(LIBAV REQUIRED IMPORTED_TARGET
-        libavformat
         libavcodec
         libswscale
         libavutil

src/slic3r/GUI/AVVideoDecoder.cpp

@@ -45,25 +45,6 @@ int AVVideoDecoder::open(Bambu_StreamInfo const &info)
     return 0;
 }
 
-int AVVideoDecoder::open(AVCodecParameters const &parameters)
-{
-    if (avcodec_parameters_to_context(codec_ctx_, &parameters) < 0)
-        return -1;
-
-    auto codec = avcodec_find_decoder(codec_ctx_->codec_id);
-    if (codec == nullptr) {
-        fprintf(stderr, "AVVideoDecoder: unsupported codec!\n");
-        return -1;
-    }
-    if (avcodec_open2(codec_ctx_, codec, nullptr) < 0) {
-        fprintf(stderr, "AVVideoDecoder: could not open codec\n");
-        return -1;
-    }
-
-    frame_ = av_frame_alloc();
-    return frame_ == nullptr ? -1 : 0;
-}
-
 int AVVideoDecoder::decode(const Bambu_Sample &sample)
 {
     int ret = -1;
@@ -90,14 +71,6 @@ int AVVideoDecoder::decode(const Bambu_Sample &sample)
     return ret;
 }
 
-int AVVideoDecoder::decode(const AVPacket &packet)
-{
-    int ret = avcodec_send_packet(codec_ctx_, &packet);
-    if (ret == 0)
-        got_frame_ = avcodec_receive_frame(codec_ctx_, frame_) == 0;
-    return ret;
-}
-
 int AVVideoDecoder::flush()
 {
     int ret = avcodec_send_packet(codec_ctx_, nullptr);

src/slic3r/GUI/AVVideoDecoder.hpp

@@ -23,10 +23,8 @@ public:
 
 public:
     int  open(Bambu_StreamInfo const &info);
-    int  open(AVCodecParameters const &parameters);
 
     int  decode(Bambu_Sample const &sample);
-    int  decode(AVPacket const &packet);
 
     int  flush();
 
@@ -36,14 +34,6 @@ public:
 
     bool toWxBitmap(wxBitmap &bitmap, wxSize const & size);
 
-    // Native size of the most recently decoded frame, or an unspecified size if
-    // nothing has decoded yet. Lets a caller learn the video dimensions when the
-    // container/probe could not report them up front.
-    wxSize decoded_frame_size() const
-    {
-        return got_frame_ && frame_ ? wxSize{frame_->width, frame_->height} : wxSize{};
-    }
-
 private:
     AVCodecContext *codec_ctx_ = nullptr;
     AVFrame *       frame_     = nullptr;

src/slic3r/GUI/CalibrationPanel.cpp

@@ -328,7 +328,7 @@ void SelectMObjectPopup::update_user_devices()
     }
 
     m_bind_machine_list.clear();
-    m_bind_machine_list = dev->get_my_machine_list(dev->get_current_printer_agent_id());
+    m_bind_machine_list = dev->get_my_machine_list();
 
     //sort list
     std::vector<std::pair<std::string, MachineObject*>> user_machine_list;

src/slic3r/GUI/CalibrationWizardPresetPage.cpp

@@ -6,10 +6,8 @@
 #include "Widgets/Label.hpp"
 #include "MsgDialog.hpp"
 #include "libslic3r/Print.hpp"
-#include "PrePrintChecker.hpp"
 
 #include "DeviceCore/DevConfig.h"
-#include "DeviceCore/DevConfigUtil.h"
 #include "DeviceCore/DevExtruderSystem.h"
 #include "DeviceCore/DevFilaBlackList.h"
 #include "DeviceCore/DevFilaSystem.h"
@@ -1639,6 +1637,29 @@ void CalibrationPresetPage::update_combobox_filaments(MachineObject* obj)
     select_default_compatible_filament();
 }
 
+bool CalibrationPresetPage::is_blocking_printing()
+{
+    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
+    if (!dev) return true;
+
+    MachineObject* obj_ = dev->get_selected_machine();
+    if (obj_ == nullptr) return true;
+
+    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
+    auto source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
+    auto target_model = obj_->printer_type;
+
+    if (source_model != target_model) {
+        std::vector<std::string> compatible_machine = obj_->get_compatible_machine();
+        vector<std::string>::iterator it = find(compatible_machine.begin(), compatible_machine.end(), source_model);
+        if (it == compatible_machine.end()) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 bool CalibrationPresetPage::is_nozzle_info_synced() const
 {
     if (!curr_obj || !curr_obj->is_info_ready())
@@ -1720,13 +1741,11 @@ void CalibrationPresetPage::update_show_status()
         }
     }
 
-    bool has_optional_printer_model = DevPrinterConfigUtil::is_optional_printer_model_id(obj_->printer_type);
-    if (PresetBundle *preset_bundle = wxGetApp().preset_bundle) {
-        has_optional_printer_model = has_optional_printer_model ||
-            DevPrinterConfigUtil::is_optional_printer_model_id(
-                preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle));
-    }
-
+    //if (is_blocking_printing()) {
+    //    show_status(CaliPresetPageStatus::CaliPresetStatusUnsupportedPrinter);
+    //    return;
+    //}
+    //else
     if (obj_->is_connecting() || !obj_->is_connected()) {
         show_status(CaliPresetPageStatus::CaliPresetStatusInConnecting);
         return;
@@ -1778,9 +1797,7 @@ void CalibrationPresetPage::update_show_status()
         return;
     }
 
-    show_status(has_optional_printer_model ?
-        CaliPresetPageStatus::CaliPresetStatusOptionalPrinterModel :
-        CaliPresetPageStatus::CaliPresetStatusNormal);
+    show_status(CaliPresetPageStatus::CaliPresetStatusNormal);
 }
 
 
@@ -1834,10 +1851,6 @@ void CalibrationPresetPage::show_status(CaliPresetPageStatus status)
         Layout();
         Fit();
     }
-    else if (status == CaliPresetPageStatus::CaliPresetStatusOptionalPrinterModel) {
-        update_print_status_msg(PrePrintChecker::get_pre_state_msg(PrintDialogStatus::PrintStatusOptionalPrinterModel), true);
-        Enable_Send_Button(true);
-    }
     else if (status == CaliPresetPageStatus::CaliPresetStatusNoUserLogin) {
         wxString msg_text = _L("No login account, only printers in LAN mode are displayed.");
         update_print_status_msg(msg_text, false);

src/slic3r/GUI/CalibrationWizardPresetPage.hpp

@@ -152,8 +152,7 @@ enum CaliPresetPageStatus
     CaliPresetStatusInConnecting, 
     CaliPresetStatusFilamentIncompatible,
     CaliPresetStatusLanModeSDcardNotAvailable,
-    CaliPresetStatusDifferentNozzleDiameters,
-    CaliPresetStatusOptionalPrinterModel
+    CaliPresetStatusDifferentNozzleDiameters
 };
 
 class CalibrationPresetPage : public CalibrationWizardPage
@@ -269,6 +268,7 @@ protected:
     bool is_nozzle_info_synced() const;
     void show_status(CaliPresetPageStatus status);
     void Enable_Send_Button(bool enable);
+    bool is_blocking_printing();
     bool need_check_sdcard(MachineObject* obj);
     
     CaliPresetPageStatus  get_status() { return m_page_status; }

src/slic3r/GUI/CameraPopup.cpp

@@ -28,6 +28,7 @@ wxEND_EVENT_TABLE()
 
 wxDEFINE_EVENT(EVT_VCAMERA_SWITCH, wxMouseEvent);
 wxDEFINE_EVENT(EVT_SDCARD_ABSENT_HINT, wxCommandEvent);
+wxDEFINE_EVENT(EVT_CAM_SOURCE_CHANGE, wxCommandEvent);
 
 #define CAMERAPOPUP_CLICK_INTERVAL 20
 
@@ -101,6 +102,34 @@ CameraPopup::CameraPopup(wxWindow *parent)
         top_sizer->Add(0, 0, wxALL, 0);
     }
 
+    // Orca: custom IP camera source — lets the user point Live Video at any camera URL (Orca feature; not in the reference)
+    m_custom_camera_input_confirm = new Button(m_panel, _L("Enable"));
+    m_custom_camera_input_confirm->SetBackgroundColor(wxColour(38, 166, 154));
+    m_custom_camera_input_confirm->SetBorderColor(wxColour(38, 166, 154));
+    m_custom_camera_input_confirm->SetTextColor(wxColour(0xFFFFFE));
+    m_custom_camera_input_confirm->SetFont(Label::Body_14);
+    m_custom_camera_input_confirm->SetMinSize(wxSize(FromDIP(90), FromDIP(30)));
+    m_custom_camera_input_confirm->SetPosition(wxDefaultPosition);
+    m_custom_camera_input_confirm->SetCornerRadius(FromDIP(12));
+    m_custom_camera_input = new TextInput(m_panel, wxEmptyString, wxEmptyString, wxEmptyString, wxDefaultPosition, wxDefaultSize);
+    m_custom_camera_input->GetTextCtrl()->SetHint(_L("Hostname or IP"));
+    m_custom_camera_input->GetTextCtrl()->SetFont(Label::Body_14);
+    m_custom_camera_hint = new wxStaticText(m_panel, wxID_ANY, _L("Custom camera source"));
+    m_custom_camera_hint->Wrap(-1);
+    m_custom_camera_hint->SetFont(Label::Head_14);
+    m_custom_camera_hint->SetForegroundColour(TEXT_COL);
+
+    m_custom_camera_input_confirm->Bind(wxEVT_BUTTON, &CameraPopup::on_camera_source_changed, this);
+
+    if (!wxGetApp().app_config->get("camera", "custom_source").empty()) {
+        m_custom_camera_input->GetTextCtrl()->SetValue(wxGetApp().app_config->get("camera", "custom_source"));
+        set_custom_cam_button_state(wxGetApp().app_config->get("camera", "enable_custom_source") == "true");
+    }
+
+    top_sizer->Add(m_custom_camera_hint, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT | wxALL, FromDIP(5));
+    top_sizer->Add(0, 0, wxALL, 0);
+    top_sizer->Add(m_custom_camera_input, 2, wxALIGN_CENTER_VERTICAL | wxEXPAND | wxALL, FromDIP(5));
+    top_sizer->Add(m_custom_camera_input_confirm, 1, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT | wxALL, FromDIP(5));
     main_sizer->Add(top_sizer, 0, wxALL, FromDIP(10));
 
     auto url = wxString(L"https://www.orcaslicer.com/wiki/"); // Orca: neutral wiki link (vendor URL removed)
@@ -155,6 +184,37 @@ void CameraPopup::sdcard_absent_hint()
     GetEventHandler()->ProcessEvent(evt);
 }
 
+void CameraPopup::on_camera_source_changed(wxCommandEvent &event)
+{
+    if (m_obj && !m_custom_camera_input->GetTextCtrl()->IsEmpty()) {
+        handle_camera_source_change();
+    }
+}
+
+void CameraPopup::handle_camera_source_change()
+{
+    m_custom_camera_enabled = !m_custom_camera_enabled;
+
+    set_custom_cam_button_state(m_custom_camera_enabled);
+
+    wxGetApp().app_config->set("camera", "custom_source", m_custom_camera_input->GetTextCtrl()->GetValue().ToStdString());
+    wxGetApp().app_config->set("camera", "enable_custom_source", m_custom_camera_enabled);
+
+    wxCommandEvent evt(EVT_CAM_SOURCE_CHANGE);
+    evt.SetEventObject(this);
+    GetEventHandler()->ProcessEvent(evt);
+}
+
+void CameraPopup::set_custom_cam_button_state(bool state)
+{
+    m_custom_camera_enabled = state;
+    auto stateColour = state ? wxColour(170, 0, 0) : wxColour(38, 166, 154);
+    auto stateText = state ? "Disable" : "Enable";
+    m_custom_camera_input_confirm->SetBackgroundColor(stateColour);
+    m_custom_camera_input_confirm->SetBorderColor(stateColour);
+    m_custom_camera_input_confirm->SetLabel(_L(stateText));
+}
+
 void CameraPopup::on_switch_recording(wxCommandEvent& event)
 {
     if (!m_obj) return;

src/slic3r/GUI/CameraPopup.hpp

@@ -15,12 +15,14 @@
 #include "Widgets/SwitchButton.hpp"
 #include "Widgets/RadioBox.hpp"
 #include "Widgets/PopupWindow.hpp"
+#include "Widgets/TextInput.hpp"
 
 namespace Slic3r {
 namespace GUI {
 
 wxDECLARE_EVENT(EVT_VCAMERA_SWITCH, wxMouseEvent);
 wxDECLARE_EVENT(EVT_SDCARD_ABSENT_HINT, wxCommandEvent);
+wxDECLARE_EVENT(EVT_CAM_SOURCE_CHANGE, wxCommandEvent);
 
 class CameraPopup : public PopupWindow
 {
@@ -51,6 +53,9 @@ protected:
     void on_switch_recording(wxCommandEvent& event);
     void on_set_resolution();
     void sdcard_absent_hint();
+    void on_camera_source_changed(wxCommandEvent& event);
+    void handle_camera_source_change();
+    void set_custom_cam_button_state(bool state);
 
     wxWindow *  create_item_radiobox(wxString title, wxWindow *parent, wxString tooltip, int padding_left);
     void select_curr_radiobox(int btn_idx);
@@ -71,10 +76,10 @@ private:
     wxStaticText* m_text_liveview_retry;
     SwitchButton* m_switch_liveview_retry;
 #endif //BBL_RELEASE_TO_PUBLIC
-    // wxStaticText* m_custom_camera_hint;
-    // TextInput* m_custom_camera_input;
-    // Button* m_custom_camera_input_confirm;
-    // bool m_custom_camera_enabled{ false };
+    wxStaticText* m_custom_camera_hint;
+    TextInput* m_custom_camera_input;
+    Button* m_custom_camera_input_confirm;
+    bool m_custom_camera_enabled{ false };
     wxStaticText* m_text_resolution;
     wxWindow* m_resolution_options[RESOLUTION_OPTIONS_NUM];
     wxScrolledWindow *m_panel;

src/slic3r/GUI/ConnectPrinter.cpp

@@ -35,9 +35,7 @@ ConnectPrinterDialog::ConnectPrinterDialog(wxWindow *parent, wxWindowID id, cons
     sizer_connect = new wxBoxSizer(wxHORIZONTAL);
 
     m_textCtrl_code = new TextInput(this, wxEmptyString);
-    // OrcaSonar uses a 12-character base32 access code. Keep this field long
-    // enough for it while retaining the existing validation for LAN codes.
-    m_textCtrl_code->GetTextCtrl()->SetMaxLength(12);
+    m_textCtrl_code->GetTextCtrl()->SetMaxLength(10);
     m_textCtrl_code->SetFont(Label::Body_14);
     m_textCtrl_code->SetCornerRadius(FromDIP(5));
     m_textCtrl_code->SetSize(wxSize(FromDIP(330), FromDIP(40)));

src/slic3r/GUI/DeviceCore/DevConfigUtil.cpp

@@ -1,7 +1,5 @@
 #include "DevConfigUtil.h"
 
-#include "slic3r/GUI/DeviceManager.hpp"
-
 #include <wx/dir.h>
 #include <boost/filesystem/operations.hpp>
 #include "../I18N.hpp"
@@ -43,19 +41,6 @@ static void _toolhead_translation_markers()
 
 std::string DevPrinterConfigUtil::m_resource_file_path = "";
 
-bool DevPrinterConfigUtil::is_printer_model_compatible(const std::string& source_model, MachineObject& machine)
-{
-    const std::string& target_model = machine.printer_type;
-    if (is_optional_printer_model_id(source_model) || is_optional_printer_model_id(target_model))
-        return true;
-
-    if (source_model == target_model)
-        return true;
-
-    const auto compatible_machine = machine.get_compatible_machine();
-    return std::find(compatible_machine.begin(), compatible_machine.end(), source_model) != compatible_machine.end();
-}
-
 
 std::map<std::string, std::string> DevPrinterConfigUtil::get_all_model_id_with_name()
 {
@@ -420,4 +405,4 @@ std::string DevPrinterConfigUtil::get_toolhead_display_name(
     return result;
 }
 
-};
+};

src/slic3r/GUI/DeviceCore/DevConfigUtil.h

@@ -25,8 +25,6 @@
 namespace Slic3r
 {
 
-class MachineObject;
-
 /// Toolhead component type (extruder / nozzle / hotend)
 enum class ToolHeadComponent {
     Extruder,
@@ -61,10 +59,6 @@ public:
     /*printer*/
     // info
     static std::map<std::string, std::string> get_all_model_id_with_name();
-    // A printer agent may not know the physical model. Keep that case optional so
-    // model compatibility checks do not turn missing identity into a hard error.
-    static bool is_printer_model_compatible(const std::string& source_model, MachineObject& machine);
-    static bool is_optional_printer_model_id(const std::string& model_id) { return model_id.empty(); }
     static std::string get_printer_type(const std::string& type_str) { return get_value_from_config<std::string>(type_str, "printer_type"); }
     static std::string get_printer_display_name(const std::string& type_str) { return get_value_from_config<std::string>(type_str, "display_name"); }
     static std::string get_printer_series_str(std::string type_str) { return get_value_from_config<std::string>(type_str, "printer_series"); }
@@ -233,4 +227,4 @@ static std::string _parse_printer_type(const std::string &type_str)
     return type_str;
 }
 
-};// namespace Slic3r
+};// namespace Slic3r

src/slic3r/GUI/DeviceCore/DevFilaSystem.cpp

@@ -762,9 +762,9 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                             {
                                 curr_tray->remain = -1;
                             }
-                            // The tray objects are reused across status updates. Reset this
-                            // state when a previously empty slot receives a filament again.
-                            curr_tray->is_slot_placeholder = tray_it->contains("tray_slot_placeholder");
+                            if (tray_it->contains("tray_slot_placeholder")) {
+                                curr_tray->is_slot_placeholder = true;
+                            }
                             int ams_id_int = 0;
                             int tray_id_int = 0;
                             try
@@ -999,4 +999,4 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
     }
 }
 
-}
+}

src/slic3r/GUI/DeviceCore/DevManager.cpp

@@ -1,10 +1,8 @@
-#include "DevManager.h"
 #include <nlohmann/json.hpp>
 
 #include <exception>
 
-#include <libslic3r/AppConfig.hpp>
-#include "CloudProvider.hpp"
+#include "DevManager.h"
 #include "DevUtil.h"
 
 // TODO: remove this include
@@ -17,8 +15,6 @@
 
 #include "libslic3r/Time.hpp"
 
-#include "IPrinterAgent.hpp"
-
 using namespace nlohmann;
 
 namespace {
@@ -50,12 +46,10 @@ namespace {
 
 namespace Slic3r
 {
-    DeviceManager::DeviceManager(NetworkAgent* agent, bool enable_refresher, AppConfig* app_config)
+    DeviceManager::DeviceManager(NetworkAgent* agent)
     {
-        m_agent      = agent;
-        m_app_config = app_config;
-        if (enable_refresher)
-            m_refresher = new DeviceManagerRefresher(this);
+        m_agent = agent;
+        m_refresher = new DeviceManagerRefresher(this);
 
         DevPrinterConfigUtil::InitFilePath(resources_dir());
 
@@ -66,14 +60,9 @@ namespace Slic3r
         }
     }
 
-    AppConfig* DeviceManager::get_app_config() const
-    {
-        return m_app_config ? m_app_config : GUI::wxGetApp().app_config;
-    }
-
     void DeviceManager::load_local_machines_from_config()
     {
-        AppConfig* config = get_app_config();
+        AppConfig* config = GUI::wxGetApp().app_config;
         if (!config)
             return;
         const auto local_machines = config->get_local_machines();
@@ -99,8 +88,9 @@ namespace Slic3r
         }
     }
 
-    void DeviceManager::update_local_machine(const MachineObject& m, AppConfig* config)
+    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()) {
@@ -121,8 +111,7 @@ namespace Slic3r
 
     DeviceManager::~DeviceManager()
     {
-        if (m_refresher)
-            delete m_refresher;
+        delete m_refresher;
 
         for (auto it = localMachineList.begin(); it != localMachineList.end(); it++)
         {
@@ -182,22 +171,14 @@ namespace Slic3r
         return printer_agent ? printer_agent->get_agent_info().id : "";
     }
 
-    std::string DeviceManager::get_current_cloud_provider() const
-    {
-        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();
-    }
-
     void DeviceManager::EnableMultiMachine(bool enable)
     {
         m_agent->enable_multi_machine(enable);
         m_enable_mutil_machine = enable;
     }
 
-    void DeviceManager::start_refresher() { if (m_refresher) m_refresher->Start(); }
-    void DeviceManager::stop_refresher() { if (m_refresher) m_refresher->Stop(); }
+    void DeviceManager::start_refresher() { m_refresher->Start(); }
+    void DeviceManager::stop_refresher() { m_refresher->Stop(); }
 
 
     void DeviceManager::keep_alive()
@@ -284,10 +265,6 @@ namespace Slic3r
             /* 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 ||
@@ -314,15 +291,10 @@ namespace Slic3r
 
             /* 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() ) {
@@ -412,6 +384,7 @@ namespace Slic3r
                 obj->m_is_online = true;
 
                 //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, obj->printer_agent_id), false);
                 }
@@ -434,7 +407,7 @@ namespace Slic3r
                     fire_lifecycle_event(LifecycleEvent::DeviceDiscovered, ctx);
                 }
             }
-            update_local_machine(*obj, config);
+            update_local_machine(*obj);
         }
         catch (...) {
             ;
@@ -449,9 +422,6 @@ namespace Slic3r
         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();
@@ -469,16 +439,11 @@ namespace Slic3r
         obj->last_alive = Slic3r::Utils::get_current_time_utc();
         obj->set_access_code(access_code, false);
 
-        update_local_machine(*obj, get_app_config());
+        update_local_machine(*obj);
 
         return obj;
     }
 
-    void DeviceManager::update_local_machine(const MachineObject& m)
-    {
-        update_local_machine(m, GUI::wxGetApp().app_config);
-    }
-
     int DeviceManager::query_bind_status(std::string& msg, const std::string& provider)
     {
         if (!m_agent)
@@ -549,7 +514,7 @@ namespace Slic3r
 
     MachineObject* DeviceManager::get_my_machine(std::string dev_id)
     {
-        auto list = get_my_machine_list(get_current_printer_agent_id());
+        auto list = get_my_machine_list();
         auto it = list.find(dev_id);
         if (it != list.end())
         {
@@ -586,15 +551,25 @@ namespace Slic3r
         OnSelectedMachineChanged(previous_selected_machine, selected_machine);
     }
 
-    void DeviceManager::clear_other_devices()
+    void DeviceManager::clear_other_devices(const std::string& target_agent_id)
     {
-        // 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.
+        // 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 (!it->second || it->second->printer_agent_id.empty())
+            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)
             {
                 delete it->second;
                 it = localMachineList.erase(it);
@@ -610,22 +585,8 @@ namespace Slic3r
     {
         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 my_machine_list = get_my_machine_list();
         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);
@@ -636,9 +597,7 @@ namespace Slic3r
                 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;
+                m_agent->set_user_selected_machine("");
             }
         }
 
@@ -673,7 +632,11 @@ namespace Slic3r
                         m_agent->disconnect_printer();
                         it->second->reset();
 
-                        it->second->connect();
+#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);
                     }
                 }
@@ -686,16 +649,18 @@ namespace Slic3r
                     {
                         // 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;
+                        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();
-                        it->second->connect();
+#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);
                     }
                 }
@@ -712,8 +677,6 @@ namespace Slic3r
 
         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;
     }
 
@@ -744,9 +707,7 @@ namespace Slic3r
             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;
+        m_agent->add_subscribe(dev_list);
     }
 
 
@@ -759,9 +720,7 @@ namespace Slic3r
             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;
+        m_agent->del_subscribe(dev_list);
     }
 
     void DeviceManager::subscribe_device_list(std::vector<std::string> dev_list)
@@ -880,24 +839,7 @@ namespace Slic3r
         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;
-            }
+            const std::string provider = GUI::wxGetApp().get_printer_cloud_provider();
 
 #if !BBL_RELEASE_TO_PUBLIC
             BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": " << j;
@@ -920,14 +862,11 @@ namespace Slic3r
                         /* 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;
+                        obj->printer_agent_id = get_current_printer_agent_id();
                         if (m_agent)
                         {
                             obj->set_bind_status(m_agent->get_user_name(provider));
@@ -935,20 +874,13 @@ namespace Slic3r
 
                         if (obj->get_dev_ip().empty())
                         {
-                            if (AppConfig* config = get_app_config())
-                                obj->get_dev_ip() = config->get("ip_address", dev_id);
+                            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;
 
-                    // 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())
@@ -980,12 +912,6 @@ namespace Slic3r
                         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
@@ -1001,9 +927,6 @@ namespace Slic3r
                         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)
@@ -1020,29 +943,25 @@ namespace Slic3r
         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); });
         }
     }
 
     void DeviceManager::record_user_last_machine(const std::string& dev_id)
     {
-        if (AppConfig* config = get_app_config()) {
-            config->set("user_last_selected_machine", dev_id);
+        if (Slic3r::GUI::wxGetApp().app_config) {
+            Slic3r::GUI::wxGetApp().app_config->set("user_last_selected_machine", dev_id);
         }
     }
 
     std::string DeviceManager::get_user_last_machine() const
     {
-        if (AppConfig* config = get_app_config()) {
-            const auto& user_last_machine = config->get("user_last_selected_machine");
+        if (Slic3r::GUI::wxGetApp().app_config) {
+            const auto& user_last_machine = Slic3r::GUI::wxGetApp().app_config->get("user_last_selected_machine");
             if (!user_last_machine.empty()) {
                 return user_last_machine;
             } else if (m_agent) {

src/slic3r/GUI/DeviceCore/DevManager.h

@@ -12,7 +12,6 @@ namespace Slic3r
 struct BBLocalMachine;
 class MachineObject;
 class NetworkAgent;
-class AppConfig;
 
 namespace GUI {
 class GUI_App;
@@ -25,7 +24,6 @@ class DeviceManager
     friend class DeviceManagerRefresher;
 private:
     NetworkAgent* m_agent{ nullptr };
-    AppConfig* m_app_config{ nullptr };
     DeviceManagerRefresher* m_refresher{ nullptr };
 
     bool m_enable_mutil_machine = false;
@@ -37,13 +35,11 @@ private:
     std::map<std::string, MachineObject*> userMachineList;      /* dev_id -> MachineObject*  cloudMachine of User */
 
 public:
-    DeviceManager(NetworkAgent* agent = nullptr, bool enable_refresher = true,
-                  AppConfig* app_config = nullptr);
+    DeviceManager(NetworkAgent* agent = nullptr);
     ~DeviceManager();
 
 public:
     NetworkAgent* get_agent() const { return m_agent; }
-    AppConfig* get_app_config() const;
     void set_agent(NetworkAgent* agent);
 
     void start_refresher();
@@ -78,9 +74,10 @@ public:
     void erase_user_machine(std::string dev_id) { userMachineList.erase(dev_id); }
     void clean_user_info(bool keep_local_selection = false);
 
-    // Retain agent-owned LAN discoveries across a switch; the active-agent list filter keeps
-    // entries from other agents hidden while allowing them to reappear when switched back.
-    void clear_other_devices();
+    // target_agent_id: id of the agent being swapped to (empty = no agent-mismatch check,
+    // just the original "drop Other Devices" behavior). Pass the incoming agent's id, not the
+    // live one - this runs before the live agent is repointed.
+    void clear_other_devices(const std::string& target_agent_id = "");
 
     void load_last_machine();
     void update_user_machine_list_info(const std::string& provider);
@@ -125,7 +122,6 @@ private:
 
     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);
@@ -138,15 +134,14 @@ public:
         std::string connection_type, std::string bind_state, std::string version,
         std::string access_code);
     static void update_local_machine(const MachineObject& m);
-    static void update_local_machine(const MachineObject& m, AppConfig* config);
 };
 
 class DeviceManagerRefresher : public wxObject
 {
-    wxTimer* m_timer{nullptr};
-    int m_timer_interval_msec = 5000;
+    wxTimer* m_timer{ nullptr };
+    int            m_timer_interval_msec = 5000;
 
-    DeviceManager* m_manager{nullptr};
+    DeviceManager* m_manager{ nullptr };
 
 public:
     DeviceManagerRefresher(DeviceManager* manger);
@@ -159,4 +154,4 @@ public:
 protected:
     virtual void on_timer(wxTimerEvent& event);
 };
-};
+};

src/slic3r/GUI/DeviceManager.cpp

@@ -4,7 +4,6 @@
 #include "I18N.hpp"
 #include "libslic3r/Time.hpp"
 #include "libslic3r/Thread.hpp"
-#include "slic3r/Utils/Http.hpp"
 #include "slic3r/Utils/NetworkAgent.hpp"
 #include "slic3r/plugin/PluginManager.hpp"
 #include "slic3r/Utils/NetworkAgentFactory.hpp"
@@ -18,7 +17,6 @@
 #include "ReleaseNote.hpp"
 #include <thread>
 #include <mutex>
-#include <charconv>
 #include <codecvt>
 #include <boost/foreach.hpp>
 #include <boost/typeof/typeof.hpp>
@@ -56,7 +54,6 @@
 #include "DeviceCore/DevStatus.h"
 #include "DeviceCore/DevUpgrade.h"
 
-#include "IPrinterAgent.hpp"
 
 #define CALI_DEBUG
 #define MINUTE_30 1800000    //ms
@@ -383,22 +380,8 @@ NozzleVolumeType convert_to_nozzle_type(const std::string &str)
 wxString MachineObject::get_printer_type_display_str() const
 {
     std::string display_name = DevPrinterConfigUtil::get_printer_display_name(printer_type);
-
-    // Bambu printers use m_resource_file_path + "/printers/" + type_str + ".json", which is a semantic that only works for their profiles.
-    // For any other profile, we can simply consult preset bundle if the model_id exists. 
-    if (display_name.empty()) {
-        for (const auto& [vendor_id, vendor] : GUI::wxGetApp().preset_bundle->vendors) {
-            for (const auto& model : vendor.models) {
-                if (printer_type == model.model_id)
-                    display_name = model.name;
-            }
-        }
-    }
-
     if (!display_name.empty())
         return display_name;
-    else if (printer_type == "orcasonar")
-        return "OrcaSonar Printer";
     else
         return _L("Unknown");
 }
@@ -485,7 +468,7 @@ void MachineObject::set_access_code(std::string code, bool only_refresh)
 {
     this->access_code = code;
     if (only_refresh) {
-        AppConfig* config = m_manager ? m_manager->get_app_config() : GUI::wxGetApp().app_config;
+        AppConfig* config = GUI::wxGetApp().app_config;
         if (config) {
             if (is_lan_mode_printer()) {
                 // why: LAN codes are scoped via BBLocalMachine::access_code, keyed by dev_id and
@@ -498,7 +481,7 @@ void MachineObject::set_access_code(std::string code, bool only_refresh)
                 // fresh from the cloud API's current response, so there's no cross-agent leakage
                 // risk to guard against there.
                 if (!code.empty()) {
-                    DeviceManager::update_local_machine(*this, config);
+                    DeviceManager::update_local_machine(*this);
                 } else {
                     // Only patch an existing record's code - don't persist a brand-new
                     // never-bound entry just because set_access_code("") was called on it.
@@ -1365,6 +1348,7 @@ int MachineObject::command_get_access_code() {
     return this->publish_json(j);
 }
 
+
 int MachineObject::command_request_push_all(bool request_now)
 {
     auto curr_time = std::chrono::system_clock::now();
@@ -1496,20 +1480,26 @@ int MachineObject::command_upgrade_module(std::string url, std::string module_ty
 
 int MachineObject::command_xyz_abs()
 {
-    if (!m_agent) return -1;
-    return command_with_dialog(m_agent->command_xyz_abs(get_dev_id(), MachineObject::m_sequence_id++, is_lan_mode_printer()));
+    return this->publish_gcode("G90 \n");
 }
 
 int MachineObject::command_auto_leveling()
 {
-    if (!m_agent) return -1;
-    return command_with_dialog(m_agent->command_auto_leveling(get_dev_id(), MachineObject::m_sequence_id++, is_lan_mode_printer()));
+    return this->publish_gcode("G29 \n");
 }
 
 int MachineObject::command_go_home()
 {
-    if (!m_agent) return -1;
-    return command_with_dialog(m_agent->command_go_home(get_dev_id(), this->is_in_printing(), m_support_mqtt_homing, MachineObject::m_sequence_id++, is_lan_mode_printer()));
+    if (m_support_mqtt_homing)
+    {
+        json j;
+        j["print"]["command"] = "back_to_center";
+        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
+        return this->publish_json(j);
+    }
+
+    // gcode command
+    return this->is_in_printing() ? this->publish_gcode("G28 X\n") : this->publish_gcode("G28 \n");
 }
 
 int MachineObject::command_task_partskip(std::vector<int> part_ids)
@@ -1631,14 +1621,23 @@ int MachineObject::command_stop_buzzer()
 
 int MachineObject::command_set_bed(int temp)
 {
-    if (!m_agent) return -1;
-    return command_with_dialog(m_agent->command_set_bed(get_dev_id(), temp, m_support_mqtt_bet_ctrl, MachineObject::m_sequence_id++, is_lan_mode_printer()));
+    if (m_support_mqtt_bet_ctrl)
+    {
+        json j;
+        j["print"]["command"] = "set_bed_temp";
+        j["print"]["temp"] = temp;
+        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
+        return this->publish_json(j);
+    }
+
+    std::string gcode_str = (boost::format("M140 S%1%\n") % temp).str();
+    return this->publish_gcode(gcode_str);
 }
 
 int MachineObject::command_set_nozzle(int temp)
 {
-    if (!m_agent) return -1;
-    return command_with_dialog(m_agent->command_set_nozzle(get_dev_id(), temp, MachineObject::m_sequence_id++, is_lan_mode_printer()));
+    std::string gcode_str = (boost::format("M104 S%1%\n") % temp).str();
+    return this->publish_gcode(gcode_str);
 }
 
 int MachineObject::command_set_nozzle_new(int nozzle_id, int temp)
@@ -1743,8 +1742,9 @@ int MachineObject::command_ams_user_settings(bool start_read_opt, bool tray_read
 
 int MachineObject::command_ams_calibrate(int ams_id)
 {
-    if (!m_agent) return -1;
-    return command_with_dialog(m_agent->command_ams_calibrate(get_dev_id(), ams_id, MachineObject::m_sequence_id++, is_lan_mode_printer()));
+    std::string gcode_cmd = (boost::format("M620 C%1% \n") % ams_id).str();
+    BOOST_LOG_TRIVIAL(trace) << "ams_debug: gcode_cmd" << gcode_cmd;
+    return this->publish_gcode(gcode_cmd);
 }
 
 int MachineObject::command_ams_filament_settings(int ams_id, int slot_id, std::string filament_id, std::string setting_id, std::string tray_color, std::string tray_type, int nozzle_temp_min, int nozzle_temp_max)
@@ -1780,23 +1780,29 @@ int MachineObject::command_ams_filament_settings(int ams_id, int slot_id, std::s
     return this->publish_json(j);
 }
 
-int MachineObject::command_ams_refresh_rfid(int ams_id, int slot_id)
+int MachineObject::command_ams_refresh_rfid(std::string tray_id)
 {
-    if (!m_agent) return -1;
-    return command_with_dialog(m_agent->command_ams_refresh_rfid(get_dev_id(), ams_id, slot_id, MachineObject::m_sequence_id++, is_lan_mode_printer()));
+    std::string gcode_cmd = (boost::format("M620 R%1% \n") % tray_id).str();
+    BOOST_LOG_TRIVIAL(trace) << "ams_debug: gcode_cmd" << gcode_cmd;
+    return this->publish_gcode(gcode_cmd);
 }
 
-int MachineObject::command_start_camera()
+int MachineObject::command_ams_refresh_rfid2(int ams_id,  int slot_id)
 {
-    if (!m_agent) return -1;
-    return m_agent->command_start_camera(get_dev_id());
+    json j;
+    j["print"]["command"]       = "ams_get_rfid";
+    j["print"]["sequence_id"]   = std::to_string(MachineObject::m_sequence_id++);
+    j["print"]["ams_id"]        = ams_id;
+    j["print"]["slot_id"]       = slot_id;
+    return this->publish_json(j);
 }
 
 
 int MachineObject::command_ams_select_tray(std::string tray_id)
 {
-    if (!m_agent) return -1;
-    return command_with_dialog(m_agent->command_ams_select_tray(get_dev_id(), tray_id, MachineObject::m_sequence_id++, is_lan_mode_printer()));
+    std::string gcode_cmd = (boost::format("M620 P%1% \n") % tray_id).str();
+    BOOST_LOG_TRIVIAL(trace) << "ams_debug: gcode_cmd" << gcode_cmd;
+    return this->publish_gcode(gcode_cmd);
 }
 
 int MachineObject::command_ams_control(std::string action)
@@ -1955,10 +1961,47 @@ int MachineObject::command_ams_air_print_detect(bool air_print_detect)
 
 int MachineObject::command_axis_control(std::string axis, double unit, double input_val, int speed)
 {
-    if (!m_agent) return -1;
-    return command_with_dialog(m_agent->command_axis_control(get_dev_id(), axis, unit, input_val, speed, is_core_xy(),
-                                                             m_support_mqtt_axis_control, MachineObject::m_sequence_id++,
-                                                             is_lan_mode_printer()));
+    if (m_support_mqtt_axis_control)
+    {
+        int dir = input_val > 0 ? 1 : -1;
+        // i3-arch printers move the bed for Y/Z, so the on-screen direction is
+        // reversed — same negation the g-code fallback below applies.
+        if (!is_core_xy() && (axis.compare("Y") == 0 || axis.compare("Z") == 0)) {
+            dir = -dir;
+        }
+
+        json j;
+        j["print"]["command"] = "xyz_ctrl";
+        j["print"]["axis"] = axis;
+        j["print"]["dir"] = dir;
+        j["print"]["mode"] = (std::abs(input_val) >= 10) ? 1 : 0;
+        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
+        return this->publish_json(j);
+    }
+
+    double value = input_val;
+    if (!is_core_xy()) {
+        if ( axis.compare("Y") == 0
+            || axis.compare("Z")  == 0) {
+            value = -1.0 * input_val;
+        }
+    }
+
+    char cmd[256];
+    if (axis.compare("X") == 0
+        || axis.compare("Y") == 0
+        || axis.compare("Z") == 0) {
+        sprintf(cmd, "M211 S \nM211 X1 Y1 Z1\nM1002 push_ref_mode\nG91 \nG1 %s%0.1f F%d\nM1002 pop_ref_mode\nM211 R\n", axis.c_str(), value * unit, speed);
+    }
+    else if (axis.compare("E") == 0) {
+        sprintf(cmd, "M83 \nG0 %s%0.1f F%d\n", axis.c_str(), value * unit, speed);
+    }
+    else {
+        return -1;
+    }
+
+
+    return this->publish_gcode(cmd);
 }
 
 int MachineObject::command_extruder_control(int nozzle_id, double val)
@@ -2583,12 +2626,7 @@ void MachineObject::reset()
             vt_slot.erase(vt_slot.begin() + 1);
         }
     }
-    // why: reset reuses MachineObject, so release its lazy subtask
-    // before dropping the pointer to prevent reconnect leaks.
-    if (subtask_) {
-        delete subtask_;
-        subtask_ = nullptr;
-    }
+    subtask_ = nullptr;
     has_extra_flow_type = false;
     m_partskip_ids.clear();
 }
@@ -2606,63 +2644,15 @@ void MachineObject::set_print_state(std::string status)
     }
 }
 
-// why: printer agents can report progress without BBL cloud task identity.
-void MachineObject::update_print_progress(const json& value)
-{
-    if (value.is_string()) {
-        const std::string progress = value.get<std::string>();
-        int              parsed_progress;
-        const auto       result = std::from_chars(progress.data(), progress.data() + progress.size(), parsed_progress);
-        if (result.ec != std::errc{} || result.ptr != progress.data() + progress.size())
-            return;
-        mc_print_percent = parsed_progress;
-    } else if (value.is_number_integer())
-        mc_print_percent = value.get<int>();
-    else
-        return;
-
-    if (BBLSubTask* curr_task = get_subtask())
-        curr_task->task_progress = mc_print_percent;
-}
-
-int MachineObject::connect()
+int MachineObject::connect(bool use_openssl)
 {
     if (get_dev_ip().empty()) return -1;
-    std::string username = m_agent ? m_agent->default_lan_username() : std::string();
+    std::string username = "bblp";
     std::string password = get_access_code();
 
-    std::string port;
-    std::string input = get_dev_ip();
-
-    const bool use_ssl = input.rfind("https", 0) == 0;
-
-    // This strips out the http/https prefix
-    std::string host = Http::get_host_from_url(input, &port);
-    std::string ca_file;
-
-    if (GUI::wxGetApp().preset_bundle) {
-        const auto& config = GUI::wxGetApp().preset_bundle->printers.get_edited_preset().config;
-        if (port.empty())
-            port = config.opt_string("printhost_port");
-        ca_file = config.opt_string("printhost_cafile");
-    }
-
-    if (host.empty())
-        host = get_dev_ip();
-
-
     if (m_agent) {
         try {
-            PrinterConnectionParams params{
-                get_dev_id(),
-                host,
-                port,
-                username,
-                password,
-                use_ssl,
-                ca_file
-            };
-            return m_agent->connect_printer(params);
+            return m_agent->connect_printer(get_dev_id(), get_dev_ip(), username, password, use_openssl);
         } catch (...) {
             ;
         }
@@ -2778,14 +2768,6 @@ int MachineObject::publish_json(const json& json_item, int qos, int flag)
         BOOST_LOG_TRIVIAL(error) << "publish_json: " << json_item.dump() << " code: " << rtn;
     }
 
-    // why: the agent is the only thing that knows what it can translate, so it reports
-    // not-supported in its return value and this - the single funnel every command_* builder
-    // passes through - is the one place that turns it into something the user sees. No list of
-    // unsupported commands is needed anywhere: an agent that has no case for a command says so.
-    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE) {
-        show_unsupported_dlg(rtn);
-    }
-
     return rtn;
 }
 
@@ -3104,13 +3086,6 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
             }
         } catch (...) {}
 
-        try {
-            if (j.contains("info"))
-                parse_new_info2(j["info"]);
-        } catch (...) {
-            BOOST_LOG_TRIVIAL(error) << "parse_json: failed to parse OrcaSonar capability info";
-        }
-
         try {
             if (auto ptr = m_fila_system->GetAmsFirmwareSwitch().lock()) {
                 ptr->ParseFirmwareSwitch(j);
@@ -3363,7 +3338,10 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                         print_type = jj["print_type"].get<std::string>();
                     }
                     if (jj.contains("mc_percent")) {
-                        update_print_progress(jj["mc_percent"]);
+                        if (jj["mc_percent"].is_string())
+                            mc_print_percent = stoi(j["print"]["mc_percent"].get<std::string>());
+                        else if (jj["mc_percent"].is_number_integer())
+                            mc_print_percent = j["print"]["mc_percent"].get<int>();
                     }
                     if (jj.contains("mc_print_sub_stage")) {
                         if (jj["mc_print_sub_stage"].is_number_integer())
@@ -3533,9 +3511,6 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                             this->task_id_ = jj["task_id"].get<std::string>();
                         }
 
-                        if (jj.contains("thumbnail_url") && jj["thumbnail_url"].is_string())
-                            m_agent_thumbnail_url = jj["thumbnail_url"].get<std::string>();
-
                         if (jj.contains("job_attr")) {
                             int jobAttr = jj["job_attr"].get<int>();
                             jobState_ =  get_flag_bits(jobAttr, 4, 4);
@@ -3581,6 +3556,7 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                         update_slice_info(jj["project_id"].get<std::string>(), jj["profile_id"].get<std::string>(), jj["subtask_id"].get<std::string>(), plate_index);
                         BBLSubTask* curr_task = get_subtask();
                         if (curr_task) {
+                            curr_task->task_progress = mc_print_percent;
                             curr_task->printing_status = print_status;
                             curr_task->task_id = jj["subtask_id"].get<std::string>();
                         }
@@ -3883,7 +3859,6 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                                         has_ipcam = true;
                                     } else {
                                         has_ipcam = false;
-                                        webcam_stream_url.clear();
                                     }
                                 }
                                 if (ipcam.contains("resolution")) {
@@ -3918,9 +3893,6 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                                     liveview_local = local_rtsp_url.empty() ? LVL_None : local_rtsp_url == "disable"
                                             ? LVL_Disable : boost::algorithm::starts_with(local_rtsp_url, "rtsps") ? LVL_Rtsps : LVL_Rtsp;
                                 }
-                                if (ipcam.contains("stream_url") && ipcam["stream_url"].is_string()) {
-                                    webcam_stream_url = ipcam["stream_url"].get<std::string>();
-                                }
                                 if (ipcam.contains("tutk_server")) {
                                     tutk_state = ipcam["tutk_server"].get<std::string>();
                                 }
@@ -4679,7 +4651,7 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
     if (diff.count() > 10.0f) {
         BOOST_LOG_TRIVIAL(trace) << "parse_json timeout = " << diff.count();
     }
-    DeviceManager::update_local_machine(*this, m_manager ? m_manager->get_app_config() : GUI::wxGetApp().app_config);
+    DeviceManager::update_local_machine(*this);
 
     return 0;
 }
@@ -5488,86 +5460,6 @@ void MachineObject::parse_new_info(json print)
     }
 }
 
-void MachineObject::parse_new_info2(const json& info)
-{
-    if (!info.is_object() || info.value("command", "") != "get_capabilities")
-        return;
-
-    const auto capabilities_it = info.find("capabilities");
-    if (capabilities_it == info.end() || !capabilities_it->is_object())
-        return;
-    const auto flags_it = capabilities_it->find("flags");
-    if (flags_it == capabilities_it->end() || !flags_it->is_object())
-        return;
-
-    const json& flags = *flags_it;
-    BOOST_LOG_TRIVIAL(info) << "parse_new_info2: OrcaSonar capability flags=" << flags.dump();
-
-    auto parse_bool = [&flags](const char* name, bool& target) {
-        const auto it = flags.find(name);
-        if (it != flags.end() && it->is_boolean())
-            target = it->get<bool>();
-    };
-
-    parse_bool("support_send_to_sd", is_support_send_to_sdcard);
-    parse_bool("support_filament_backup", is_support_filament_backup);
-    parse_bool("support_update_remain", is_support_update_remain);
-    parse_bool("support_auto_recovery_step_loss", is_support_auto_recovery_step_loss);
-    parse_bool("support_ams_humidity", is_support_ams_humidity);
-    parse_bool("support_prompt_sound", is_support_prompt_sound);
-    parse_bool("support_filament_tangle_detect", is_support_filament_tangle_detect);
-    parse_bool("support_1080dpi", is_support_1080dpi);
-    parse_bool("support_cloud_print_only", is_support_cloud_print_only);
-    parse_bool("support_command_ams_switch", is_support_command_ams_switch);
-    parse_bool("support_mqtt_alive", is_support_mqtt_alive);
-    parse_bool("support_motor_noise_cali", is_support_motor_noise_cali);
-    parse_bool("support_timelapse", is_support_timelapse);
-    parse_bool("support_user_preset", is_support_user_preset);
-    parse_bool("support_refresh_nozzle", is_support_refresh_nozzle);
-    parse_bool("support_flow_calibration", is_support_flow_calibration);
-    parse_bool("support_build_plate_marker_detect", is_support_build_plate_marker_detect);
-    parse_bool("support_nozzle_blob_detect", is_support_nozzle_blob_detection);
-
-    if (!m_manager->IsMultiMachineEnabled() && !is_support_agora)
-        parse_bool("support_tunnel_mqtt", is_support_tunnel_mqtt);
-
-    const auto bed_leveling_it = flags.find("support_bed_leveling");
-    if (bed_leveling_it != flags.end() && bed_leveling_it->is_number_integer())
-        is_support_bed_leveling = bed_leveling_it->get<int>();
-
-    auto copy_bool = [&flags](json& target, const char* name) {
-        const auto it = flags.find(name);
-        if (it != flags.end() && it->is_boolean())
-            target[name] = *it;
-    };
-
-    // The capability manifest uses an object for this range, while the legacy
-    // DeviceCore parser consumes a boolean plus a two-element range array.
-    json device_config;
-    copy_bool(device_config, "support_chamber");
-    copy_bool(device_config, "support_first_layer_inspect");
-    copy_bool(device_config, "support_ai_monitoring");
-    copy_bool(device_config, "support_lidar_calibration");
-    const auto chamber_edit_it = flags.find("support_chamber_temp_edit");
-    if (chamber_edit_it != flags.end() && chamber_edit_it->is_boolean()) {
-        device_config["support_chamber_temp_edit"] = *chamber_edit_it;
-    } else if (chamber_edit_it != flags.end() && chamber_edit_it->is_object()) {
-        const auto min_it = chamber_edit_it->find("min");
-        const auto max_it = chamber_edit_it->find("max");
-        if (min_it != chamber_edit_it->end() && max_it != chamber_edit_it->end() && min_it->is_number() && max_it->is_number()) {
-            device_config["support_chamber_temp_edit"]       = true;
-            device_config["support_chamber_temp_edit_range"] = {*min_it, *max_it};
-        }
-    }
-
-    json fan_config;
-    copy_bool(fan_config, "support_aux_fan");
-    copy_bool(fan_config, "support_chamber_fan");
-
-    m_config->ParseConfig(device_config);
-    m_fan->ParseV2_0(fan_config);
-}
-
 static bool is_hex_digit(char c) {
     return std::isxdigit(static_cast<unsigned char>(c)) != 0;
 }
@@ -6073,15 +5965,6 @@ bool MachineObject::HasAms() const
     return m_fila_system->HasAms();
 }
 
-int MachineObject::command_with_dialog(int cmd_result)
-{
-    if (!m_agent)
-        return -1;
-    if (cmd_result == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || cmd_result == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
-        show_unsupported_dlg(cmd_result);
-    return cmd_result;
-}
-
 void change_the_opacity(wxColour& colour)
 {
     if (colour.Alpha() == 255) {

src/slic3r/GUI/DeviceManager.hpp

@@ -18,7 +18,6 @@
 #include "boost/bimap/bimap.hpp"
 #include "libslic3r/calib.hpp"
 #include "libslic3r/Utils.hpp"
-#include "slic3r/Utils/PrinterNetworkTypes.hpp"
 
 #include "DeviceCore/DevDefs.h"
 #include "DeviceCore/DevConfigUtil.h"
@@ -101,6 +100,7 @@ struct DevPrintTaskRatingInfo;
 // given nozzle diameter (mm), bucketed per nozzle size to mirror the printer firmware.
 bool is_stringing_prone_filament(const std::string& filament_id, float nozzle_diameter);
 
+
 class MachineObject
 {
 private:
@@ -307,7 +307,7 @@ public:
     bool  ams_support_virtual_tray { true };
     time_t ams_user_setting_start = 0;
     time_t ams_switch_filament_start = 0;
-    AmsStatusMain ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_IDLE;
+    AmsStatusMain ams_status_main;
     int   ams_status_sub;
     int   ams_version = 0;
 
@@ -547,12 +547,30 @@ public:
     bool xcam_first_layer_inspector { false };
     time_t  xcam_first_layer_hold_start = 0;
     std::string local_rtsp_url;
-    std::string webcam_stream_url;
     std::string tutk_state;
-    LiveviewLocal liveview_local{ LiveviewLocal::LVL_None };
-    LiveviewRemote liveview_remote{ LiveviewRemote::LVR_None};
-    FileLocal file_local{ FileLocal::FL_None };
-    FileRemote file_remote{ FileRemote::FR_None };
+    enum LiveviewLocal {
+        LVL_None,
+        LVL_Disable,
+        LVL_Local,
+        LVL_Rtsps,
+        LVL_Rtsp
+    } liveview_local{ LVL_None };
+    enum LiveviewRemote {
+        LVR_None,
+        LVR_Tutk,
+        LVR_Agora,
+        LVR_TutkAgora
+    } liveview_remote{ LVR_None };
+    enum FileLocal {
+        FL_None,
+        FL_Local
+    } file_local{ FL_None };
+    enum FileRemote {
+        FR_None,
+        FR_Tutk,
+        FR_Agora,
+        FR_TutkAgora
+    } file_remote{ FR_None };
 
     enum PlateMakerDectect : int
     {
@@ -678,7 +696,7 @@ public:
 
 
     /* machine mqtt apis */
-    int connect();
+    int connect(bool use_openssl = true);
     int disconnect();
 
     json_diff print_json;
@@ -690,8 +708,6 @@ public:
     std::string  subtask_id_;
     std::string  job_id_;
     std::string  last_subtask_id_;
-    // note: printer-agent-supplied thumbnail url, empty when the agent supplies none.
-    std::string  m_agent_thumbnail_url;
     BBLSliceInfo* slice_info {nullptr};
     boost::thread* get_slice_info_thread { nullptr };
     boost::thread* get_model_task_thread { nullptr };
@@ -749,7 +765,6 @@ public:
     int command_set_printer_nozzle(std::string nozzle_type, float diameter);
     int command_set_printer_nozzle2(int id, std::string nozzle_type, float diameter);
     int command_get_access_code();
-    int command_start_camera();
     int command_ack_proceed(json& proceed);
     int command_purification_disable();
     int command_dont_remind_next_time(json& mqtt_guard_json);
@@ -796,7 +811,8 @@ public:
     int command_ams_calibrate(int ams_id);
     int command_ams_filament_settings(int ams_id, int slot_id, std::string filament_id, std::string setting_id, std::string tray_color, std::string tray_type, int nozzle_temp_min, int nozzle_temp_max);
     int command_ams_select_tray(std::string tray_id);
-    int command_ams_refresh_rfid(int ams_id, int slot_id);
+    int command_ams_refresh_rfid(std::string tray_id);
+    int command_ams_refresh_rfid2(int ams_id, int slot_id);
     int command_ams_control(std::string action);
     int command_ams_drying_stop();
     int command_start_extrusion_cali(int tray_index, int nozzle_temp, int bed_temp, float max_volumetric_speed, std::string setting_id = "");
@@ -878,7 +894,6 @@ public:
     static bool is_in_printing_status(std::string status);
 
     void set_print_state(std::string status);
-    void update_print_progress(const json& value);
 
     bool is_connected();
     bool is_connecting();
@@ -947,7 +962,6 @@ public:
     /*for parse new info*/
     bool check_enable_np(const json& print) const;
     void parse_new_info(json print);
-    void parse_new_info2(const json& info);
     int  get_flag_bits(std::string str, int start, int count = 1) const;
     uint32_t get_flag_bits_no_border(std::string str, int start_idx, int count = 1) const;
     int get_flag_bits(int num, int start, int count = 1, int base = 10) const;
@@ -976,7 +990,7 @@ public:
     void command_set_save_remote_print_file_to_storage(bool save);
 
 private:
-    int command_with_dialog(int cmd_result);
+
     /* xcam door open check*/
     bool is_support_door_open_check = false;
     DoorOpenCheckState xcam_door_open_check  = DoorOpenCheckState::DOOR_OPEN_CHECK_DISABLE;

src/slic3r/GUI/GLCanvas3D.cpp

@@ -6546,11 +6546,8 @@ void GLCanvas3D::render_thumbnail_internal(ThumbnailData& thumbnail_data, const
     //    glsafe(::glClearColor(1.0f, 1.0f, 1.0f, 1.0f));
     BOOST_LOG_TRIVIAL(info) << boost::format("render_thumbnail: finished");
 
-    // Puts the canvas viewport back in place of the thumbnail one set above. The CLI renders
-    // thumbnails with no application and no plater, so there is no canvas viewport to restore.
-    if (wxTheApp != nullptr)
-        if (Plater *plater = wxGetApp().plater(); plater != nullptr)
-            plater->get_camera().apply_viewport();
+    // Puts the canvas viewport back in place of the thumbnail one set above.
+    wxGetApp().plater()->get_camera().apply_viewport();
 }
 
 void GLCanvas3D::render_thumbnail_framebuffer(ThumbnailData& thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams& thumbnail_params,

src/slic3r/GUI/GUI_App.cpp

@@ -4,7 +4,6 @@
 #include "libslic3r/Platform.hpp"
 #include "GUI_App.hpp"
 #include "Shortcuts.hpp"
-#include "DeviceCore/DevConfigUtil.h"
 #include "BindDialog.hpp"
 #include "DeviceManager.hpp"
 #include "HMS.hpp"
@@ -25,6 +24,7 @@
 #include <boost/locale/encoding_utf.hpp>
 #include <boost/log/detail/native_typeof.hpp>
 #include <libslic3r/Config.hpp>
+#include <mutex>
 #include <slic3r/plugin/PythonPluginInterface.hpp>
 #include <wx/event.h>
 
@@ -41,11 +41,9 @@
 #include <iterator>
 #include <exception>
 #include <cstdlib>
-#include <mutex>
 #include <regex>
 #include <thread>
 #include <string_view>
-
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/format.hpp>
@@ -87,9 +85,11 @@
 #include "libslic3r/Model.hpp"
 #include "libslic3r/I18N.hpp"
 #include "libslic3r/PresetBundle.hpp"
+#include "libslic3r/InstanceLock.hpp"
 #include "libslic3r/Thread.hpp"
 #include "libslic3r/miniz_extension.hpp"
 #include "libslic3r/Utils.hpp"
+#include "libslic3r/Color.hpp"
 #include "slic3r/plugin/PluginManager.hpp"
 #include "slic3r/plugin/host/PluginHostUi.hpp"
 #include "slic3r/plugin/PythonInterpreter.hpp"
@@ -109,18 +109,19 @@
 #include "../Utils/PrintHost.hpp"
 #include "../Utils/Process.hpp"
 #include "../Utils/wxInspectorPlugins/Registration.hpp"
+#include "../Utils/MacDarkMode.hpp"
 #include "../Utils/Http.hpp"
 #include "../Utils/InstanceID.hpp"
 #include "../Utils/UndoRedo.hpp"
 #include "slic3r/Config/Snapshot.hpp"
 #include "Preferences.hpp"
 #include "Tab.hpp"
+#include "SysInfoDialog.hpp"
 #include "UpdateDialogs.hpp"
 #include "Mouse3DController.hpp"
 #include "RemovableDriveManager.hpp"
 #include "InstanceCheck.hpp"
 #ifdef __APPLE__
-#include "../Utils/MacDarkMode.hpp"
 #include "DeepLinkHandlerMac.h"
 #endif
 #include "NotificationManager.hpp"
@@ -129,6 +130,8 @@
 #include "PrintHostDialogs.hpp"
 #include "NetworkPluginDialog.hpp"
 #include "DesktopIntegrationDialog.hpp"
+#include "SendSystemInfoDialog.hpp"
+#include "ParamsDialog.hpp"
 #include "KBShortcutsDialog.hpp"
 #include "DownloadProgressDialog.hpp"
 #include "TroubleshootDialog.hpp"
@@ -139,6 +142,7 @@
 #include "Widgets/ProgressDialog.hpp"
 
 //BBS: DailyTip and UserGuide Dialog
+#include "WebDownPluginDlg.hpp"
 #include "WebGuideDialog.hpp"
 #include "ReleaseNote.hpp"
 #include "PrivacyUpdateDialog.hpp"
@@ -2416,23 +2420,34 @@ GUI_App::~GUI_App()
 
 bool GUI_App::is_blocking_printing(MachineObject *obj_)
 {
-    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
-    const std::string source_model = preset_bundle
-        ? preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle)
-        : std::string();
-    return is_blocking_printing(obj_, source_model);
-}
-
-bool GUI_App::is_blocking_printing(MachineObject *obj_, const std::string& source_model)
-{
-    DeviceManager *dev = getDeviceManager();
+    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
     if (!dev) return true;
-    if (obj_ == nullptr)
+    std::string target_model;
+    if (obj_ == nullptr) {
         obj_ = dev->get_selected_machine();
-    if (!obj_)
-        return false;
+        if (obj_) {
+            target_model = obj_->printer_type;
+        }
+    } else {
+        target_model = obj_->printer_type;
+    }
 
-    return !DevPrinterConfigUtil::is_printer_model_compatible(source_model, *obj_);
+    if (!obj_)
+    {
+        return false;
+    }
+
+    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
+    std::string    source_model  = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
+
+    if (source_model != target_model) {
+        std::vector<std::string>      compatible_machine = obj_->get_compatible_machine();
+        vector<std::string>::iterator it                 = find(compatible_machine.begin(), compatible_machine.end(), source_model);
+        if (it == compatible_machine.end()) {
+            return true;
+        }
+    }
+    return false;
 }
 
 // If formatted for github, plaintext with OpenGL extensions enclosed into <details>.
@@ -3556,7 +3571,7 @@ bool GUI_App::on_init_inner()
             update_publish_status();
         }
 
-        if (m_post_initialized && app_config->dirty())
+        if (m_post_initialized && app_config->dirty() && app_config->save_due())
             app_config->save();
 
     });
@@ -3993,16 +4008,20 @@ void GUI_App::set_live_printer_agent(std::shared_ptr<IPrinterAgent> agent)
         m_agent->set_user_selected_machine("");
         // note: belt-and-suspenders (precedent: DeviceManagerRefresher::on_timer)
         dev->OnSelectedMachineLost(); // why: clear stale sidebar sync-status / AMS
-        // why: retain agent-owned LAN discoveries so agents without automatic discovery (for
-        // example the Moonraker-based Qidi/Snapmaker agents) can reuse them after a switch.
-        dev->clear_other_devices();
+        // why: drop stale LAN discoveries; keep My Devices, but only those belonging to the
+        // agent we're about to swap to, so a device stamped by the outgoing agent doesn't
+        // linger hidden - the new agent's start_discovery re-inserts and re-stamps it fresh.
+        // agent is null when clearing the live agent entirely (e.g. plugin unload); there's no
+        // target to filter against then, so fall back to the original "keep all My Devices"
+        // behavior rather than guessing.
+        dev->clear_other_devices(agent ? agent->get_agent_info().id : std::string());
     }
 
     m_agent->set_printer_agent(agent);
     sidebar().update_all_preset_comboboxes();
 }
 
-std::string GUI_App::resolve_printer_agent_id(const std::string& stored_id) const
+std::string GUI_App::resolve_printer_agent_id(const std::string& stored_id)
 {
     if (!stored_id.empty())
         return stored_id;
@@ -4038,7 +4057,6 @@ void GUI_App::switch_printer_agent()
 
     std::string log_dir        = data_dir();
     std::string cloud_agent_id = agent_info.id == BBL_PRINTER_AGENT_ID ? BBL_CLOUD_PROVIDER : ORCA_CLOUD_PROVIDER;
-    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << agent_info.id;
     std::shared_ptr<ICloudServiceAgent> cloud_agent = m_agent->get_cloud_agent(cloud_agent_id);
 
     // Create new printer agent via registry
@@ -4052,10 +4070,8 @@ void GUI_App::switch_printer_agent()
         return;
     }
 
-    // Compare the registered IDs, not only the implementation pointer. Different registry IDs
-    // may intentionally be backed by the same implementation object (especially for plugins).
-    const auto current_printer_agent = m_agent->get_printer_agent();
-    if (current_printer_agent && current_printer_agent->get_agent_info().id == effective_agent_id) {
+    // The factory caches agents per ID, so an identical pointer means the agent type is unchanged.
+    if (m_agent->get_printer_agent() == new_printer_agent) {
         // Orca: the agent type is unchanged (e.g. switching between two Moonraker/Klipper
         // printer presets), so the selected machine and the agent's cached device_info still
         // point at the previously active printer preset. Re-select the machine when the new
@@ -5038,16 +5054,14 @@ bool GUI_App::is_user_login(const std::string& provider/* = ORCA_CLOUD_PROVIDER*
     return false;
 }
 
-std::string GUI_App::get_printer_cloud_provider() const
+const std::string& GUI_App::get_printer_cloud_provider() const
 {
-    const std::string agent_id = resolve_printer_agent_id(
-        preset_bundle ? preset_bundle->printers.get_edited_preset().config.opt_string("printer_agent")
-                      : std::string());
-    return agent_id == BBL_PRINTER_AGENT_ID ? BBL_CLOUD_PROVIDER : ORCA_CLOUD_PROVIDER;
+    // Orca todo: this need to be revisted. currently it is mainly used for device manager and related clausses and only bambu machines use them.
+    // 
+    return BBL_CLOUD_PROVIDER;
 }
 
 
-
 bool GUI_App::check_login(const std::string& provider/* = ORCA_CLOUD_PROVIDER*/)
 {
     bool result = false;
@@ -7651,8 +7665,11 @@ void GUI_App::start_sync_user_preset(bool with_progress_dlg)
 
                             // Delete the bundle folder and bundle
                             fs::path bundle_folder = fs::path(bundle.path.c_str()).parent_path();
-                            boost::system::error_code ec;
-                            boost::filesystem::remove_all(bundle_folder, ec);
+                            {
+                                boost::system::error_code ec;
+                                InstanceLock instance_lock(user_presets_lock_path());
+                                boost::filesystem::remove_all(bundle_folder, ec);
+                            }
 
                             preset_bundle->bundles.WriteLock();
                             preset_bundle->bundles.m_bundles.erase(bundle.id);
@@ -8939,6 +8956,7 @@ void GUI_App::preset_deleted_from_cloud(std::string setting_id)
 
     // Delete the .info file after cloud deletion is confirmed
     if (!preset_file_path.empty() && fs::exists(fs::path(preset_file_path))) {
+        InstanceLock instance_lock(user_presets_lock_path());
         boost::nowide::remove(preset_file_path.c_str());
         BOOST_LOG_TRIVIAL(info) << "Deleted .info file after cloud confirmation: " << preset_file_path;
     }
@@ -9001,15 +9019,19 @@ void GUI_App::scan_orphaned_info_files()
             fs::path preset_file = info_file;
             preset_file.replace_extension(".json");
 
-            // If .json doesn't exist, .info is orphaned
-            if (!fs::exists(preset_file)) {
-                // Extract setting_id from .info file
-                std::string setting_id = extract_setting_id_from_info(info_file.string());
-                if (!setting_id.empty()) {
-                    // Add to need_delete_presets
-                    delete_preset_from_cloud(setting_id, info_file.string());
-                    BOOST_LOG_TRIVIAL(info) << "Found orphaned .info file on startup: " << info_file.string();
-                }
+            // If .json doesn't exist, .info is orphaned. Read under the lock, so a
+            // remove_files() in another instance is seen whole or not at all; the
+            // delete queue's own mutex is taken after the lock is released.
+            std::string setting_id;
+            {
+                InstanceLock instance_lock(user_presets_lock_path());
+                if (!fs::exists(preset_file))
+                    setting_id = extract_setting_id_from_info(info_file.string());
+            }
+            if (!setting_id.empty()) {
+                // Add to need_delete_presets
+                delete_preset_from_cloud(setting_id, info_file.string());
+                BOOST_LOG_TRIVIAL(info) << "Found orphaned .info file on startup: " << info_file.string();
             }
         }
         if (ec)

src/slic3r/GUI/GUI_App.hpp

@@ -24,6 +24,9 @@
 #include <wx/snglinst.h>
 #include <wx/msgdlg.h>
 
+#include <mutex>
+#include <stack>
+
 //#define BBL_HAS_FIRST_PAGE          1
 #define STUDIO_INACTIVE_TIMEOUT     15*60*1000
 #define LOG_FILES_MAX_NUM           30
@@ -370,7 +373,6 @@ public:
     EAppMode get_app_mode() const { return m_app_mode; }
     Slic3r::DeviceManager* getDeviceManager() { return m_device_manager; }
     bool                   is_blocking_printing(MachineObject *obj_ = nullptr);
-    bool                   is_blocking_printing(MachineObject *obj_, const std::string& source_model);
     Slic3r::TaskManager*   getTaskManager() { return m_task_manager; }
     HMSQuery* get_hms_query() { return hms_query; }
     NetworkAgent* getAgent() { return m_agent; }
@@ -378,7 +380,7 @@ public:
     // Reconcile the live printer agent with the stored preset selection.
     void switch_printer_agent();
 
-    std::string resolve_printer_agent_id(const std::string& stored_id) const;
+    std::string resolve_printer_agent_id(const std::string& stored_id);
     // ORCA TODO: in the future, bbl presets should specify "bbl" printer agent id
     // then, all resolve and canonical would just be ORCA<->""
     std::string canonical_printer_agent_id(const std::string& picked_id);
@@ -509,7 +511,7 @@ public:
     bool            check_login(const std::string& provider = ORCA_CLOUD_PROVIDER);
     void            get_login_info(const std::string& provider = ORCA_CLOUD_PROVIDER);
     bool            is_user_login(const std::string& provider = ORCA_CLOUD_PROVIDER);
-    std::string      get_printer_cloud_provider() const;
+    const std::string& get_printer_cloud_provider() const;
 
     void            request_user_login(int online_login = 0, const std::string& provider = ORCA_CLOUD_PROVIDER);
     void            request_user_handle(int online_login = 0, const std::string& provider = ORCA_CLOUD_PROVIDER);

src/slic3r/GUI/IMediaController.hpp

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <wx/mediactrl.h>
-#include <wx/uri.h>
-
-namespace Slic3r { namespace GUI {
-
-class IMediaController
-{
-public:
-    virtual ~IMediaController() = default;
-
-    virtual void Load(wxURI url) = 0;
-
-    virtual void Play() = 0;
-
-    virtual void Stop() = 0;
-
-    virtual wxMediaState GetState() { return wxMediaState{}; }
-
-    virtual int GetLastError() const { return {}; };
-
-    virtual wxSize GetVideoSize() const { return {}; };
-};
-
-}} // namespace Slic3r::GUI

src/slic3r/GUI/Jobs/PrintJob.cpp

@@ -15,7 +15,6 @@
 
 #include "slic3r/Utils/FileTransferUtils.hpp"
 #include "slic3r/Utils/BBLNetworkPlugin.hpp"
-#include "NetworkAgent.hpp"
 
 namespace Slic3r {
 namespace GUI {
@@ -217,7 +216,7 @@ void PrintJob::process(Ctl &ctl)
     params.dev_ip = m_dev_ip;
     params.use_ssl_for_ftp  = m_local_use_ssl_for_ftp;
     params.use_ssl_for_mqtt  = m_local_use_ssl;
-    params.username = m_agent->default_lan_username();
+    params.username = "bblp";
     params.password = m_access_code;
 
     // check access code and ip address

src/slic3r/GUI/Jobs/SendJob.cpp

@@ -127,7 +127,7 @@ void SendJob::process(Ctl &ctl)
     if (m_is_check_mode) {
         PrintParams verify_params;
         verify_params.dev_ip           = m_dev_ip;
-        verify_params.username         = agent->default_lan_username();
+        verify_params.username         = "bblp";
         verify_params.password         = m_access_code;
         verify_params.use_ssl_for_ftp  = m_local_use_ssl_for_ftp;
         verify_params.use_ssl_for_mqtt = m_local_use_ssl;
@@ -219,7 +219,7 @@ void SendJob::process(Ctl &ctl)
 
     // local print access
     params.dev_ip = m_dev_ip;
-    params.username = agent->default_lan_username();
+    params.username = "bblp";
     params.password = m_access_code;
     params.use_ssl_for_ftp = m_local_use_ssl_for_ftp;
     params.use_ssl_for_mqtt = m_local_use_ssl;

src/slic3r/GUI/MainFrame.cpp

@@ -4377,7 +4377,7 @@ void MainFrame::load_printer_url()
         if (auto *device_manager = wxGetApp().getDeviceManager()) {
             auto *machine = device_manager->get_selected_machine();
             if (!machine) {
-                auto machines = device_manager->get_my_machine_list(device_manager->get_current_printer_agent_id());
+                auto machines = device_manager->get_my_machine_list();
                 if (machines.size() == 1)
                     machine = machines.begin()->second;
             }

src/slic3r/GUI/MediaPlayCtrl.cpp

@@ -1,6 +1,4 @@
 #include "MediaPlayCtrl.h"
-#include "WebMediaController.hpp"
-#include "IPrinterAgent.hpp"
 #include "Widgets/Button.hpp"
 #include "Widgets/CheckBox.hpp"
 #include "Widgets/Label.hpp"
@@ -9,7 +7,6 @@
 #include "DeviceManager.hpp"
 #include "DeviceCore/DevConfigUtil.h"
 #include "slic3r/Utils/NetworkAgent.hpp"
-#include "slic3r/Utils/NetworkAgentFactory.hpp"
 #include "libslic3r/Thread.hpp"
 #include "libslic3r/AppConfig.hpp"
 #include "I18N.hpp"
@@ -18,15 +15,11 @@
 #include "slic3r/Utils/BBLNetworkPlugin.hpp"
 
 
-#include <algorithm>
-
 #include <boost/lexical_cast.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/nowide/cstdio.hpp>
 #include <boost/nowide/fstream.hpp>
 #include <boost/nowide/utf8_codecvt.hpp>
-#include <slic3r/GUI/DeviceManager.hpp>
-#include <wx/mediactrl.h>
 #undef pid_t
 #include <boost/process.hpp>
 #ifdef __WIN32__
@@ -55,7 +48,6 @@ namespace GUI {
 MediaPlayCtrl::MediaPlayCtrl(wxWindow *parent, wxMediaCtrl3 *media_ctrl, const wxPoint &pos, const wxSize &size)
     : wxPanel(parent, wxID_ANY, pos, size)
     , m_media_ctrl(media_ctrl)
-    , m_active_media_controller(media_ctrl)
 {
     SetLabel("MediaPlayCtrl");
     SetBackgroundColour(*wxWHITE);
@@ -102,10 +94,7 @@ MediaPlayCtrl::MediaPlayCtrl(wxWindow *parent, wxMediaCtrl3 *media_ctrl, const w
     });
 
     m_button_play->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [this](auto &e) { TogglePlay(); });
-    m_button_play->Bind(wxEVT_RIGHT_UP, [this](auto & e) {
-        if (m_active_media_controller)
-            m_active_media_controller->Play();
-    });
+    m_button_play->Bind(wxEVT_RIGHT_UP, [this](auto & e) { m_media_ctrl->Play(); });
     // Orca: live-view FAQ link binding removed (vendor URL)
 
     Bind(wxEVT_RIGHT_UP, [this](auto & e) {
@@ -150,12 +139,9 @@ MediaPlayCtrl::MediaPlayCtrl(wxWindow *parent, wxMediaCtrl3 *media_ctrl, const w
 
 MediaPlayCtrl::~MediaPlayCtrl()
 {
-    if (m_webrtc_ctrl)
-        m_webrtc_ctrl->Stop();
-    m_media_ctrl->EndExternalStream();
     {
         boost::unique_lock lock(m_mutex);
-        m_tasks.push_back({"<exit>", nullptr});
+        m_tasks.push_back("<exit>");
         m_cond.notify_all();
     }
     while (!m_thread.try_join_for(boost::chrono::milliseconds(10))) {
@@ -165,144 +151,59 @@ MediaPlayCtrl::~MediaPlayCtrl()
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": " << this;
 }
 
-void MediaPlayCtrl::SetWebMediaController(IMediaController *ctrl)
-{
-    m_web_ctrl = ctrl;
-    set_active_media_controller(current_mode());
-}
-
-void MediaPlayCtrl::set_active_media_controller(CameraStreamMode mode)
-{
-    switch (mode) {
-    case CameraStreamMode::http_snapshot:
-        if (auto *web_ctrl = dynamic_cast<WebMediaController *>(m_web_ctrl))
-            web_ctrl->set_mode(mode);
-        m_active_media_controller = m_web_ctrl;
-        break;
-    case CameraStreamMode::webrtc:
-        if (!m_webrtc_ctrl) {
-            m_webrtc_ctrl = std::make_unique<WebRtcMediaController>(
-                [this](const wxImage& image, wxSize size) { m_media_ctrl->SetExternalFrame(image, size); },
-                [this, token = std::weak_ptr<int>(m_token)](WebRtcMediaController::Status status) {
-                    if (token.expired())
-                        return;
-                    CallAfter([this, status] { on_webrtc_status(status); });
-                });
-        }
-        m_active_media_controller = m_webrtc_ctrl.get();
-        break;
-    default:
-        m_active_media_controller = m_media_ctrl;
-        break;
-    }
-}
-
-CameraStreamMode MediaPlayCtrl::current_mode() const
-{
-    auto agent = wxGetApp().getAgent();
-    return agent ? agent->get_camera_stream_mode() : CameraStreamMode::none;
-}
-
 void MediaPlayCtrl::SetMachineObject(MachineObject* obj)
 {
-    const CameraStreamMode mode = current_mode();
-    if (mode != m_last_mode) {
-        if (m_last_state != MEDIASTATE_IDLE) {
-            m_failed_code = 0; // a mode switch is not a stream failure - don't arm back-off
-            Stop(" ");
+    std::string machine = obj ? obj->get_dev_id() : "";
+    if (obj) {
+        m_camera_exists  = obj->has_ipcam;
+        m_dev_ver        = obj->get_ota_version();
+        m_lan_mode       = obj->is_lan_mode_printer();
+        m_lan_proto      = obj->liveview_local;
+        m_remote_proto   = obj->get_liveview_remote();
+        m_lan_ip         = obj->get_dev_ip();
+        m_lan_passwd     = obj->get_access_code();
+        m_device_busy    = obj->is_camera_busy_off();
+        m_tutk_state     = obj->tutk_state;
+
+        if (DevPrinterConfigUtil::get_printer_series_str(obj->printer_type) == "series_o" && BBLNetworkPlugin::instance().use_legacy_network()) {
+            // Legacy plugin cannot support remote play for H2D, force using local mode
+            m_remote_proto = MachineObject::LVR_None;
         }
-        m_last_mode = mode;
-    }
-    set_active_media_controller(mode);
-
-    const bool uses_local_camera_url = mode == CameraStreamMode::http || mode == CameraStreamMode::https ||
-                                       mode == CameraStreamMode::http_snapshot || mode == CameraStreamMode::rtsp;
-    const bool uses_webrtc = mode == CameraStreamMode::webrtc;
-    const std::string machine = obj ? obj->get_dev_id() : "";
-    bool changed = false;
-
-    if (uses_local_camera_url) {
-        auto agent = wxGetApp().getAgent();
-        std::string url = agent ? agent->get_local_camera_stream_url() : "";
-        m_camera_exists = !url.empty();
-        Enable(obj && m_camera_exists);
-        changed = machine != m_machine || url != m_agent_camera_url;
-        m_agent_camera_url = url;
-        m_url = from_u8(url);
-    } else if (uses_webrtc) {
-        m_camera_exists = obj != nullptr;
-        Enable(obj != nullptr);
-        changed = machine != m_machine;
-        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::SetMachineObject webrtc: changed=" << changed
-                                << " last_state=" << m_last_state << " web_user_stopped=" << m_web_user_stopped;
-        m_url.clear();
-        m_agent_camera_url.clear();
     } else {
-        if (obj) {
-            m_camera_exists  = obj->has_ipcam;
-            m_dev_ver        = obj->get_ota_version();
-            m_lan_mode       = obj->is_lan_mode_printer();
-            m_lan_proto      = obj->liveview_local;
-            m_remote_proto   = obj->get_liveview_remote();
-            m_lan_ip         = obj->get_dev_ip();
-            m_lan_passwd     = obj->get_access_code();
-            m_device_busy    = obj->is_camera_busy_off();
-            m_tutk_state     = obj->tutk_state;
-
-            if (DevPrinterConfigUtil::get_printer_series_str(obj->printer_type) == "series_o" && BBLNetworkPlugin::instance().use_legacy_network()) {
-                // Legacy plugin cannot support remote play for H2D, force using local mode
-                m_remote_proto = LiveviewRemote::LVR_None;
-            }
-        } else {
-            m_camera_exists = false;
-            m_lan_mode = false;
-            m_lan_proto = LiveviewLocal::LVL_None;
-            m_lan_ip.clear();
-            m_lan_passwd.clear();
-            m_dev_ver.clear();
-            m_tutk_state.clear();
-            m_remote_proto = 0;
-            m_device_busy = false;
-        }
-        Enable(obj && obj->is_info_ready() && obj->m_push_count > 0);
-        if (machine == m_machine)
-            return;
-
-        m_machine = machine;
-        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl switch machine: " << m_machine;
-        m_disable_lan = false;
-        m_failed_retry = 0;
-        m_last_failed_codes.clear();
-        m_last_user_play = wxDateTime::Now();
-        std::string stream_url;
-        if (get_stream_url(&stream_url)) {
-            m_streaming = boost::algorithm::contains(stream_url, "device=" + m_machine);
-        } else {
-            m_streaming = false;
-        }
-        if (m_last_state != MEDIASTATE_IDLE)
-            Stop(" ");
-        if (m_next_retry.IsValid()) // Try open 2 seconds later, to avoid state conflict
-            m_next_retry = wxDateTime::Now() + wxTimeSpan::Seconds(2);
-        else
-            SetStatus("", false);
+        m_camera_exists = false;
+        m_lan_mode = false;
+        m_lan_proto = MachineObject::LVL_None;
+        m_lan_ip.clear();
+        m_lan_passwd.clear();
+        m_dev_ver.clear();
+        m_tutk_state.clear();
+        m_remote_proto = 0;
+        m_device_busy = false;
+    }
+    Enable(obj && obj->is_info_ready() && obj->m_push_count > 0);
+    if (machine == m_machine) {
+        if (m_last_state == MEDIASTATE_IDLE && IsEnabled())
+            Play();
         return;
     }
-
     m_machine = machine;
-    if (!changed)
-        return;
-
-    // A genuine target switch is not a stream failure and should clear the
-    // manual-stop state before the new target is allowed to play.
-    m_web_user_stopped = false;
-    if (uses_local_camera_url) {
-        m_failed_code = 0;
-        m_failed_retry = 0;
-        m_next_retry = wxDateTime();
+    BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl switch machine: " << m_machine;
+    m_disable_lan = false;
+    m_failed_retry = 0;
+    m_last_failed_codes.clear();
+    m_last_user_play = wxDateTime::Now();
+    std::string stream_url;
+    if (get_stream_url(&stream_url)) {
+        m_streaming = boost::algorithm::contains(stream_url, "device=" + m_machine);
+    } else {
+        m_streaming = false;
     }
     if (m_last_state != MEDIASTATE_IDLE)
         Stop(" ");
+    if (m_next_retry.IsValid()) // Try open 2 seconds later, to avoid state conflict
+        m_next_retry = wxDateTime::Now() + wxTimeSpan::Seconds(2);
+    else
+        SetStatus("", false);
 }
 
 wxString hide_id_middle_string(wxString const &str, size_t offset = 0, size_t length = -1)
@@ -353,71 +254,13 @@ void refresh_agora_url(char const* device, char const* dev_ver, char const* chan
 
 void MediaPlayCtrl::Play()
 {
-    if ((m_next_retry.IsValid() && wxDateTime::Now() < m_next_retry) || !IsShownOnScreen() || m_last_state != MEDIASTATE_IDLE)
+    if (!m_next_retry.IsValid() || wxDateTime::Now() < m_next_retry)
         return;
-
-    const CameraStreamMode mode = current_mode();
-    set_active_media_controller(mode);
-    m_last_mode = mode;
-    auto agent = wxGetApp().getAgent();
-
-    auto printer_agent = agent ? agent->get_printer_agent() : nullptr;
-    const bool is_bbl = (printer_agent ? printer_agent->get_agent_info().id : "") == BBL_PRINTER_AGENT_ID;
-
-    if (!is_bbl) {
-        const bool is_webrtc = mode == CameraStreamMode::webrtc;
-        const bool is_snapshot = mode == CameraStreamMode::http_snapshot;
-        const bool is_http_stream = mode == CameraStreamMode::http || mode == CameraStreamMode::https || mode == CameraStreamMode::rtsp;
-        if (!is_webrtc && !is_snapshot && !is_http_stream)
-            return;
-
-        auto *webrtc_ctrl = is_webrtc ? dynamic_cast<WebRtcMediaController *>(m_active_media_controller) : nullptr;
-        if (is_webrtc && (!webrtc_ctrl || !m_media_ctrl)) {
-            Stop(_L("Please confirm if the printer is connected."));
-            return;
-        }
-        if (webrtc_ctrl && webrtc_ctrl->is_active())
-            return;
-
-        m_failed_code = 0;
-        if (!m_active_media_controller || m_machine.empty() || !IsEnabled() || !m_camera_exists ||
-            (!is_webrtc && m_url.IsEmpty())) {
-            Stop(_L("Please confirm if the printer is connected."));
-            return;
-        }
-
-        if (is_webrtc) {
-            BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::Play webrtc: last_state=" << m_last_state << " failed_retry=" << m_failed_retry
-                                    << " shown=" << IsShownOnScreen();
-            auto channel = agent ? agent->create_camera_signaling_channel(m_machine, wxGetApp().get_printer_cloud_provider()) : nullptr;
-            if (!channel) {
-                Stop(_L("Sign in to OrcaCloud to view the camera."));
-                return;
-            }
-            webrtc_ctrl->set_signalling_channel(std::move(channel));
-            m_media_ctrl->BeginExternalStream();
-            m_last_state = MEDIASTATE_INITIALIZING;
-            SetStatus(_L("Initializing..."), false);
-        } else if (is_snapshot) {
-            m_last_state = wxMEDIASTATE_PLAYING;
-            SetStatus(_L("Playing..."), false);
-        }
-
-        m_button_play->SetIcon("media_stop");
-        if (m_active_media_controller == m_media_ctrl) {
-            // wxMediaCtrl3 reports when it has a decoded frame; load() waits for
-            // that event before queuing Play so the stream is not marked stopped.
-            load();
-        } else {
-            m_active_media_controller->Load(wxURI(m_url));
-            m_active_media_controller->Play();
-        }
-        if (webrtc_ctrl) {
-            m_webrtc_epoch = webrtc_ctrl->epoch();
-        }
+    if (!IsShownOnScreen())
+        return;
+    if (m_last_state != MEDIASTATE_IDLE) {
         return;
     }
-
     m_failed_code = 0;
     if (m_machine.empty()) {
         Stop(_L("Please confirm if the printer is connected."));
@@ -438,15 +281,16 @@ void MediaPlayCtrl::Play()
     }
 
     BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::Play: " << m_lan_proto << m_remote_proto << m_disable_lan;
+    NetworkAgent *agent = wxGetApp().getAgent();
     std::string  agent_version = agent ? agent->get_version() : "";
-    if (m_lan_proto > LiveviewLocal::LVL_Disable && (m_lan_mode || !m_remote_proto) && !m_disable_lan && !m_lan_ip.empty()) {
+    if (m_lan_proto > MachineObject::LVL_Disable && (m_lan_mode || !m_remote_proto) && !m_disable_lan && !m_lan_ip.empty()) {
         m_disable_lan = m_remote_proto && !m_lan_mode; // try remote next time
         std::string url;
-        if (m_lan_proto == LiveviewLocal::LVL_Local)
+        if (m_lan_proto == MachineObject::LVL_Local)
             url = "bambu:///local/" + m_lan_ip + ".?port=6000&user=" + m_lan_user + "&passwd=" + m_lan_passwd;
-        else if (m_lan_proto == LiveviewLocal::LVL_Rtsps)
+        else if (m_lan_proto == MachineObject::LVL_Rtsps)
             url = "bambu:///rtsps___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsps";
-        else if (m_lan_proto == LiveviewLocal::LVL_Rtsp)
+        else if (m_lan_proto == MachineObject::LVL_Rtsp)
             url = "bambu:///rtsp___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsp";
         url += "&device=" + m_machine;
         url += "&net_ver=" + agent_version;
@@ -468,8 +312,8 @@ void MediaPlayCtrl::Play()
     // !m_lan_mode && !m_remote_proto && m_lan_proto == LVL_Disable (*)
     // !m_lan_mode && !m_remote_proto && m_lan_proto == LVL_None (x)
 
-    if (m_lan_proto <= LiveviewLocal::LVL_Disable && (m_lan_mode || !m_remote_proto)) {
-        Stop(m_lan_proto == LiveviewLocal::LVL_None
+    if (m_lan_proto <= MachineObject::LVL_Disable && (m_lan_mode || !m_remote_proto)) {
+        Stop(m_lan_proto == MachineObject::LVL_None
             ? _L("A problem occurred. Please update the printer firmware and try again.")
             : _L("LAN Only Liveview is off. Please turn on the liveview on printer screen."));
         return;
@@ -537,78 +381,15 @@ void MediaPlayCtrl::Play()
 
 void start_ping_test();
 
-void MediaPlayCtrl::StopWebStream()
-{
-    if (m_last_state == MEDIASTATE_IDLE)
-        return;
-    if (m_active_media_controller && m_active_media_controller == m_web_ctrl)
-        m_active_media_controller->Stop();
-    m_button_play->SetIcon("media_play");
-    m_last_state = MEDIASTATE_IDLE;
-    SetStatus(_L("Video Stopped."), false);
-}
-
 void MediaPlayCtrl::Stop(wxString const &msg, wxString const &msg2)
 {
-    const bool webrtc_active = m_last_mode == CameraStreamMode::webrtc &&
-                               dynamic_cast<WebRtcMediaController *>(m_active_media_controller) != nullptr;
-    BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::Stop: last_state=" << m_last_state
-                            << " webrtc_active=" << webrtc_active << " failed_code=" << m_failed_code
-                            << " msg='" << msg.ToUTF8().data() << "'";
-    if (webrtc_active) {
-        m_active_media_controller->Stop();
-        m_media_ctrl->EndExternalStream();
-    }
-    switch (m_last_mode) {
-    case CameraStreamMode::http:
-    case CameraStreamMode::https:
-    case CameraStreamMode::http_snapshot: {
-        const bool snapshot = m_last_mode == CameraStreamMode::http_snapshot;
-        if (m_last_state != MEDIASTATE_IDLE) {
-            if (snapshot) {
-                if (m_active_media_controller)
-                    m_active_media_controller->Stop();
-            } else {
-                // http/https mode plays through the ffmpeg backend (m_media_ctrl), not
-                // the webview - tear its read thread down too, otherwise it keeps
-                // pulling and painting frames after the UI says "Video Stopped".
-                boost::unique_lock lock(m_mutex);
-                m_tasks.push_back({"<stop>", m_active_media_controller});
-                m_cond.notify_all();
-            }
-            m_button_play->SetIcon("media_play");
-            m_last_state = MEDIASTATE_IDLE;
-            if (!msg.IsEmpty())
-                SetStatus(msg);
-            else
-                SetStatus(_L("Video Stopped."), false);
-            // Keep retries bounded for an explicit or retry-driven playback attempt.
-            // m_failed_retry is cleared on success (onStateChanged) and on a deliberate
-            // machine switch (SetMachineObject); manual playback via TogglePlay resets it.
-            if (m_failed_code != 0) {
-                const bool auto_retry = wxGetApp().app_config->get("liveview", "auto_retry") != "false";
-                ++m_failed_retry;
-                m_next_retry = auto_retry
-                    ? wxDateTime::Now() + wxTimeSpan::Seconds(std::min(5 * m_failed_retry, 30))
-                    : wxDateTime::Now() + wxTimeSpan::Days(1); // "off": wait for a manual retry
-            }
-        } else if (!msg.IsEmpty()) {
-            SetStatus(msg, false);
-        }
-        return;
-    }
-    default:
-        break;
-    }
-
     int last_state = m_last_state;
 
     if (m_last_state != MEDIASTATE_IDLE) {
         m_media_ctrl->InvalidateBestSize();
         m_button_play->SetIcon("media_play");
         boost::unique_lock lock(m_mutex);
-        if (!webrtc_active)
-            m_tasks.push_back({"<stop>", m_active_media_controller});
+        m_tasks.push_back("<stop>");
         m_cond.notify_all();
         if (!msg.IsEmpty())
             SetStatus(msg);
@@ -673,38 +454,15 @@ void MediaPlayCtrl::Stop(wxString const &msg, wxString const &msg2)
         m_next_retry = wxDateTime::Now() + wxTimeSpan::Seconds(5 * m_failed_retry);
 }
 
-void MediaPlayCtrl::on_webrtc_status(WebRtcMediaController::Status status)
-{
-    // Drop CallAfter-queued events from a superseded Play attempt.
-    if (status.epoch != m_webrtc_epoch)
-        return;
-    if (status.kind == WebRtcMediaController::Status::Connecting) {
-        m_last_state = MEDIASTATE_INITIALIZING;
-        SetStatus(_L("Initializing..."), false);
-    } else if (status.kind == WebRtcMediaController::Status::Playing) {
-        m_last_state = wxMEDIASTATE_PLAYING;
-        m_failed_code = 0;
-        m_failed_retry = 0;
-        SetStatus(_L("Playing..."), false);
-    } else if (status.kind == WebRtcMediaController::Status::Failed) {
-        m_failed_code = static_cast<int>(status.code) + 1;
-        Stop();
-    }
-    // Status::Stopped needs no action: a genuine failure arrives as Failed, and
-    // a stop we initiated is already handled by Stop() itself.
-}
-
 void MediaPlayCtrl::TogglePlay()
 {
     BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::TogglePlay";
     if (m_last_state != MEDIASTATE_IDLE) {
         m_next_retry = wxDateTime();
-        m_web_user_stopped = true;
         Stop();
     } else {
         m_failed_retry = 0;
         m_user_triggered = true;
-        m_web_user_stopped = false;
         if (m_last_user_play + wxTimeSpan::Minutes(5) < wxDateTime::Now()) {
             m_last_failed_codes.clear();
             m_last_user_play = wxDateTime::Now();
@@ -770,13 +528,13 @@ void MediaPlayCtrl::ToggleStream()
             wxGetApp().app_config->set("not_show_vcamera_stop_prev", "1");
         if (res == wxID_CANCEL) return;
     }
-    if (m_lan_proto > LiveviewLocal::LVL_Disable && (m_lan_mode || !m_remote_proto) && !m_disable_lan && !m_lan_ip.empty()) {
+    if (m_lan_proto > MachineObject::LVL_Disable && (m_lan_mode || !m_remote_proto) && !m_disable_lan && !m_lan_ip.empty()) {
         std::string url;
-        if (m_lan_proto == LiveviewLocal::LVL_Local)
+        if (m_lan_proto == MachineObject::LVL_Local)
             url = "bambu:///local/" + m_lan_ip + ".?port=6000&user=" + m_lan_user + "&passwd=" + m_lan_passwd;
-        else if (m_lan_proto == LiveviewLocal::LVL_Rtsps)
+        else if (m_lan_proto == MachineObject::LVL_Rtsps)
             url = "bambu:///rtsps___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsps";
-        else if (m_lan_proto == LiveviewLocal::LVL_Rtsp)
+        else if (m_lan_proto == MachineObject::LVL_Rtsp)
             url = "bambu:///rtsp___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsp";
         url += "&device=" + into_u8(m_machine);
         url += "&dev_ver=" + m_dev_ver;
@@ -836,9 +594,7 @@ void MediaPlayCtrl::jump_to_play()
 void MediaPlayCtrl::onStateChanged(wxMediaEvent &event)
 {
     auto last_state = m_last_state;
-    if (m_active_media_controller != m_media_ctrl)
-        return;
-    auto state      = m_active_media_controller->GetState();
+    auto state      = m_media_ctrl->GetState();
     BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::onStateChanged: " << state << ", last_state: " << last_state;
     if ((int) state < 0) return;
     {
@@ -850,14 +606,14 @@ void MediaPlayCtrl::onStateChanged(wxMediaEvent &event)
     }
     if ((last_state == MEDIASTATE_IDLE || last_state == MEDIASTATE_INITIALIZING) && state == wxMEDIASTATE_STOPPED) { return; }
     if ((last_state == wxMEDIASTATE_PAUSED || last_state == wxMEDIASTATE_PLAYING) && state == wxMEDIASTATE_STOPPED) {
-        m_failed_code = m_active_media_controller->GetLastError();
+        m_failed_code = m_media_ctrl->GetLastError();
         Stop();
         return;
     }
     if (last_state == MEDIASTATE_LOADING && (state == wxMEDIASTATE_STOPPED || state == wxMEDIASTATE_PAUSED)) {
-        wxSize size = m_active_media_controller->GetVideoSize();
+        wxSize size = m_media_ctrl->GetVideoSize();
         BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::onStateChanged: size: " << size.x << "x" << size.y;
-        m_failed_code = m_active_media_controller->GetLastError();
+        m_failed_code = m_media_ctrl->GetLastError();
         if (size.GetWidth() >= 320) {
             m_last_state = state;
             m_failed_code = 0;
@@ -867,7 +623,7 @@ void MediaPlayCtrl::onStateChanged(wxMediaEvent &event)
             m_failed_retry = 0;
             m_disable_lan = false;
             boost::unique_lock lock(m_mutex);
-            m_tasks.push_back({"<play>", m_active_media_controller});
+            m_tasks.push_back("<play>");
             m_cond.notify_all();
         } else if (event.GetId()) {
             if (m_failed_code == 0)
@@ -910,8 +666,7 @@ void MediaPlayCtrl::load()
 {
     m_last_state = MEDIASTATE_LOADING;
     SetStatus(_L("Loading..."));
-    const auto mode = current_mode();
-    if (mode == CameraStreamMode::none && wxGetApp().app_config->get("internal_developer_mode") == "true") {
+    if (wxGetApp().app_config->get("internal_developer_mode") == "true") {
         std::string file_h264 = data_dir() + "/video.h264";
         std::string file_info = data_dir() + "/video.info";
         BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl dump video to " << file_h264;
@@ -922,7 +677,7 @@ void MediaPlayCtrl::load()
         m_url                = m_url + "&dump_info=" + boost::lexical_cast<std::string>(dump_info_file);
     }
     boost::unique_lock lock(m_mutex);
-    m_tasks.push_back({m_url, m_active_media_controller});
+    m_tasks.push_back(m_url);
     m_cond.notify_all();
 }
 
@@ -931,8 +686,9 @@ void MediaPlayCtrl::on_show_hide(wxShowEvent &evt)
     evt.Skip();
     if (m_isBeingDeleted) return;
     m_failed_retry = 0;
-    if (!IsShownOnScreen())
-        Stop();
+    if (m_next_retry.IsValid()) // Try open 2 seconds later, to avoid quick play/stop
+        m_next_retry = wxDateTime::Now() + wxTimeSpan::Seconds(2);
+    IsShownOnScreen() ? Play() : Stop();
 }
 
 void MediaPlayCtrl::media_proc()
@@ -942,34 +698,30 @@ void MediaPlayCtrl::media_proc()
         while (m_tasks.empty()) {
             m_cond.wait(lock);
         }
-        MediaTask task = m_tasks.front();
-        if (m_tasks.size() >= 2 && !task.command.IsEmpty() && task.command[0] != '<' &&
-            m_tasks[1].command == "<stop>" && task.controller == m_tasks[1].controller) {
-            BOOST_LOG_TRIVIAL(trace) << "MediaPlayCtrl: busy skip url: " << task.command;
+        wxString url = m_tasks.front();
+        if (m_tasks.size() >= 2 && !url.IsEmpty() && url[0] != '<' && m_tasks[1] == "<stop>") {
+            BOOST_LOG_TRIVIAL(trace) << "MediaPlayCtrl: busy skip url: " << url;
             m_tasks.pop_front();
             m_tasks.pop_front();
             continue;
         }
         lock.unlock();
-        if (task.command == "<stop>") {
+        if (url == "<stop>") {
             BOOST_LOG_TRIVIAL(info) <<  "MediaPlayCtrl: start stop";
-            if (task.controller)
-                task.controller->Stop();
+            m_media_ctrl->Stop();
             BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl: end stop";
         }
-        else if (task.command == "<exit>") {
+        else if (url == "<exit>") {
             break;
         }
-        else if (task.command == "<play>") {
+        else if (url == "<play>") {
             BOOST_LOG_TRIVIAL(info) <<  "MediaPlayCtrl: start play";
-            if (task.controller)
-                task.controller->Play();
+            m_media_ctrl->Play();
             BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl: end play";
         }
         else {
             BOOST_LOG_TRIVIAL(info) <<  "MediaPlayCtrl: start load";
-            if (task.controller)
-                task.controller->Load(wxURI(task.command));
+            m_media_ctrl->Load(wxURI(url));
             BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl: end load";
         }
         lock.lock();

src/slic3r/GUI/MediaPlayCtrl.h

@@ -9,9 +9,6 @@
 #define MediaPlayCtrl_h
 
 #include "wxMediaCtrl3.h"
-#include "IMediaController.hpp"
-#include "WebRtcMediaController.hpp"
-#include "slic3r/Utils/IPrinterAgent.hpp"
 
 #include <wx/panel.h>
 
@@ -39,10 +36,6 @@ public:
 
     void SetMachineObject(MachineObject * obj);
 
-    void SetWebMediaController(IMediaController *ctrl);
-
-    void StopWebStream();
-
     bool IsStreaming() const;
 
     void ToggleStream();
@@ -61,7 +54,6 @@ protected:
     void TogglePlay();
 
     void SetStatus(wxString const &msg, bool hyperlink = true);
-    void on_webrtc_status(WebRtcMediaController::Status status);
 
 private:
     void load();
@@ -74,9 +66,6 @@ private:
 
     static bool get_stream_url(std::string *url = nullptr);
 
-    CameraStreamMode current_mode() const;
-    void set_active_media_controller(CameraStreamMode mode);
-
 private:
     static inline const wxMediaState MEDIASTATE_IDLE = static_cast<wxMediaState>(3);
     static inline const wxMediaState MEDIASTATE_INITIALIZING = static_cast<wxMediaState>(4);
@@ -87,13 +76,6 @@ private:
     std::shared_ptr<int> m_token = std::make_shared<int>(0);
 
     wxMediaCtrl3 * m_media_ctrl;
-    IMediaController * m_active_media_controller = nullptr;
-    IMediaController * m_web_ctrl = nullptr;
-    std::unique_ptr<WebRtcMediaController> m_webrtc_ctrl;
-    CameraStreamMode m_last_mode = CameraStreamMode::none;
-    std::uint64_t m_webrtc_epoch = 0;
-    std::string m_agent_camera_url;
-    bool m_web_user_stopped = false;
     wxMediaState m_last_state = MEDIASTATE_IDLE;
     std::string m_machine;
     int m_lan_proto = 0;
@@ -109,11 +91,7 @@ private:
     bool m_disable_lan = false;
     wxString m_url;
 
-    struct MediaTask {
-        wxString command;
-        IMediaController *controller = nullptr;
-    };
-    std::deque<MediaTask> m_tasks;
+    std::deque<wxString> m_tasks;
     boost::mutex m_mutex;
     boost::condition_variable m_cond;
     boost::thread m_thread;

src/slic3r/GUI/Monitor.cpp

@@ -34,8 +34,6 @@
 
 #include "DeviceCore/DevManager.h"
 
-#include <boost/log/trivial.hpp>
-
 namespace Slic3r {
 namespace GUI {
 
@@ -267,7 +265,6 @@ void MonitorPanel::msw_rescale()
 
 void MonitorPanel::select_machine(std::string machine_sn)
 {
-    BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: MonitorPanel::select_machine queueing machine_sn=" << machine_sn;
     wxCommandEvent *event = new wxCommandEvent(wxEVT_COMMAND_CHOICE_SELECTED);
     event->SetString(machine_sn);
     wxQueueEvent(this, event);
@@ -276,10 +273,7 @@ void MonitorPanel::select_machine(std::string machine_sn)
 
 void MonitorPanel::on_timer(wxTimerEvent& event)
 {
-    // MediaPlayCtrl may yield the event loop while it joins its camera worker
-    // during window teardown. Do not let a queued monitor refresh touch panels
-    // that are already being destroyed.
-    if (!wxGetApp().is_closing() && update_flag) {
+    if (update_flag) {
         update_all();
         //Layout();
     }
@@ -288,20 +282,13 @@ void MonitorPanel::on_timer(wxTimerEvent& event)
 void MonitorPanel::on_select_printer(wxCommandEvent& event)
 {
     Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
-    const std::string requested_dev_id = event.GetString().ToStdString();
-    BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: MonitorPanel::on_select_printer requested_dev_id="
-                            << requested_dev_id << " device_manager=" << (dev ? "set" : "null");
     if (!dev) return;
 
     if ( dev->get_selected_machine() && (dev->get_selected_machine()->get_dev_id() != event.GetString().ToStdString()) && m_hms_panel) {
         m_hms_panel->clear_hms_tag();
     }
 
-    const bool selected = dev->set_selected_machine(requested_dev_id);
-    BOOST_LOG_TRIVIAL(trace) << "Orca diagnostic: MonitorPanel::on_select_printer set_selected_machine result="
-                            << selected << " selected_dev_id="
-                            << (dev->get_selected_machine() ? dev->get_selected_machine()->get_dev_id() : "<null>");
-    if (!selected)
+    if (!dev->set_selected_machine(event.GetString().ToStdString()))
         return;
 
     set_default();

src/slic3r/GUI/MultiMachine.cpp

@@ -51,7 +51,7 @@ void DeviceItem::sync_state()
             state_printable = 6;
         }
 
-        if (wxGetApp().is_blocking_printing(obj_)) {
+        if (is_blocking_printing(obj_)) {
             state_printable = 5;
         }
 
@@ -104,6 +104,27 @@ void DeviceItem::unselected()
     }
 }
 
+bool DeviceItem::is_blocking_printing(MachineObject* obj_)
+{
+    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
+    if (!dev) return true;
+    auto target_model = obj_->printer_type;
+    std::string source_model = "";
+
+    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
+    source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
+
+    if (source_model != target_model) {
+        std::vector<std::string> compatible_machine = obj_->get_compatible_machine();
+        vector<std::string>::iterator it = find(compatible_machine.begin(), compatible_machine.end(), source_model);
+        if (it == compatible_machine.end()) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 void DeviceItem::update_item(const DeviceItem* item)
 {
     // Except for the selected status, everything else is updated

src/slic3r/GUI/MultiMachine.hpp

@@ -59,6 +59,7 @@ public:
 
     void selected();
     void unselected();
+    bool is_blocking_printing(MachineObject* obj_);
     void update_item(const DeviceItem* item);
 };
 

src/slic3r/GUI/PartSkipDialog.hpp

@@ -159,4 +159,4 @@ private:
     void OnApplyDialog(wxCommandEvent &event);
 };
 
-}} // namespace Slic3r::GUI
+}} // namespace Slic3r::GUI

src/slic3r/GUI/Plater.cpp

@@ -2236,14 +2236,12 @@ bool Sidebar::priv::sync_extruder_list(bool &only_external_material, bool is_man
     std::string machine_print_name = obj->get_show_printer_type();
     PresetBundle *preset_bundle = wxGetApp().preset_bundle;
     std::string target_model_id  = preset_bundle->printers.get_selected_preset().get_printer_type(preset_bundle);
-    const bool optional_printer_model = DevPrinterConfigUtil::is_optional_printer_model_id(obj->printer_type);
-    const bool optional_target_model  = DevPrinterConfigUtil::is_optional_printer_model_id(target_model_id);
-    Preset* machine_preset = optional_printer_model ? nullptr : get_printer_preset(obj);
-    if (!optional_printer_model && !optional_target_model && !machine_preset) {
+    Preset* machine_preset = get_printer_preset(obj);
+    if (!machine_preset) {
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << "check error: machine_preset empty";
         return false;
     }
-    if (!optional_printer_model && !optional_target_model && machine_print_name != target_model_id) {
+    if (machine_print_name != target_model_id) {
         MessageDialog dlg(this->plater, _L("The currently selected machine preset is inconsistent with the connected printer type.\n"
                                             "Are you sure to continue syncing?"), _L("Sync printer information"), wxICON_WARNING | wxYES | wxNO);
         if (dlg.ShowModal() == wxID_NO) {
@@ -2435,11 +2433,6 @@ void Sidebar::priv::update_sync_status(const MachineObject *obj)
         return;
     }
 
-    if (DevPrinterConfigUtil::is_optional_printer_model_id(obj->printer_type)) {
-        clear_all_sync_status();
-        return;
-    }
-
     bool printer_synced = false;
     // 1. update printer status
     const Preset &cur_preset = wxGetApp().preset_bundle->printers.get_edited_preset();
@@ -6073,30 +6066,11 @@ void Sidebar::load_ams_list(MachineObject* obj)
         filament_ams_list = build_filament_ams_list(obj);
     }
 
+    bool device_change     = false;
     const std::string& device = obj ? obj->get_dev_id() : "";
-    const bool same_device = p->ams_list_device == device;
-
-    // Keep sync metadata out of the device payload, but preserve it across a
-    // subscription refresh when the physical filament in a slot is unchanged.
-    // Otherwise the refreshed configs differ only by the missing
-    // filament_changed key, causing combo boxes to rebuild and lose their
-    // transient post-sync badges.
-    auto &previous_filament_ams_list = wxGetApp().preset_bundle->filament_ams_list;
-    for (auto &entry : filament_ams_list) {
-        auto previous = previous_filament_ams_list.find(entry.first);
-        const auto *previous_changed = previous == previous_filament_ams_list.end() ? nullptr :
-                                       dynamic_cast<const ConfigOptionBool *>(previous->second.option("filament_changed"));
-        if (!same_device || previous_changed == nullptr ||
-            previous->second.opt_string("filament_id", 0u) != entry.second.opt_string("filament_id", 0u)) {
-            continue;
-        }
-        entry.second.set_key_value("filament_changed",
-                                   new ConfigOptionBool{previous_changed->value});
-    }
-
-    bool device_change     = !same_device;
-    if (device_change) {
+    if (p->ams_list_device != device) {
         p->ams_list_device = device;
+        device_change      = true;
     }
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1% items") % filament_ams_list.size();
     if (wxGetApp().preset_bundle->filament_ams_list == filament_ams_list && !device_change)
@@ -6106,27 +6080,9 @@ void Sidebar::load_ams_list(MachineObject* obj)
     wxGetApp().preset_bundle->filament_ams_list = filament_ams_list;
 
     for (auto c : p->combos_filament){
-        c->set_sync_badge(false);
         c->update();
-    }
-
-    if (!device_change) {
-        size_t combo_index = 0;
-        for (const auto &entry : filament_ams_list) {
-            const auto &tray = entry.second;
-            const bool has_filament = !tray.opt_string("filament_id", 0u).empty();
-            const bool is_placeholder = tray.has("filament_slot_placeholder") &&
-                                         tray.opt_bool("filament_slot_placeholder", 0u);
-            if (!has_filament && !is_placeholder) {
-                continue;
-            }
-            if (combo_index >= p->combos_filament.size()) {
-                break;
-            }
-            const auto *filament_changed = dynamic_cast<const ConfigOptionBool *>(tray.option("filament_changed"));
-            p->combos_filament[combo_index]->set_sync_badge(
-                has_filament && !is_placeholder && filament_changed != nullptr && filament_changed->value);
-            ++combo_index;
+        if (device_change) {
+            c->ShowBadge(false);//change printer,then clear badge
         }
     }
 
@@ -6300,32 +6256,18 @@ void Sidebar::sync_ams_list(bool is_from_big_sync_btn)
         auto tip     = sync_color_only ? _L("Only filament color information has been synchronized from printer.") :
                                          _L("Filament type and color information have been synchronized, but slot information is not included.");
         c->SetToolTip(tip);
-        c->set_sync_badge(true);
+        c->ShowBadge(true);
     };
     { // badge ams filament
         clear_combos_filament_badge();
         if (sync_result.direct_sync) {
-            // A placeholder contributes a preserved project filament to the
-            // overwrite result, but it is not AMS-sourced and must not get a
-            // sync badge. Non-placeholder empty trays are omitted entirely.
-            size_t combo_index = 0;
-            for (const auto &entry : wxGetApp().preset_bundle->filament_ams_list) {
-                const auto &tray = entry.second;
-                const bool has_filament = !tray.opt_string("filament_id", 0u).empty();
-                const bool is_placeholder = tray.has("filament_slot_placeholder") &&
-                                             tray.opt_bool("filament_slot_placeholder", 0u);
-                if (!has_filament && !is_placeholder) {
-                    continue;
-                }
-                if (combo_index >= p->combos_filament.size()) {
-                    break;
-                }
-                if (is_placeholder) {
-                    p->combos_filament[combo_index]->set_sync_badge(false);
-                } else {
-                    badge_combox_filament(p->combos_filament[combo_index]);
-                }
-                ++combo_index;
+            // Orca: PresetBundle::sync_ams_list rebuilds combos_filament
+            // 1:1 from the AMS trays that produce a combo (loaded trays + placeholders; non-placeholder
+            // empty trays are skipped), so every resulting combo is AMS-sourced and gets a badge. The
+            // previous per-tray index walked the full filament_ams_list (including the skipped empties),
+            // so an empty slot before a loaded one dropped the badge for the trailing filaments.
+            for (auto &c : p->combos_filament) {
+                badge_combox_filament(c);
             }
         }
     }
@@ -6593,11 +6535,6 @@ template<typename T> void setup_dialog_position(T& info)
 
 void Sidebar::pop_sync_nozzle_and_ams_dialog() {
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " begin pop_sync_nozzle_and_ams_dialog";
-    auto agent = wxGetApp().getAgent();
-    if (!agent || agent->get_filament_sync_mode() == FilamentSyncMode::none) {
-        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " filament synchronization is not supported; skipping dialog";
-        return;
-    }
     wxTheApp->CallAfter([this]() {
         SyncNozzleAndAmsDialog::InputInfo temp_na_info;
         wxPoint                           big_btn_pt;
@@ -6729,14 +6666,17 @@ void Sidebar::clear_combos_filament_badge()
 {
     auto &combos_filament = p->combos_filament;
     for (auto &c : combos_filament) { // clear flag
-        c->set_sync_badge(false);
+        c->ShowBadge(false);
     }
 }
 
 void Sidebar::udpate_combos_filament_badge() {
     auto &combos_filament = p->combos_filament;
     for (auto &c : combos_filament) {
-        c->update_badge_according_flag();
+        auto selection   = c->GetSelection();
+        auto select_flag = c->GetFlag(selection);
+        auto ok          = select_flag == (int) PresetComboBox::FilamentAMSType::FROM_AMS;
+        c->ShowBadge(ok);
     }
 
 }
@@ -12721,7 +12661,7 @@ void Plater::priv::on_select_preset(wxCommandEvent &evt)
             sidebar->auto_calc_flushing_volumes(idx);
         }
         auto select_flag = combo->GetFlag(selection);
-        combo->set_sync_badge(select_flag == (int)PresetComboBox::FilamentAMSType::FROM_AMS);
+        combo->ShowBadge(select_flag == (int)PresetComboBox::FilamentAMSType::FROM_AMS);
         q->on_filament_change(idx);
     }
     bool select_preset = !combo->selection_is_changed_according_to_physical_printers();
@@ -21395,14 +21335,9 @@ bool Plater::is_same_printer_for_connected_and_selected(bool popup_warning)
     }
     if (!check_printer_initialized(obj, true, popup_warning))
         return false;
-    const std::string machine_model = obj->printer_type;
-    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
-    const std::string selected_model = preset_bundle ? preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) : std::string();
-    if (!DevPrinterConfigUtil::is_optional_printer_model_id(machine_model) &&
-        !DevPrinterConfigUtil::is_optional_printer_model_id(selected_model) &&
-        !get_printer_preset(obj)) {
+    Preset *      machine_preset     = get_printer_preset(obj);
+    if (!machine_preset)
         return false;
-    }
 
     if (wxGetApp().is_blocking_printing()) {
         if (popup_warning) {

src/slic3r/GUI/PluginStatus.hpp

@@ -11,7 +11,6 @@ namespace Slic3r
             // IMPORTANT: ordinal order is the Plugins dialog Status sort priority.
             Activated,
             Error,
-            RuntimeError,
             Inactive,
             Loading
         };
@@ -22,28 +21,11 @@ namespace Slic3r
             {
             case PluginStatus::Activated: return "Activated";
             case PluginStatus::Error: return "Error";
-            case PluginStatus::RuntimeError: return "RuntimeError";
             case PluginStatus::Inactive: return "Inactive";
             case PluginStatus::Loading: return "Loading";
             }
 
             return "Inactive";
         }
-
-        // why: a plugin whose module is live but whose catalog carries an error is a
-        //   RUNTIME fault (e.g. a capability rejected at register time) - it stays
-        //   loaded/checked and is only flagged, distinct from a load-time Error where
-        //   the module never came up. Loading wins over both so an in-flight reload
-        //   never flashes an error.
-        inline PluginStatus resolve_plugin_status(bool loading, bool has_error, bool is_loaded)
-        {
-            if (loading)
-                return PluginStatus::Loading;
-            if (has_error)
-                return is_loaded ? PluginStatus::RuntimeError : PluginStatus::Error;
-            if (is_loaded)
-                return PluginStatus::Activated;
-            return PluginStatus::Inactive;
-        }
     }
 } // namespace Slic3r::GUI

src/slic3r/GUI/PluginsDialog.cpp

@@ -193,7 +193,6 @@ nlohmann::json build_plugin_payload_item(const PluginDialogItem& dialog_item)
     payload_item["label"]                 = dialog_item.display_name;
     payload_item["source"]                = to_string(dialog_item.source);
     payload_item["status"]                = to_string(dialog_item.status);
-    payload_item["is_loaded"]             = dialog_item.is_loaded;
     payload_item["error"]                 = dialog_item.error_text;
     payload_item["update_status"]         = to_string(dialog_item.update_status);
     payload_item["unauthorized"]          = dialog_item.unauthorized;
@@ -338,7 +337,14 @@ PluginDialogItem build_plugin_dialog_item(const PluginDescriptor& descriptor)
     item.sharing_token = descriptor.sharing_token;
     item.thumbnail_url = descriptor.thumbnail_url;
 
-    item.status = resolve_plugin_status(item.loading, item.has_error, item.is_loaded);
+    if (item.loading)
+        item.status = PluginStatus::Loading;
+    else if (item.has_error)
+        item.status = PluginStatus::Error;
+    else if (item.is_loaded)
+        item.status = PluginStatus::Activated;
+    else
+        item.status = PluginStatus::Inactive;
 
     item.available_actions        = evaluate_action_policy(item);
     const bool has_enabled_script = std::any_of(item.capabilities.begin(), item.capabilities.end(),
@@ -784,9 +790,6 @@ void PluginsDialog::toggle_plugin(const std::string& plugin_key, bool enabled)
         }
 
         BOOST_LOG_TRIVIAL(info) << "Plugin unloaded from Plugins dialog: " << plugin_key;
-        // A user-disabled plugin has no meaningful error state.
-        if (!manager.clear_plugin_error(plugin_key))
-            BOOST_LOG_TRIVIAL(warning) << "Failed to clear plugin error for " << plugin_key << " (failed to find)";
         // A prior activation of this plugin is moot now; drop it so no stale "Activated" arrives later.
         if (m_activating_plugin_key == plugin_key)
             m_activating_plugin_key.clear();

src/slic3r/GUI/PrePrintChecker.cpp

@@ -63,7 +63,6 @@ std::string PrePrintChecker::get_print_status_info(PrintDialogStatus status)
     case PrintStatusRackReading: return "PrintStatusRackReading";
     case PrintStatusRackNozzleNumUnmeetWarning: return "PrintStatusRackNozzleNumUnmeetWarning";
     case PrintStatusHasUnreliableNozzleWarning: return "PrintStatusHasUnreliableNozzleWarning";
-    case PrintStatusOptionalPrinterModel: return "PrintStatusOptionalPrinterModel";
     case PrintStatusWarningExtFilamentNotMatch: return "PrintStatusWarningExtFilamentNotMatch";
     case PrintStatusFilamentWarningNozzleHRC: return "PrintStatusFilamentWarningNozzleHRC";
     case PrintStatusTPUUnsupportCaliOn: return "PrintStatusTPUUnsupportCaliOn";
@@ -105,7 +104,6 @@ wxString PrePrintChecker::get_pre_state_msg(PrintDialogStatus status)
     case PrintStatusNeedConsistencyUpgrading: return _L("Cannot send the print job to a printer whose firmware must be updated.");
     case PrintStatusBlankPlate: return _L("Cannot send a print job for an empty plate.");
     case PrintStatusTimelapseNoSdcard: return _L("Storage needs to be inserted to record timelapse.");
-    case PrintStatusOptionalPrinterModel: return _L("The selected printer model could not be identified, so compatibility with the print file configuration cannot be verified. Please verify the printer preset before sending.");
     case PrintStatusMixAmsAndVtSlotWarning: return _L("You have selected both external and AMS filaments for an extruder. You will need to manually switch the external filament during printing.");
     case PrintStatusTPUUnsupportAutoCali: return _L("TPU 90A/TPU 85A is too soft and does not support automatic Flow Dynamics calibration.");
     case PrintStatusWarningKvalueNotUsed: return _L("Set dynamic flow calibration to 'OFF' to enable custom dynamic flow value.");
@@ -381,3 +379,4 @@ bool PrinterMsgPanel::UpdateInfos(const std::vector<prePrintInfo>& infos)
 }
 };
 
+

src/slic3r/GUI/PrePrintChecker.hpp

@@ -112,7 +112,6 @@ enum PrintDialogStatus : unsigned int {
     // Orca: a nozzle diameter that differs from the one the printer remembers is a warning,
     // not an error, so non-standard nozzles can still be printed with.
     PrintStatusNozzleDiameterMismatch,
-    PrintStatusOptionalPrinterModel,
     PrintStatusPrinterWarningEnd,
 
     // Warnings for filament
@@ -171,7 +170,7 @@ public:
     void add_with_checkbox(PrintDialogStatus state, wxString msg, wxString checkbox_label, bool checked, std::function<void(bool)> checkbox_callback);
     static ::std::string get_print_status_info(PrintDialogStatus status);
 
-	static wxString get_pre_state_msg(PrintDialogStatus status);
+	wxString get_pre_state_msg(PrintDialogStatus status);
     static bool is_error(PrintDialogStatus status) { return (PrintStatusErrorBegin < status) && (PrintStatusErrorEnd > status); };
     static bool is_error_printer(PrintDialogStatus status) { return (PrintStatusPrinterErrorBegin < status) && (PrintStatusPrinterErrorEnd > status); };
     static bool is_error_filament(PrintDialogStatus status) { return (PrintStatusFilamentErrorBegin < status) && (PrintStatusFilamentErrorEnd > status); };

src/slic3r/GUI/PresetComboBoxes.cpp

@@ -361,8 +361,7 @@ wxString PresetComboBox::get_preset_item_name(unsigned int index)
                 return GetString(index);
             }
 
-            std::map<std::string, MachineObject *> machine_list =
-                dev->get_my_machine_list(dev->get_current_printer_agent_id());
+            std::map<std::string, MachineObject *> machine_list = dev->get_my_machine_list();
             if (machine_list.empty()) {
                 assert(false);
                 m_selected_dev_id.clear();
@@ -480,8 +479,7 @@ void PresetComboBox::add_connected_printers(std::string selected, bool alias_nam
     if (!dev)
         return;
 
-    std::map<std::string, MachineObject *> machine_list =
-        dev->get_my_machine_list(dev->get_current_printer_agent_id());
+    std::map<std::string, MachineObject *> machine_list = dev->get_my_machine_list();
     if (machine_list.empty())
         return;
 
@@ -1001,13 +999,7 @@ void PlaterPresetComboBox::update_badge_according_flag() {
     auto selection   = GetSelection();
     auto select_flag = GetFlag(selection);
     auto ok          = select_flag == (int) PresetComboBox::FilamentAMSType::FROM_AMS;
-    ShowBadge(m_sync_badge || ok);
-}
-
-void PlaterPresetComboBox::set_sync_badge(bool show)
-{
-    m_sync_badge = show;
-    ShowBadge(show);
+    ShowBadge(ok);
 }
 
 bool PlaterPresetComboBox::switch_to_tab()

src/slic3r/GUI/PresetComboBoxes.hpp

@@ -205,7 +205,6 @@ public:
     void msw_rescale() override;
     void OnSelect(wxCommandEvent& evt) override;
     void update_badge_according_flag();
-    void set_sync_badge(bool show);
 
     FilamentColor get_cur_color_info();
     void show_default_color_picker();
@@ -215,7 +214,6 @@ public:
 private:
     // BBS
     wxColor m_color;
-    bool    m_sync_badge{false};
 };
 
 

src/slic3r/GUI/ReleaseNote.cpp

@@ -20,19 +20,15 @@
 #include <wx/progdlg.h>
 #include <wx/clipbrd.h>
 #include <wx/dcgraph.h>
-#include <wx/filedlg.h>
 #include <miniz.h>
 #include <algorithm>
-#include <cctype>
 #include "Plater.hpp"
 #include "BitmapCache.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "DeviceCore/DevManager.h"
 #include "DeviceCore/DevStorage.h"
-#include "../Utils/Http.hpp"
 #include "md4c/src/md4c-html.h"
-#include "../Utils/Http.hpp"
 
 namespace Slic3r { namespace GUI {
 
@@ -1465,45 +1461,6 @@ InputIpAddressDialog::InputIpAddressDialog(wxWindow *parent)
     m_input_top_sizer->Add(0, 0, 0, wxTOP, FromDIP(4));
     m_input_top_sizer->Add(m_input_area, 0, wxRIGHT | wxEXPAND, FromDIP(18));
 
-    m_tips_cafile = new Label(ip_input_top_panel, _L("HTTPS CA File"));
-    m_input_cafile = new wxTextCtrl(ip_input_top_panel, wxID_ANY);
-    m_input_cafile->SetMinSize(wxSize(FromDIP(260), FromDIP(28)));
-    m_input_cafile->SetMaxSize(wxSize(FromDIP(260), FromDIP(28)));
-
-    m_button_cafile = new Button(ip_input_top_panel, _L("Browse") + " " + dots);
-    m_button_cafile->SetStyle(ButtonStyle::Regular, ButtonType::Parameter);
-    m_button_cafile->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
-        static const auto filemasks = _L("Certificate files (*.crt, *.pem)|*.crt;*.pem|All files|*.*");
-        wxFileDialog openFileDialog(this, _L("Open CA certificate file"), "", "", filemasks,
-                                    wxFD_OPEN | wxFD_FILE_MUST_EXIST);
-        if (openFileDialog.ShowModal() != wxID_CANCEL)
-            m_input_cafile->SetValue(openFileDialog.GetPath());
-    });
-
-    auto cafile_input_sizer = new wxBoxSizer(wxHORIZONTAL);
-    cafile_input_sizer->Add(m_input_cafile, 1, wxALIGN_CENTER_VERTICAL);
-    cafile_input_sizer->Add(m_button_cafile, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, FromDIP(10));
-
-    m_cafile_hint = new Label(ip_input_top_panel, _L("HTTPS CA file is optional. It is only needed if you use HTTPS with a self-signed certificate."));
-    m_cafile_hint->Wrap(FromDIP(352));
-
-    m_input_top_sizer->Add(m_tips_cafile, 0, wxTOP | wxEXPAND, FromDIP(10));
-    m_input_top_sizer->Add(cafile_input_sizer, 0, wxTOP | wxEXPAND, FromDIP(4));
-    m_input_top_sizer->Add(m_cafile_hint, 0, wxTOP | wxEXPAND, FromDIP(4));
-
-    if (!Http::ca_file_supported()) {
-        m_input_cafile->Disable();
-        m_button_cafile->Disable();
-        m_cafile_hint->SetLabel(_L("This system uses HTTPS certificates from the system Certificate Store or Keychain. To use a custom CA file, import it there."));
-        m_cafile_hint->Wrap(FromDIP(352));
-    }
-
-    if (wxGetApp().preset_bundle) {
-        const auto& config = wxGetApp().preset_bundle->printers.get_edited_preset().config;
-        if (config.has("printhost_cafile"))
-            m_input_cafile->SetValue(from_u8(config.opt_string("printhost_cafile")));
-    }
-
     ip_input_top_panel->SetSizer(m_input_top_sizer);
     ip_input_top_panel->Layout();
     ip_input_top_panel->Fit();
@@ -1779,8 +1736,7 @@ void InputIpAddressDialog::set_machine_obj(MachineObject* obj)
     auto str_ip = m_input_ip->GetTextCtrl()->GetValue();
     auto str_access_code = m_input_access_code->GetTextCtrl()->GetValue();
     // ORCA enabling / disabling buttons with conditions enough to change its style
-    m_button_ok->Enable(isValidEndpoint(str_ip.ToStdString()) &&
-                        (str_access_code.IsEmpty() || str_access_code.Length() >= 8));
+    m_button_ok->Enable(isIp(str_ip.ToStdString()) && str_access_code.Length() == 8);
 
     Layout();
     Fit();
@@ -1817,29 +1773,19 @@ void InputIpAddressDialog::update_test_msg(wxString msg,bool connected)
     Fit();
 }
 
-bool InputIpAddressDialog::isValidEndpoint(std::string endpoint)
+bool InputIpAddressDialog::isIp(std::string ipstr)
 {
-    if (endpoint.empty() || std::any_of(endpoint.begin(), endpoint.end(), [](unsigned char c) {
-            return std::isspace(c) != 0;
-        }))
-        return false;
-
-    const bool has_http_scheme = endpoint.rfind("http://", 0) == 0;
-    const bool has_https_scheme = endpoint.rfind("https://", 0) == 0;
-    const auto scheme_pos = endpoint.find("://");
-    if (scheme_pos != std::string::npos && !has_http_scheme && !has_https_scheme)
-        return false;
-
-    std::string port;
-    const std::string host = Http::get_host_from_url(endpoint, &port);
-    if (host.empty())
-        return false;
-
-    // get_host_from_url returns its input when libcurl cannot parse it. For a
-    // URL with a scheme, that means a failed parse still needs to be rejected.
-    if (scheme_pos != std::string::npos && host == endpoint)
-        return false;
-
+    istringstream ipstream(ipstr);
+    int num[4];
+    char point[3];
+    string end;
+    ipstream >> num[0] >> point[0] >> num[1] >> point[1] >> num[2] >> point[2] >> num[3] >> end;
+    for (int i = 0; i < 3; ++i) {
+        if (num[i] < 0 || num[i]>255) return false;
+        if (point[i] != '.') return false;
+    }
+    if (num[3] < 0 || num[3]>255) return false;
+    if (!end.empty()) return false;
     return true;
 }
 
@@ -1855,8 +1801,6 @@ void InputIpAddressDialog::on_ok(wxMouseEvent& evt)
     m_trouble_shoot->Hide();
     std::string str_ip = m_input_ip->GetTextCtrl()->GetValue().ToStdString();
     std::string str_access_code = m_input_access_code->GetTextCtrl()->GetValue().ToStdString();
-    if (str_access_code.empty())
-        str_access_code = "88888888";
     std::string str_name = m_input_printer_name->GetTextCtrl()->GetValue().Strip(wxString::both).ToStdString();
     // Serial number should not contain lower case letters, and bambu_network plugin crashes
     // if user entered the wrong serial number, so we call `Upper()` here.
@@ -1876,17 +1820,6 @@ void InputIpAddressDialog::on_ok(wxMouseEvent& evt)
     Layout();
     Fit();
 
-    if (wxGetApp().preset_bundle) {
-        auto& config = wxGetApp().preset_bundle->printers.get_edited_preset().config;
-        std::string port;
-        Http::get_host_from_url(str_ip, &port);
-        config.opt_string("print_host") = str_ip;
-        if (!port.empty())
-            config.opt_string("printhost_port") = port;
-        if (Http::ca_file_supported())
-            config.opt_string("printhost_cafile") = m_input_cafile->GetValue().ToStdString();
-    }
-
     token_.reset(this, nop_deleter);
     m_thread = new boost::thread(boost::bind(&InputIpAddressDialog::workerThreadFunc, this, str_ip, str_access_code, str_sn, str_model_id, str_name));
 }
@@ -1902,8 +1835,6 @@ void InputIpAddressDialog::on_send_retry()
     Fit();
     wxString ip              = m_input_ip->GetTextCtrl()->GetValue();
     wxString str_access_code = m_input_access_code->GetTextCtrl()->GetValue();
-    if (str_access_code.IsEmpty())
-        str_access_code = "88888888";
 
     // check support function
     if (!m_obj) return;
@@ -2125,7 +2056,7 @@ void InputIpAddressDialog::on_text(wxCommandEvent &evt)
     auto str_ip              = m_input_ip->GetTextCtrl()->GetValue();
     auto str_access_code     = m_input_access_code->GetTextCtrl()->GetValue();
 
-    if (str_access_code.IsEmpty()) {
+    if (str_access_code.empty()) {
         str_access_code = "88888888";
     }
 
@@ -2141,8 +2072,7 @@ void InputIpAddressDialog::on_text(wxCommandEvent &evt)
     }
 
     // ORCA enabling / disabling buttons with conditions enough to change its style
-    bool valid_access_code_length = str_access_code.IsEmpty() || str_access_code.Length() >= 8;
-    bool enable_btns = isValidEndpoint(str_ip.ToStdString()) && valid_access_code_length && invalid_access_code;
+    bool enable_btns = isIp(str_ip.ToStdString()) && str_access_code.Length() == 8 && invalid_access_code;
     m_button_manual_setup->Enable(enable_btns);
     m_button_ok->Enable(enable_btns);
 
@@ -2157,7 +2087,7 @@ InputIpAddressDialog::~InputIpAddressDialog()
 
 void InputIpAddressDialog::on_dpi_changed(const wxRect& suggested_rect)
 {
-    m_button_cafile->Rescale();
+
 }
 
 

src/slic3r/GUI/ReleaseNote.hpp

@@ -315,16 +315,12 @@ public:
     Button* m_button_manual_setup{ nullptr };
     Label* m_tips_ip{ nullptr };
     Label* m_tips_access_code{ nullptr };
-    Label* m_tips_cafile{ nullptr };
-    Label* m_cafile_hint{ nullptr };
     Label* m_tips_sn{nullptr};
     Label* m_tips_modelID{nullptr};
     Label* m_test_right_msg{ nullptr };
     Label* m_test_wrong_msg{ nullptr };
     TextInput* m_input_ip{ nullptr };
     TextInput* m_input_access_code{ nullptr };
-    wxTextCtrl* m_input_cafile{ nullptr };
-    Button* m_button_cafile{ nullptr };
     TextInput* m_input_printer_name{ nullptr };
     TextInput* m_input_sn{ nullptr };
     ComboBox*  m_input_modelID{ nullptr };
@@ -348,7 +344,7 @@ public:
     void update_title(wxString title);
     void set_machine_obj(MachineObject* obj);
     void update_test_msg(wxString msg, bool connected);
-    bool isValidEndpoint(std::string endpoint);
+    bool isIp(std::string ipstr);
     void check_ip_address_failed(int result);
     void on_check_ip_address_failed(wxCommandEvent& evt);
     void on_ok(wxMouseEvent& evt);

src/slic3r/GUI/SelectMachine.cpp

@@ -21,7 +21,6 @@
 #include "Jobs/PlaterWorker.hpp"
 
 #include "DeviceCore/DevConfig.h"
-#include "DeviceCore/DevConfigUtil.h"
 #include "DeviceCore/DevNozzleSystem.h"
 #include "DeviceCore/DevNozzleRack.h"
 #include "DeviceCore/DevExtensionTool.h"
@@ -1129,10 +1128,7 @@ bool SelectMachineDialog::do_ams_mapping(MachineObject *obj_,bool use_ams)
 
     int filament_result = 0;
     std::vector<bool> map_opt;  //four values: use_left_ams, use_right_ams, use_left_ext, use_right_ext
-    // Orca: only do the per-physical-extruder left/right split when the device actually reports
-    // 2+ extruders. A non-BBL multi-nozzle printer (e.g. Snapmaker U1) reports a single extruder
-    // with one filament pool, so it maps as a single surface via the else branch below.
-    if (nozzle_nums > 1 && obj_->GetExtderSystem()->GetTotalExtderCount() > 1){
+    if (nozzle_nums > 1){
         //get nozzle property, the extders are same?
         if (true/*!can_hybrid_mapping(obj_get_extder_data())*/){
             std::vector<FilamentInfo>           m_ams_mapping_result_left, m_ams_mapping_result_right;
@@ -2291,7 +2287,9 @@ void SelectMachineDialog::show_status(PrintDialogStatus status, std::vector<wxSt
         // Fill the real per-printer max color count into the %s template.
         if (!params.empty())
             msg = wxString::Format(m_pre_print_checker.get_pre_state_msg(status), params[0], params[0]);
-    } else if (status == PrintDialogStatus::PrintStatusAmsMappingU0Invalid) {
+    }
+
+    else if (status == PrintDialogStatus::PrintStatusAmsMappingU0Invalid) {
         wxString msg_text;
         if (params.size() > 1)
             msg_text = wxString::Format(_L("Filament %s does not match the filament in AMS slot %s. Please update the printer firmware to support AMS slot assignment."), params[0], params[1]);
@@ -2317,10 +2315,8 @@ void SelectMachineDialog::show_status(PrintDialogStatus status, std::vector<wxSt
     } else if (status == PrintDialogStatus::PrintStatusNoSdcard) {
         Enable_Refresh_Button(true);
         Enable_Send_Button(false);
-    } else if (status == PrintDialogStatus::PrintStatusUnsupportedPrinter ||
-              status == PrintDialogStatus::PrintStatusOptionalPrinterModel) {
+    }else if (status == PrintDialogStatus::PrintStatusUnsupportedPrinter) {
         wxString msg_text;
-        const bool block_send = status == PrintDialogStatus::PrintStatusUnsupportedPrinter;
         try
         {
             DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
@@ -2346,21 +2342,17 @@ void SelectMachineDialog::show_status(PrintDialogStatus status, std::vector<wxSt
 
             auto target_print_name = wxString(DevPrinterConfigUtil::get_printer_display_name(target_model_id));
             target_print_name.Replace(wxT("Bambu Lab "), wxEmptyString);
-            if (block_send) {
-                msg_text = wxString::Format(_L("The selected printer (%s) is incompatible with the print file configuration (%s). Please adjust the printer preset in the prepare page or choose a compatible printer on this page."), sourcet_print_name, target_print_name);
-            } else {
-                msg_text = wxString::Format(_L("The selected printer (%s) has an unknown model, so compatibility with the print file configuration (%s) cannot be verified. Please verify the printer preset before sending."), sourcet_print_name, target_print_name);
-            }
+            msg_text = wxString::Format(_L("The selected printer (%s) is incompatible with the print file configuration (%s). Please adjust the printer preset in the prepare page or choose a compatible printer on this page."), sourcet_print_name, target_print_name);
 
 
             msg = msg_text;
             Enable_Refresh_Button(true);
-            Enable_Send_Button(!block_send);
+            Enable_Send_Button(false);
         }
         catch (...)
         {
             Enable_Refresh_Button(true);
-            Enable_Send_Button(!block_send);
+            Enable_Send_Button(false);
         }
 
 
@@ -2521,13 +2513,31 @@ void SelectMachineDialog::on_cancel(wxCloseEvent &event)
 
 bool SelectMachineDialog::is_blocking_printing(MachineObject* obj_)
 {
-    if (m_print_type == PrintFromType::FROM_NORMAL)
-        return wxGetApp().is_blocking_printing(obj_);
+    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
+    if (!dev) return true;
+    auto target_model = obj_->printer_type;
+    std::string source_model = "";
 
-    std::string source_model;
-    if (m_print_type == PrintFromType::FROM_SDCARD_VIEW && !m_required_data_plate_data_list.empty())
-        source_model = m_required_data_plate_data_list[m_print_plate_idx]->printer_model_id;
-    return wxGetApp().is_blocking_printing(obj_, source_model);
+    if (m_print_type == PrintFromType::FROM_NORMAL) {
+        PresetBundle* preset_bundle = wxGetApp().preset_bundle;
+        source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
+
+
+    }else if (m_print_type == PrintFromType::FROM_SDCARD_VIEW) {
+        if (m_required_data_plate_data_list.size() > 0) {
+            source_model = m_required_data_plate_data_list[m_print_plate_idx]->printer_model_id;
+        }
+    }
+
+    if (source_model != target_model) {
+        std::vector<std::string> compatible_machine = obj_->get_compatible_machine();
+        vector<std::string>::iterator it = find(compatible_machine.begin(), compatible_machine.end(), source_model);
+        if (it == compatible_machine.end()) {
+            return true;
+        }
+    }
+
+    return false;
 }
 
 static std::unordered_set<int> _get_used_nozzle_idxes()
@@ -2615,10 +2625,6 @@ bool SelectMachineDialog::is_same_printer_model()
     if(preset_bundle == nullptr) return result;
     const auto source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
     const auto target_model = obj_->printer_type;
-    if (DevPrinterConfigUtil::is_optional_printer_model_id(source_model) ||
-        DevPrinterConfigUtil::is_optional_printer_model_id(target_model)) {
-        return true;
-    }
     // Orca: ignore P1P -> P1S
     if (source_model != target_model) {
         if ((source_model == "C12" && target_model == "C11") || (source_model == "C11" && target_model == "C12") ||
@@ -3693,32 +3699,10 @@ void SelectMachineDialog::on_send_print()
     m_print_job->on_success([this]() { finish_mode(); });
 
     m_print_job->on_check_ip_address_fail([this]() {
-        // Invoked from the PrintJob worker thread when the LAN pre-flight (file upload
-        // verification) fails. Marshal device/UI access to the main thread.
-        CallAfter([this]()
-        {
-            // Reset the dialog out of sending mode so the user can retry.
-            wxCommandEvent* evt = new wxCommandEvent(EVT_CLEAR_IPADDRESS);
-            wxQueueEvent(this, evt);
-
-            DeviceManager* dev = wxGetApp().getDeviceManager();
-            MachineObject* obj = dev ? dev->get_selected_machine() : nullptr;
-
-            if (obj && obj->is_connected())
-            {
-                // Connected: failed on file upload
-                MessageDialog dlg(this,
-                                  _L("Failed to upload the file to the printer's storage. Please try again."),
-                                  _L("Send Failed"), wxOK | wxICON_ERROR);
-                dlg.ShowModal();
-            }
-            else
-            {
-                // Not connected: reenter ip and access code
-                wxGetApp().show_ip_address_enter_dialog();
-            }
-        });
-    });
+        wxCommandEvent* evt = new wxCommandEvent(EVT_CLEAR_IPADDRESS);
+        wxQueueEvent(this, evt);
+        wxGetApp().show_ip_address_enter_dialog();
+     });
 
     // update ota version
     NetworkAgent* agent = wxGetApp().getAgent();
@@ -4552,13 +4536,11 @@ bool SelectMachineDialog::CheckErrorExtruderNozzleWithSlicing(MachineObject* obj
 
             // check nozzle data valid
             {
-                // Commented out the following as ntUndefine and 0.0f are default values
-                // (signifying that the value is not given) that should PASS, not fail
-                // if (installed_ext_nozzle.GetNozzleType() == NozzleType::ntUndefine ||
-                //     installed_ext_nozzle.GetNozzleDiameter() <= 0.0f) {
-                //     show_status(PrintDialogStatus::PrintStatusNozzleDataInvalid);
-                //     return false;
-                // }
+                if (installed_ext_nozzle.GetNozzleType() == NozzleType::ntUndefine ||
+                    installed_ext_nozzle.GetNozzleDiameter() <= 0.0f) {
+                    show_status(PrintDialogStatus::PrintStatusNozzleDataInvalid);
+                    return false;
+                }
 
                 if (obj_->is_nozzle_flow_type_supported() &&
                     installed_ext_nozzle.GetNozzleFlowType() == NozzleFlowType::NONE_FLOWTYPE) {
@@ -4587,10 +4569,7 @@ bool SelectMachineDialog::CheckErrorExtruderNozzleWithSlicing(MachineObject* obj
 
             // check nozzle diameter
             {
-                // 0.0f is default when there is no nozzle diameter is given.
-                // In nozzle_diameter == 0.0f case, it passes and does not require a comparison
-                if (installed_ext_nozzle.GetNozzleDiameter() > 0.0f &&
-                    slicing_ext.nozzle_diameter != installed_ext_nozzle.GetNozzleDiameter()) {
+                if (slicing_ext.nozzle_diameter != installed_ext_nozzle.GetNozzleDiameter()) {
                     std::vector<wxString> msg_params;
                     if (ext_sys->GetTotalExtderCount() == 2) {
                         const wxString& mismatch_nozzle_str = _get_nozzle_name(ext_sys->GetTotalExtderCount(), slicing_ext_idx);
@@ -4784,22 +4763,6 @@ void SelectMachineDialog::update_show_status(MachineObject* obj_)
         return;
     }
 
-    bool has_optional_printer_model = DevPrinterConfigUtil::is_optional_printer_model_id(obj_->printer_type);
-    if (m_print_type == PrintFromType::FROM_NORMAL) {
-        PresetBundle* preset_bundle = wxGetApp().preset_bundle;
-        has_optional_printer_model = has_optional_printer_model ||
-            (preset_bundle && DevPrinterConfigUtil::is_optional_printer_model_id(
-                preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle)));
-    } else if (m_print_type == PrintFromType::FROM_SDCARD_VIEW && !m_required_data_plate_data_list.empty()) {
-        has_optional_printer_model = has_optional_printer_model ||
-            DevPrinterConfigUtil::is_optional_printer_model_id(
-                m_required_data_plate_data_list[m_print_plate_idx]->printer_model_id);
-    }
-
-    if (has_optional_printer_model) {
-        show_status(PrintDialogStatus::PrintStatusOptionalPrinterModel);
-    }
-
     if (is_blocking_printing(obj_)) {
         show_status(PrintDialogStatus::PrintStatusUnsupportedPrinter);
         return;
@@ -5522,8 +5485,8 @@ void SelectMachineDialog::reset_and_sync_ams_list()
                 item = new MaterialItem(m_filament_left_panel, colour_rgb, _L(display_materials[extruder]));
                 m_sizer_ams_mapping_left->Add(item, 0, wxALL, FromDIP(5));
             }
-            else // map == 2, or (non-BBL multi-nozzle) 3+; update_material_item_pos() collapses
-            {    // these into the single panel when the device reports < 2 extruders.
+            else if (m_filaments_map[extruder] == 2)
+            {
                 item = new MaterialItem(m_filament_right_panel, colour_rgb, _L(display_materials[extruder]));
                 m_sizer_ams_mapping_right->Add(item, 0, wxALL, FromDIP(5));
             }

src/slic3r/GUI/SendMultiMachinePage.cpp

@@ -738,7 +738,7 @@ void SendMultiMachinePage::on_send(wxCommandEvent& event)
 
         if (obj && obj->is_online() && !obj->can_abort() && !obj->is_in_upgrading() && it->second->get_state_selected() == 1 && it->second->state_printable <= 2) {
 
-            if (!wxGetApp().is_blocking_printing(obj)) {
+            if (!it->second->is_blocking_printing(obj)) {
                 PrintParams params = request_params(obj);
                 print_params.push_back(params);
             }

src/slic3r/GUI/SendToPrinter.cpp

@@ -24,7 +24,6 @@
 #include "BitmapCache.hpp"
 
 #include "DeviceCore/DevManager.h"
-#include "DeviceCore/DevConfigUtil.h"
 #include "DeviceCore/DevStorage.h"
 #include "slic3r/Utils/FileTransferUtils.hpp"
 
@@ -301,7 +300,7 @@ SendToPrinterDialog::SendToPrinterDialog(Plater *plater)
     m_storage_panel->Layout();
 
     // try to connect
-    m_statictext_printer_msg = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(FromDIP(400), -1), wxALIGN_CENTER_HORIZONTAL);
+    m_statictext_printer_msg = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_CENTER_HORIZONTAL);
     m_statictext_printer_msg->SetFont(::Label::Body_13);
     m_statictext_printer_msg->SetForegroundColour(*wxBLACK);
     m_statictext_printer_msg->Hide();
@@ -761,25 +760,9 @@ void SendToPrinterDialog::update_priner_status_msg(wxString msg, bool is_warning
         if (str_new != str_old) {
             if (m_statictext_printer_msg->GetLabel() != msg) {
                 m_statictext_printer_msg->SetLabel(msg);
-                const int wrap_width = FromDIP(400);
-                m_statictext_printer_msg->Wrap(wrap_width);
-                int line_count = 1;
-                const wxString wrapped_label = m_statictext_printer_msg->GetLabel();
-                for (size_t i = 0; i < wrapped_label.length(); ++i) {
-                    if (wrapped_label[i] == '\n')
-                        ++line_count;
-                }
-                wxCoord text_width = 0;
-                wxCoord text_height = 0;
-                m_statictext_printer_msg->GetTextExtent(msg, &text_width, &text_height);
-                const int extent_line_count = text_width > 0 ?
-                    std::max(1, (static_cast<int>(text_width) + wrap_width - 1) / wrap_width) : 1;
-                line_count = std::max(line_count, extent_line_count);
-                const int line_height = std::max(m_statictext_printer_msg->GetCharHeight(), static_cast<int>(text_height));
-                const int min_height = std::max(m_statictext_printer_msg->GetBestSize().GetHeight(),
-                                                line_count * line_height + FromDIP(2));
-                m_statictext_printer_msg->SetMinSize(wxSize(wrap_width, min_height));
-                m_statictext_printer_msg->SetMaxSize(wxDefaultSize);
+                m_statictext_printer_msg->SetMinSize(wxSize(FromDIP(400), -1));
+                m_statictext_printer_msg->SetMaxSize(wxSize(FromDIP(400), -1));
+                m_statictext_printer_msg->Wrap(FromDIP(400));
                 m_statictext_printer_msg->Show();
                 Layout();
                 Fit();
@@ -1119,7 +1102,7 @@ void SendToPrinterDialog::update_user_printer()
     wxArrayString                         machine_list_name;
     std::map<std::string, MachineObject*> option_list;
 
-    option_list = dev->get_my_machine_list(dev->get_current_printer_agent_id());
+    option_list = dev->get_my_machine_list();
 
     // same machine only appear once
     for (auto it = option_list.begin(); it != option_list.end(); it++) {
@@ -1277,7 +1260,7 @@ void SendToPrinterDialog::update_show_status()
     reset_timeout();
 
     // reading done
-    if (wxGetApp().is_blocking_printing(obj_)) {
+    if (is_blocking_printing(obj_)) {
         show_status(PrintDialogStatus::PrintStatusUnsupportedPrinter);
         return;
     }
@@ -1342,6 +1325,26 @@ void SendToPrinterDialog::update_show_status()
     }
 }
 
+bool SendToPrinterDialog::is_blocking_printing(MachineObject* obj_)
+{
+    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
+    if (!dev) return true;
+
+    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
+    auto source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
+    auto target_model = obj_->printer_type;
+
+    if (source_model != target_model) {
+        std::vector<std::string> compatible_machine = obj_->get_compatible_machine();
+        vector<std::string>::iterator it = find(compatible_machine.begin(), compatible_machine.end(), source_model);
+        if (it == compatible_machine.end()) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 void SendToPrinterDialog::Enable_Refresh_Button(bool en)
 {
     if (!en) {
@@ -1410,68 +1413,79 @@ void SendToPrinterDialog::show_status(PrintDialogStatus status, std::vector<wxSt
 		update_print_status_msg(wxEmptyString, false, false);
 		Enable_Send_Button(false);
 		Enable_Refresh_Button(true);
-	} else if (status == PrintDialogStatus::PrintStatusInvalidPrinter) {
+	}
+	else if (status == PrintDialogStatus::PrintStatusInvalidPrinter) {
 		update_print_status_msg(wxEmptyString, true, true);
 		Enable_Send_Button(false);
 		Enable_Refresh_Button(true);
-	} else if (status == PrintDialogStatus::PrintStatusConnectingServer) {
+	}
+	else if (status == PrintDialogStatus::PrintStatusConnectingServer) {
 		wxString msg_text = _L("Connecting to server...");
 		update_print_status_msg(msg_text, true, true);
 		Enable_Send_Button(true);
 		Enable_Refresh_Button(true);
-    } else if (status == PrintDialogStatus::PrintStatusReading) {
+    }
+    else if (status == PrintDialogStatus::PrintStatusReading) {
         wxString msg_text = _L("Synchronizing device information...");
         update_print_status_msg(msg_text, false, true);
         Enable_Send_Button(false);
         Enable_Refresh_Button(false);
-    } else if (status == PrintDialogStatus::PrintStatusReadingFinished) {
+    }
+
+	else if (status == PrintDialogStatus::PrintStatusReadingFinished) {
 		update_print_status_msg(wxEmptyString, false, true);
 		Enable_Send_Button(true);
 		Enable_Refresh_Button(true);
-	} else if (status == PrintDialogStatus::PrintStatusReadingTimeout) {
+	}
+	else if (status == PrintDialogStatus::PrintStatusReadingTimeout) {
 		wxString msg_text = _L("Synchronizing device information timed out.");
 		update_print_status_msg(msg_text, true, true);
 		Enable_Send_Button(true);
 		Enable_Refresh_Button(true);
-	} else if (status == PrintDialogStatus::PrintStatusInUpgrading) {
+	}
+	else if (status == PrintDialogStatus::PrintStatusInUpgrading) {
 		wxString msg_text = _L("Cannot send print tasks when an update is in progress");
 		update_print_status_msg(msg_text, true, true);
 		Enable_Send_Button(false);
 		Enable_Refresh_Button(true);
-	} else if (status == PrintDialogStatus::PrintStatusUnsupportedPrinter) {
+	}
+    else if (status == PrintDialogStatus::PrintStatusUnsupportedPrinter) {
         wxString msg_text = _L("The selected printer is incompatible with the chosen printer presets.");
         update_print_status_msg(msg_text, true, true);
-        Enable_Send_Button(true);
+        Enable_Send_Button(false);
         Enable_Refresh_Button(true);
-    } else if (status == PrintDialogStatus::PrintStatusRefreshingMachineList) {
+    }
+	else if (status == PrintDialogStatus::PrintStatusRefreshingMachineList) {
 		update_print_status_msg(wxEmptyString, false, true);
 		Enable_Send_Button(false);
 		Enable_Refresh_Button(false);
-	} else if (status == PrintDialogStatus::PrintStatusSending) {
+	}
+	else if (status == PrintDialogStatus::PrintStatusSending) {
 		Enable_Send_Button(false);
 		Enable_Refresh_Button(false);
-	} else if (status == PrintDialogStatus::PrintStatusSendingCanceled) {
+	}
+	else if (status == PrintDialogStatus::PrintStatusSendingCanceled) {
 		Enable_Send_Button(true);
 		Enable_Refresh_Button(true);
-	} else if (status == PrintDialogStatus::PrintStatusNoSdcard) {
+	}
+	else if (status == PrintDialogStatus::PrintStatusNoSdcard) {
 		wxString msg_text = _L("Storage needs to be inserted before send to printer.");
 		update_print_status_msg(msg_text, true, true);
 		Enable_Send_Button(false);
 		Enable_Refresh_Button(true);
-    } else if (status == PrintDialogStatus::PrintStatusNotOnTheSameLAN) {
+    }
+    else if (status == PrintDialogStatus::PrintStatusNotOnTheSameLAN) {
         wxString msg_text = _L("The printer is required to be on the same LAN as Orca Slicer.");
         update_print_status_msg(msg_text, true, true);
         Enable_Send_Button(false);
         Enable_Refresh_Button(true);
-    } else if (status == PrintDialogStatus::PrintStatusNotSupportedSendToSDCard) {
+    }
+    else if (status == PrintDialogStatus::PrintStatusNotSupportedSendToSDCard) {
         wxString msg_text = _L("The printer does not support sending to printer storage.");
         update_print_status_msg(msg_text, true, true);
         Enable_Send_Button(false);
         Enable_Refresh_Button(true);
     } else if (status == PrintDialogStatus::PrintStatusPublicInitFailed) {
-        wxString msg_text = _L(
-            "Failed to initialize the printer file transfer. Please check the connection and try again.");
-        update_print_status_msg(msg_text, true, true);
         Enable_Send_Button(false);
         Enable_Refresh_Button(true);
     } else if (status == PrintDialogStatus::PrintStatusPublicUploadFiled) {
@@ -1649,18 +1663,30 @@ extern void     refresh_agora_url(char const *device, char const *dev_ver, char
 void SendToPrinterDialog::GetConnection()
 {
     DeviceManager *dm  = GUI::wxGetApp().getDeviceManager();
-    MachineObject *obj = dm ? dm->get_selected_machine() : nullptr;
 
-    if (!obj)
+    MachineObject *obj = dm->get_selected_machine();
+    if (obj == nullptr) {
         BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : obj is empty";
-    if (obj && !obj->get_file_remote())
+        m_connection_status = ConnectionStatus::NOT_START;
+    }
+
+    int remote_proto = obj->get_file_remote();
+    if (!remote_proto) {
         BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : remote_proto is not support";
-    if (obj && obj->is_camera_busy_off())
-    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : camera is busy";
+        m_connection_status = ConnectionStatus::NOT_START;
+    }
 
-    NetworkAgent* agent = wxGetApp().getAgent();
+    if (obj->is_camera_busy_off()) {
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : camera is busy";
+        m_connection_status = ConnectionStatus::NOT_START;
+    }
 
-    if (m_url_timer && m_url_timer->IsRunning())
+    NetworkAgent *agent         = wxGetApp().getAgent();
+    std::string   agent_version = agent ? agent->get_version() : "";
+    std::string   dev_ver       = obj->get_ota_version();
+    std::string   dev_id        = obj->get_dev_id();
+
+     if (m_url_timer && m_url_timer->IsRunning())
      {
          m_url_timer->Stop();
      }
@@ -1683,40 +1709,19 @@ void SendToPrinterDialog::GetConnection()
          m_url_timer->GetId());
      m_url_timer->StartOnce(8000);
 
-    if (obj && agent)
-    {
-        std::string dev_ver = obj->get_ota_version();
-        std::string dev_id = obj->get_dev_id();
-
+    if (agent) {
         if (m_tcp_try_connect) {
             std::string devIP      = obj->get_dev_ip();
             std::string accessCode = obj->get_access_code();
             std::string url        = "bambu:///local/" + devIP + "?port=6000&user=" + "bblp" + "&passwd=" + accessCode;
-            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Connect method tcp, dev_id=" << dev_id
-                                    << ", dev_ip=" << devIP << ", access_code_len=" << accessCode.size();
-
-            try
-            {
-                m_filetransfer_tunnel = std::make_unique<FileTransferTunnel>(module(), url);
-                m_filetransfer_tunnel->on_connection([this](bool is_success, int err_code, std::string error_msg)
-                {
-                    CallAfter([this, is_success, err_code, error_msg]()
-                    {
-                        OnConnection(is_success, err_code, error_msg);
-                    });
+            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Connect method tcp";
+            m_filetransfer_tunnel  = std::make_unique<FileTransferTunnel>(module(), url);
+            m_filetransfer_tunnel->on_connection([this](bool is_success, int err_code, std::string error_msg) {
+                CallAfter([this, is_success, err_code, error_msg]() {
+                       OnConnection(is_success, err_code, error_msg);
                 });
-                m_filetransfer_tunnel->start_connect();
-            }
-            catch (const std::exception& e)
-            {
-                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": tcp FileTransferTunnel unavailable for dev_id=" <<
- dev_id
-                                           << " dev_ip=" << devIP << ": " << e.what();
-                if (m_url_timer && m_url_timer->IsRunning()) m_url_timer->Stop();
-                m_filetransfer_tunnel.reset();
-                m_connection_status = ConnectionStatus::CONNECTION_FAILED;
-                show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
-            }
+            });
+            m_filetransfer_tunnel->start_connect();
         }
         else if (m_tutk_try_connect)
         {
@@ -1744,28 +1749,11 @@ void SendToPrinterDialog::GetConnection()
                 if (boost::algorithm::starts_with(url, "bambu:///"))
                 {
                     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Connect method tutk";
-                    try
-                    {
-                        m_filetransfer_tunnel = std::make_unique<FileTransferTunnel>(module(), url);
-                        m_filetransfer_tunnel->on_connection(
-                            [this](bool is_success, int err_code, std::string error_msg)
-                            {
-                                CallAfter([this, is_success, err_code, error_msg]()
-                                {
-                                    OnConnection(is_success, err_code, error_msg);
-                                });
-                            });
-                        m_filetransfer_tunnel->start_connect();
-                    }
-                    catch (const std::exception& e)
-                    {
-                        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": tutk FileTransferTunnel unavailable: " << e.
-what();
-                        if (m_url_timer && m_url_timer->IsRunning()) m_url_timer->Stop();
-                        m_filetransfer_tunnel.reset();
-                        m_connection_status = ConnectionStatus::CONNECTION_FAILED;
-                        show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
-                    }
+                    m_filetransfer_tunnel = std::make_unique<FileTransferTunnel>(module(), url);
+                    m_filetransfer_tunnel->on_connection([this](bool is_success, int err_code, std::string error_msg) {
+                        CallAfter([this, is_success, err_code, error_msg]() { OnConnection(is_success, err_code, error_msg); });
+                    });
+                    m_filetransfer_tunnel->start_connect();
                 }
                 else
                 {
@@ -1864,17 +1852,8 @@ void SendToPrinterDialog::ResetTunnelAndJob()
 
 void SendToPrinterDialog::CreateMediaAbilityJob()
 {
-    nlohmann::json media_ability = {{"cmd_type", 7}};
-    try
-    {
-        m_filetransfer_mediability_job = std::make_unique<FileTransferJob>(module(), std::string(media_ability.dump()));
-    }
-    catch (const std::exception& e)
-    {
-        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": FileTransferJob unavailable: " << e.what();
-         show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
-         return;
-     }
+     nlohmann::json media_ability = {{"cmd_type", 7}};
+     m_filetransfer_mediability_job = std::make_unique<FileTransferJob>(module(), std::string(media_ability.dump()));
      m_filetransfer_mediability_job->on_result([this](int res, int resp_ec, std::string json_res, std::vector<std::byte> bin_res) {
          //this pl
          CallAfter([this, res, resp_ec, json_res] {
@@ -1929,20 +1908,11 @@ void SendToPrinterDialog::CreateUploadFileJob(const std::string &path, const std
         {"cmd_type", 5},
     };
     upload_params["dest_storage"] = m_selected_storage;
-    upload_params["dest_name"] = name; // filenme no path
-    upload_params["file_path"] = path;
+    upload_params["dest_name"]    = name; // filenme no path
+    upload_params["file_path"]    = path;
 
-    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Begin CreateUploadFileJob";
-    try
-    {
-        m_filetransfer_uploadfile_job = std::make_unique<FileTransferJob>(module(), std::string(upload_params.dump()));
-    }
-    catch (const std::exception& e)
-    {
-        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": FileTransferJob unavailable: " << e.what();
-        show_status(PrintDialogStatus::PrintStatusPublicUploadFiled);
-        return;
-    }
+      BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Begin CreateUploadFileJob";
+    m_filetransfer_uploadfile_job = std::make_unique<FileTransferJob>(module(), std::string(upload_params.dump()));
     m_filetransfer_uploadfile_job->on_result([this](int res, int resp_ec, std::string json_res, std::vector<std::byte> bin_res) { //
         CallAfter([this, res, resp_ec, json_res, bin_res] {
             UploadFileRessultCallback(res, resp_ec,json_res, bin_res);

src/slic3r/GUI/SendToPrinter.hpp

@@ -181,6 +181,7 @@ public:
     void reset_timeout();
     void update_user_printer();
     void update_show_status();
+    bool is_blocking_printing(MachineObject* obj_);
     void prepare(int print_plate_idx);
     void check_focus(wxWindow* window);
     void check_fcous_state(wxWindow* window);

src/slic3r/GUI/StatusPanel.cpp

@@ -22,7 +22,6 @@
 #include <wx/mstream.h>
 #include <wx/sstream.h>
 #include <wx/zstream.h>
-#include <chrono>
 
 #include "DeviceCore/DevBed.h"
 #include "DeviceCore/DevCtrl.h"
@@ -1502,26 +1501,27 @@ wxBoxSizer *StatusBasePanel::create_monitoring_page()
     m_setting_button->SetMinSize(wxSize(FromDIP(38), FromDIP(24)));
     m_setting_button->SetBackgroundColour(STATUS_TITLE_BG);
 
-    // m_camera_switch_button = new wxStaticBitmap(m_panel_monitoring_title, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxSize(FromDIP(38), FromDIP(24)), 0);
-    // m_camera_switch_button->SetMinSize(wxSize(FromDIP(38), FromDIP(24)));
-    // m_camera_switch_button->SetBackgroundColour(STATUS_TITLE_BG);
-    // m_camera_switch_button->SetBitmap(m_bitmap_switch_camera.bmp());
-    // m_camera_switch_button->Bind(wxEVT_RIGHT_DOWN, [this](auto& e) {
-    //     const std::string js_request_pip = R"(
-    //         document.querySelector('video').requestPictureInPicture();
-    //     )";
-    //     m_custom_camera_view->RunScript(js_request_pip);
-    // });
-    // m_camera_switch_button->Hide();
+    m_camera_switch_button = new wxStaticBitmap(m_panel_monitoring_title, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxSize(FromDIP(38), FromDIP(24)), 0);
+    m_camera_switch_button->SetMinSize(wxSize(FromDIP(38), FromDIP(24)));
+    m_camera_switch_button->SetBackgroundColour(STATUS_TITLE_BG);
+    m_camera_switch_button->SetBitmap(m_bitmap_switch_camera.bmp());
+    m_camera_switch_button->Bind(wxEVT_LEFT_DOWN, &StatusBasePanel::on_camera_switch_toggled, this);
+    m_camera_switch_button->Bind(wxEVT_RIGHT_DOWN, [this](auto& e) {
+        const std::string js_request_pip = R"(
+            document.querySelector('video').requestPictureInPicture();
+        )";
+        m_custom_camera_view->RunScript(js_request_pip);
+    });
+    m_camera_switch_button->Hide();
 
     m_bitmap_sdcard_img->SetToolTip(_L("Storage"));
     m_bitmap_timelapse_img->SetToolTip(_L("Timelapse"));
     m_bitmap_recording_img->SetToolTip(_L("Video"));
     m_bitmap_vcamera_img->SetToolTip(_L("Go Live"));
     m_setting_button->SetToolTip(_L("Camera Setting"));
-    // m_camera_switch_button->SetToolTip(_L("Switch Camera View"));
+    m_camera_switch_button->SetToolTip(_L("Switch Camera View"));
 
-    // bSizer_monitoring_title->Add(m_camera_switch_button, 0, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
+    bSizer_monitoring_title->Add(m_camera_switch_button, 0, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
     bSizer_monitoring_title->Add(m_bitmap_sdcard_img, 0, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
     bSizer_monitoring_title->Add(m_bitmap_timelapse_img, 0, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
     bSizer_monitoring_title->Add(m_bitmap_recording_img, 0, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
@@ -1544,18 +1544,19 @@ wxBoxSizer *StatusBasePanel::create_monitoring_page()
     m_custom_camera_view = WebView::CreateWebView(this, wxEmptyString);
     m_custom_camera_view->EnableContextMenu(false);
     Bind(wxEVT_WEBVIEW_NAVIGATING, &StatusBasePanel::on_webview_navigating, this, m_custom_camera_view->GetId());
-    m_web_media_controller = std::make_unique<WebMediaController>(m_custom_camera_view);
 
     m_media_play_ctrl = new MediaPlayCtrl(this, m_media_ctrl, wxDefaultPosition, wxSize(-1, FromDIP(40)));
-    m_media_play_ctrl->SetWebMediaController(m_web_media_controller.get());
     m_custom_camera_view->Hide();
-    // m_custom_camera_view->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, [this](wxWebViewEvent& evt) {
-    //     if (evt.GetString() == "leavepictureinpicture") {
-    //         // When leaving PiP, video gets paused in some cases and toggling play
-    //         // programmatically does not work.
-    //         m_custom_camera_view->Reload();
-    //     }
-    // });
+    m_custom_camera_view->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, [this](wxWebViewEvent& evt) {
+        if (evt.GetString() == "leavepictureinpicture") {
+            // When leaving PiP, video gets paused in some cases and toggling play
+            // programmatically does not work.
+            m_custom_camera_view->Reload();
+        }
+        else if (evt.GetString() == "enterpictureinpicture") {
+            toggle_builtin_camera();
+        }
+    });
 
     sizer->Add(m_media_ctrl, 1, wxEXPAND | wxALL, 0);
     sizer->Add(m_custom_camera_view, 1, wxEXPAND | wxALL, 0);
@@ -1565,6 +1566,10 @@ wxBoxSizer *StatusBasePanel::create_monitoring_page()
 //
 //    sizer->Add(media_ctrl_panel, 1, wxEXPAND | wxALL, 1);
 
+    if (wxGetApp().app_config->get("camera", "enable_custom_source") == "true") {
+        handle_camera_source_change();
+    }
+
     return sizer;
 }
 
@@ -2328,27 +2333,6 @@ void StatusPanel::update_camera_state(MachineObject* obj)
 {
     if (!obj) return;
 
-    auto agent = wxGetApp().getAgent();
-    const auto camera_mode = agent ? agent->get_camera_stream_mode() : CameraStreamMode::none;
-    const bool use_webview = camera_mode == CameraStreamMode::http_snapshot;
-    if (use_webview) {
-        //m_camera_switch_button->Hide();
-        if (!m_custom_camera_view->IsShown()) {
-            // why: do not reload the WebView URL per tick, or redirects can cause a reload loop.
-            // MediaPlayCtrl (via its WebMediaController) owns loading/playing the stream itself.
-            m_custom_camera_view->Show();
-            m_media_ctrl->Hide();
-        }
-    } else {
-        if (m_custom_camera_view->IsShown()) {
-            m_custom_camera_view->Hide();
-            // Stop the snapshot WebView before switching to native playback
-            // or leaving the camera mode.
-            m_media_play_ctrl->StopWebStream();
-        }
-        m_media_ctrl->Show();
-    }
-
     //sdcard
     auto sdcard_state = obj->GetStorage()->get_sdcard_state();
     if (m_last_sdcard != sdcard_state) {
@@ -2380,12 +2364,7 @@ void StatusPanel::update_camera_state(MachineObject* obj)
         m_last_recording = obj->is_recording() ? 1 : 0;
     }
 
-    if (use_webview) {
-        if (m_bitmap_recording_img->IsShown()) {
-            m_bitmap_recording_img->Hide();
-            m_panel_monitoring_title->Layout();
-        }
-    } else if (!m_bitmap_recording_img->IsShown()) {
+    if (!m_bitmap_recording_img->IsShown()) {
         m_bitmap_recording_img->Show();
         m_panel_monitoring_title->Layout();
     }
@@ -2442,8 +2421,6 @@ void StatusPanel::update_camera_state(MachineObject* obj)
         bool show_vcamera = m_media_play_ctrl->IsStreaming();
         m_camera_popup->update(show_vcamera);
     }
-
-    m_setting_button->Show(!use_webview);
 }
 
 StatusPanel::StatusPanel(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long style, const wxString &name)
@@ -3974,60 +3951,39 @@ void StatusPanel::update_cloud_subtask(MachineObject *obj)
         update_calib_bitmap();
         if (obj->slice_info) {
             m_request_url = wxString(obj->slice_info->thumbnail_url);
-            load_thumbnail_from_url(m_request_url, obj);
+            if (!m_request_url.IsEmpty()) {
+                wxImage                               img;
+                std::map<wxString, wxImage>::iterator it = img_list.find(m_request_url);
+                if (it != img_list.end()) {
+                    if (m_current_print_mode != PrintingTaskType::CALIBRATION  ||(m_calib_mode == CalibMode::Calib_Flow_Rate && m_calib_method == CalibrationMethod::CALI_METHOD_MANUAL)) {
+                        img = it->second;
+                        wxImage resize_img = img.Scale(m_project_task_panel->get_bitmap_thumbnail()->GetSize().x, m_project_task_panel->get_bitmap_thumbnail()->GetSize().y);
+                        m_project_task_panel->set_thumbnail_img(resize_img, "");
+                        m_project_task_panel->set_brightness_value(get_brightness_value(resize_img));
+                    }
+                    if (this->obj) {
+                        m_project_task_panel->set_plate_index(obj->m_plate_index);
+                    } else {
+                        m_project_task_panel->set_plate_index(-1);
+                    }
+                    task_thumbnail_state = ThumbnailState::TASK_THUMBNAIL;
+                    BOOST_LOG_TRIVIAL(trace) << "web_request: use cache image";
+                } else {
+                    web_request = wxWebSession::GetDefault().CreateRequest(this, m_request_url);
+                    BOOST_LOG_TRIVIAL(trace) << "monitor: start request thumbnail, url = " << m_request_url;
+                    web_request.Start();
+                    m_start_loading_thumbnail = false;
+                }
+            }
         }
     }
 }
 
-bool StatusPanel::load_thumbnail_from_url(const wxString &url, MachineObject *obj)
-{
-    if (url.IsEmpty())
-        return false;
-
-    wxImage                               img;
-    std::map<wxString, wxImage>::iterator it = img_list.find(url);
-    if (it != img_list.end()) {
-        if (m_current_print_mode != PrintingTaskType::CALIBRATION  ||(m_calib_mode == CalibMode::Calib_Flow_Rate && m_calib_method == CalibrationMethod::CALI_METHOD_MANUAL)) {
-            img = it->second;
-            wxImage resize_img = img.Scale(m_project_task_panel->get_bitmap_thumbnail()->GetSize().x, m_project_task_panel->get_bitmap_thumbnail()->GetSize().y);
-            m_project_task_panel->set_thumbnail_img(resize_img, "");
-            m_project_task_panel->set_brightness_value(get_brightness_value(resize_img));
-        }
-        if (this->obj) {
-            m_project_task_panel->set_plate_index(obj->m_plate_index);
-        } else {
-            m_project_task_panel->set_plate_index(-1);
-        }
-        task_thumbnail_state = ThumbnailState::TASK_THUMBNAIL;
-        BOOST_LOG_TRIVIAL(trace) << "web_request: use cache image";
-    } else {
-        m_request_url = url;
-        web_request = wxWebSession::GetDefault().CreateRequest(this, m_request_url);
-        BOOST_LOG_TRIVIAL(trace) << "monitor: start request thumbnail, url = " << m_request_url;
-        web_request.Start();
-        m_start_loading_thumbnail = false;
-    }
-    return true;
-}
-
 void StatusPanel::update_sdcard_subtask(MachineObject *obj)
 {
     if (!obj) return;
 
-    const wxString thumbnail_url = wxString(obj->m_agent_thumbnail_url);
-    if (!thumbnail_url.IsEmpty()) {
-        if (m_request_url != thumbnail_url || !m_load_sdcard_thumbnail) {
-            if (web_request.IsOk() && web_request.GetState() == wxWebRequest::State_Active)
-                web_request.Cancel();
-            update_calib_bitmap();
-            m_request_url = thumbnail_url;
-            load_thumbnail_from_url(thumbnail_url, obj);
-            m_load_sdcard_thumbnail = true;
-        }
-        return;
-    }
-
-    if (!m_load_sdcard_thumbnail || !m_request_url.IsEmpty()) {
+    if (!m_load_sdcard_thumbnail) {
         update_calib_bitmap();
         if (m_current_print_mode != PrintingTaskType::CALIBRATION) {
             m_project_task_panel->get_bitmap_thumbnail()->SetBitmap(m_thumbnail_sdcard.bmp());
@@ -4035,7 +3991,6 @@ void StatusPanel::update_sdcard_subtask(MachineObject *obj)
         }
         task_thumbnail_state = ThumbnailState::SDCARD_THUMBNAIL;
         m_load_sdcard_thumbnail = true;
-        m_request_url.clear();
     }
 }
 
@@ -4765,11 +4720,11 @@ void StatusPanel::on_ams_refresh_rfid(wxCommandEvent &event)
         try {
             if (!use_new_command) {
                 int tray_index = atoi(curr_ams_id.c_str()) * 4 + atoi(slot_it->second->id.c_str());
-                obj->command_ams_refresh_rfid(-1, tray_index);
+                obj->command_ams_refresh_rfid(std::to_string(tray_index));
             }
 
             if (use_new_command) {
-                obj->command_ams_refresh_rfid(stoi(curr_ams_id), stoi(curr_can_id));
+                obj->command_ams_refresh_rfid2(stoi(curr_ams_id), stoi(curr_can_id));
             }
 
         } catch (...) {
@@ -5035,6 +4990,7 @@ void StatusPanel::on_camera_enter(wxMouseEvent& event)
             }
             sdcard_hint_dlg->on_show();
             });
+        m_camera_popup->Bind(EVT_CAM_SOURCE_CHANGE, &StatusPanel::on_camera_source_change, this);
         wxWindow* ctrl = (wxWindow*)event.GetEventObject();
         wxPoint   pos = ctrl->ClientToScreen(wxPoint(0, 0));
         wxSize        sz   = ctrl->GetSize();
@@ -5046,6 +5002,54 @@ void StatusPanel::on_camera_enter(wxMouseEvent& event)
     }
 }
 
+void StatusBasePanel::on_camera_source_change(wxCommandEvent& event)
+{
+    handle_camera_source_change();
+}
+
+void StatusBasePanel::handle_camera_source_change()
+{
+    const auto new_cam_url = wxGetApp().app_config->get("camera", "custom_source");
+    const auto enabled = wxGetApp().app_config->get("camera", "enable_custom_source") == "true";
+
+    if (enabled && !new_cam_url.empty()) {
+        m_custom_camera_view->LoadURL(new_cam_url);
+        toggle_custom_camera();
+        m_camera_switch_button->Show();
+    } else {
+        toggle_builtin_camera();
+        m_camera_switch_button->Hide();
+    }
+}
+
+void StatusBasePanel::toggle_builtin_camera()
+{
+    m_custom_camera_view->Hide();
+    m_media_ctrl->Show();
+    m_media_play_ctrl->Show();
+}
+
+void StatusBasePanel::toggle_custom_camera()
+{
+    const auto enabled = wxGetApp().app_config->get("camera", "enable_custom_source") == "true";
+
+    if (enabled) {
+        m_custom_camera_view->Show();
+        m_media_ctrl->Hide();
+        m_media_play_ctrl->Hide();
+    }
+}
+
+void StatusBasePanel::on_camera_switch_toggled(wxMouseEvent& event)
+{
+    const auto enabled = wxGetApp().app_config->get("camera", "enable_custom_source") == "true";
+    if (enabled && m_media_ctrl->IsShown()) {
+        toggle_custom_camera();
+    } else {
+        toggle_builtin_camera();
+    }
+}
+
 void StatusBasePanel::remove_controls()
 {
     const std::string js_cleanup_video_element = R"(
@@ -5198,11 +5202,6 @@ bool StatusPanel::is_stage_list_info_changed(MachineObject *obj)
 void StatusPanel::set_default()
 {
     BOOST_LOG_TRIVIAL(trace) << "status_panel: set_default";
-    if (m_custom_camera_view->IsShown()) {
-        m_custom_camera_view->Hide();
-        m_media_ctrl->Show();
-        m_media_play_ctrl->StopWebStream();
-    }
     obj                  = nullptr;
     last_subtask         = nullptr;
     last_tray_exist_bits = -1;

src/slic3r/GUI/StatusPanel.hpp

@@ -14,9 +14,7 @@
 #include <wx/sizer.h>
 #include <wx/gbsizer.h>
 #include <wx/webrequest.h>
-#include <memory>
 #include "MediaPlayCtrl.h"
-#include "WebMediaController.hpp"
 #include "AMSSetting.hpp"
 #include "Calibration.hpp"
 #include "CalibrationWizardPage.hpp"
@@ -442,7 +440,7 @@ protected:
     wxStaticBitmap *m_bitmap_sdcard_img;
     wxStaticBitmap *m_bitmap_static_use_time;
     wxStaticBitmap *m_bitmap_static_use_weight;
-    // wxStaticBitmap* m_camera_switch_button;
+    wxStaticBitmap* m_camera_switch_button;
 
 
     wxMediaCtrl3 *  m_media_ctrl;
@@ -464,8 +462,6 @@ protected:
     ScalableButton *m_button_abort;
     Button *        m_button_clean;
     wxWebView *     m_custom_camera_view{nullptr};
-    std::unique_ptr<WebMediaController> m_web_media_controller;
-
     wxSimplebook*   m_extruder_book;
     std::vector<ExtruderImage *> m_extruderImage;
 
@@ -581,8 +577,13 @@ protected:
     virtual void on_axis_ctrl_e_up_10(wxCommandEvent &event) { event.Skip(); }
     virtual void on_axis_ctrl_e_down_10(wxCommandEvent &event) { event.Skip(); }
     virtual void on_nozzle_selected(wxCommandEvent &event) { event.Skip(); }
+    void on_camera_source_change(wxCommandEvent& event);
+    void handle_camera_source_change();
     void remove_controls();
     void on_webview_navigating(wxWebViewEvent& evt);
+    void on_camera_switch_toggled(wxMouseEvent& event);
+    void toggle_custom_camera();
+    void toggle_builtin_camera();
 
 public:
     StatusBasePanel(wxWindow *      parent,
@@ -630,7 +631,6 @@ class StatusPanel : public StatusBasePanel
 private:
     friend class MonitorPanel;
     void wire_controls();
-    bool load_thumbnail_from_url(const wxString &url, MachineObject *obj);
 
 protected:
     std::shared_ptr<SliceInfoPopup> m_slice_info_popup;

src/slic3r/GUI/SyncAmsInfoDialog.cpp

@@ -1746,8 +1746,6 @@ void SyncAmsInfoDialog::show_status(PrintDialogStatus status, std::vector<wxStri
         update_print_status_msg(msg_text, true, true);
     } else if (status == PrintDialogStatus::PrintStatusAmsMappingSuccess) {
         update_print_status_msg(wxEmptyString, false, false);
-    } else if (status == PrintDialogStatus::PrintStatusOptionalPrinterModel) {
-        update_print_status_msg(PrePrintChecker::get_pre_state_msg(PrintDialogStatus::PrintStatusOptionalPrinterModel), true, true);
     } else if (status == PrintDialogStatus::PrintStatusAmsMappingInvalid) {
         update_print_status_msg(wxEmptyString, true, false);
     } else if (status == PrintDialogStatus::PrintStatusAmsMappingMixInvalid) {
@@ -1867,13 +1865,26 @@ void SyncAmsInfoDialog::on_cancel(wxCloseEvent &event)
 
 bool SyncAmsInfoDialog::is_blocking_printing(MachineObject *obj_)
 {
-    if (m_print_type == PrintFromType::FROM_NORMAL)
-        return wxGetApp().is_blocking_printing(obj_);
+    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
+    if (!dev) return true;
+    auto        target_model = obj_->printer_type;
+    std::string source_model = "";
 
-    std::string source_model;
-    if (m_print_type == PrintFromType::FROM_SDCARD_VIEW && !m_required_data_plate_data_list.empty())
-        source_model = m_required_data_plate_data_list[m_print_plate_idx]->printer_model_id;
-    return wxGetApp().is_blocking_printing(obj_, source_model);
+    if (m_print_type == PrintFromType::FROM_NORMAL) {
+        PresetBundle *preset_bundle = wxGetApp().preset_bundle;
+        source_model                = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
+
+    } else if (m_print_type == PrintFromType::FROM_SDCARD_VIEW) {
+        if (m_required_data_plate_data_list.size() > 0) { source_model = m_required_data_plate_data_list[m_print_plate_idx]->printer_model_id; }
+    }
+
+    if (source_model != target_model) {
+        std::vector<std::string>      compatible_machine = obj_->get_compatible_machine();
+        vector<std::string>::iterator it                 = find(compatible_machine.begin(), compatible_machine.end(), source_model);
+        if (it == compatible_machine.end()) { return true; }
+    }
+
+    return false;
 }
 
 bool SyncAmsInfoDialog::is_same_nozzle_type(std::string &filament_type, NozzleType &tag_nozzle_type)
@@ -1923,13 +1934,7 @@ bool SyncAmsInfoDialog::is_same_printer_model()
     if (obj_ == nullptr) { return result; }
 
     PresetBundle *preset_bundle = wxGetApp().preset_bundle;
-    const std::string source_model = preset_bundle ? preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) : std::string();
-    if (DevPrinterConfigUtil::is_optional_printer_model_id(source_model) ||
-        DevPrinterConfigUtil::is_optional_printer_model_id(obj_->printer_type)) {
-        return true;
-    }
-
-    if (preset_bundle && source_model != obj_->printer_type) {
+    if (preset_bundle && preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) != obj_->printer_type) {
         if ((obj_->is_support_upgrade_kit && obj_->installed_upgrade_kit) && (preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) == "C12")) {
             return true;
         }
@@ -2130,7 +2135,7 @@ void SyncAmsInfoDialog::update_user_printer()
     std::map<std::string, MachineObject *> option_list;
 
     // user machine list
-    option_list = dev->get_my_machine_list(dev->get_current_printer_agent_id());
+    option_list = dev->get_my_machine_list();
 
     // same machine only appear once
     for (auto it = option_list.begin(); it != option_list.end(); it++) {
@@ -2263,18 +2268,6 @@ void SyncAmsInfoDialog::update_show_status()
 
     reset_timeout();
 
-    bool has_optional_printer_model = DevPrinterConfigUtil::is_optional_printer_model_id(obj_->printer_type);
-    if (m_print_type == PrintFromType::FROM_NORMAL) {
-        if (PresetBundle *preset_bundle = wxGetApp().preset_bundle) {
-            has_optional_printer_model = has_optional_printer_model ||
-                DevPrinterConfigUtil::is_optional_printer_model_id(
-                    preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle));
-        }
-    } else if (m_print_type == PrintFromType::FROM_SDCARD_VIEW && !m_required_data_plate_data_list.empty()) {
-        has_optional_printer_model = has_optional_printer_model ||
-            DevPrinterConfigUtil::is_optional_printer_model_id(m_required_data_plate_data_list[m_print_plate_idx]->printer_model_id);
-    }
-
     if (!obj_->GetConfig()->SupportPrintAllPlates() && m_print_plate_idx == PLATE_ALL_IDX) {
         show_status(PrintDialogStatus::PrintStatusNotSupportedPrintAll);
         return;
@@ -2368,9 +2361,6 @@ void SyncAmsInfoDialog::update_show_status()
             }
         }
     }
-
-    if (has_optional_printer_model)
-        show_status(PrintDialogStatus::PrintStatusOptionalPrinterModel);
 }
 
 bool SyncAmsInfoDialog::has_timelapse_warning()
@@ -3220,7 +3210,6 @@ SyncAmsInfoDialog::~SyncAmsInfoDialog() {
 void SyncAmsInfoDialog::set_info(SyncInfo &info)
 {
     m_input_info = info;
-    reinit_dialog();
 }
 
 void SyncAmsInfoDialog::update_lan_machine_list()

src/slic3r/GUI/WebGuideDialog.cpp

@@ -1478,9 +1478,7 @@ bool GuideFrame::BuildProfileDataFromVendors()
             return false;
 
         // Written through a temp file and moved into place, as the preset caches
-        // are: half a cache must never be readable, and the PID suffix keeps two
-        // instances from interleaving on one temp file.
-        const std::string tmp_path = cache_file.string() + "." + std::to_string(get_current_pid()) + ".tmp";
+        // are: half a cache must never be readable.
         try {
             json out;
             out["format"]  = 1;
@@ -1489,18 +1487,9 @@ bool GuideFrame::BuildProfileDataFromVendors()
             for (const char* key : { "model", "machine", "filament", "process" })
                 profile[key] = m_ProfileJson[key];
             boost::filesystem::create_directories(cache_file.parent_path());
-            {
-                boost::nowide::ofstream ofs(tmp_path, std::ios::binary | std::ios::trunc);
-                ofs << out.dump(-1, ' ', false, json::error_handler_t::ignore);
-                ofs.close();
-                if (! ofs.good())
-                    throw std::runtime_error("write failed");
-            }
-            if (const std::error_code ec = rename_file(tmp_path, cache_file.string()))
+            if (const std::error_code ec = write_file_atomically(cache_file.string(), out.dump(-1, ' ', false, json::error_handler_t::ignore), /*binary=*/true))
                 throw std::runtime_error(ec.message());
         } catch (const std::exception& e) {
-            boost::system::error_code rm;
-            boost::filesystem::remove(tmp_path, rm);
             BOOST_LOG_TRIVIAL(warning) << "GuideFrame: could not write the profile data cache: " << e.what();
         }
         return true;

src/slic3r/GUI/WebMediaController.cpp

@@ -1,90 +0,0 @@
-#include "WebMediaController.hpp"
-
-#include <wx/webview.h>
-
-namespace Slic3r { namespace GUI {
-
-namespace {
-
-void initialize_webview(wxWebView* webview)
-{
-    if (!webview)
-        return;
-
-    webview->SetBackgroundColour(*wxBLACK);
-    webview->SetPage("<html><head><style>html,body{margin:0;height:100%;background:#000;}</style></head><body></body></html>", "");
-}
-
-} // namespace
-
-WebMediaController::WebMediaController(wxWebView* webview)
-    : m_webview(webview)
-{
-    initialize_webview(m_webview);
-}
-
-void WebMediaController::Load(wxURI url)
-{
-    m_url = url.BuildURI().ToStdString();
-}
-
-void WebMediaController::set_mode(CameraStreamMode mode)
-{
-    m_stream_mode = mode;
-}
-
-void WebMediaController::Play()
-{
-    if (!m_webview)
-        return;
-
-    wxString url  = wxString::FromUTF8(m_url);
-    wxString html = "<html><head><style>"
-                    "html,body{margin:0;height:100%;background:#000;overflow:hidden;}"
-                    "img{width:100%;height:100%;object-fit:contain;display:block;}"
-                    "</style></head><body><img id=\"camera-frame\"";
-    if (m_stream_mode == CameraStreamMode::http_snapshot) {
-        html += " data-camera-url=\"" + url +
-                "\"><script>"
-                "const cameraFrame=document.getElementById('camera-frame');"
-                "const cameraUrl=cameraFrame.dataset.cameraUrl;"
-                "let cameraFrameLoading=false;"
-                "function refreshCameraFrame(){"
-                "if(cameraFrameLoading)return;"
-                "cameraFrameLoading=true;"
-                "const nextFrame=new Image();"
-                "nextFrame.onload=function(){cameraFrame.src=nextFrame.src;cameraFrameLoading=false;};"
-                "nextFrame.onerror=function(){cameraFrameLoading=false;};"
-                "nextFrame.src=cameraUrl+(cameraUrl.indexOf('?')>=0?'&':'?')+'_orca_frame='+Date.now();"
-                "}"
-                "let cameraRefreshInterval=null;"
-                "function stopCameraRefresh(){"
-                "if(cameraRefreshInterval!==null){"
-                "clearInterval(cameraRefreshInterval);"
-                "cameraRefreshInterval=null;"
-                "}"
-                "}"
-                "refreshCameraFrame();"
-                "cameraRefreshInterval = setInterval(refreshCameraFrame,200);"
-                "</script></body></html>";
-        m_webview->SetPage(html, url);
-    } else {
-        // Load MJPEG streams as the top-level document.  Some embedded WebView
-        // backends buffer a multipart stream when it is used as an <img> resource,
-        // which introduces noticeable live-view latency.
-        m_webview->LoadURL(url);
-    }
-}
-
-void WebMediaController::Stop()
-{
-    if (m_webview) {
-        m_webview->RunScript("if(typeof stopCameraRefresh==='function') stopCameraRefresh();");
-        m_webview->Stop();
-        m_webview->SetPage("", "about:blank");
-        m_webview->ClearHistory();
-    }
-    m_url.clear();
-}
-
-}} // namespace Slic3r::GUI

src/slic3r/GUI/WebMediaController.hpp

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <slic3r/GUI/IMediaController.hpp>
-#include <slic3r/Utils/IPrinterAgent.hpp>
-
-#include <string>
-
-class wxWebView;
-
-namespace Slic3r { namespace GUI {
-
-class WebMediaController : public IMediaController
-{
-public:
-    explicit WebMediaController(wxWebView* webview);
-
-    void Load(wxURI url) override;
-
-    void set_mode(CameraStreamMode mode);
-
-    void Play() override;
-
-    void Stop() override;
-
-private:
-    wxWebView* m_webview = nullptr;
-    std::string m_url;
-    CameraStreamMode m_stream_mode = CameraStreamMode::http;
-};
-
-}} // namespace Slic3r::GUI

src/slic3r/GUI/WebRtcMediaController.cpp

@@ -1,401 +0,0 @@
-#include "WebRtcMediaController.hpp"
-
-#include <rtc/common.hpp>
-#include <rtc/rtc.hpp>
-
-#include <mutex>
-#include <wx/mstream.h>
-
-#include <boost/log/trivial.hpp>
-
-namespace {
-void init_rtc_logger_once()
-{
-    static std::once_flag flag;
-    std::call_once(flag, [] {
-        rtc::InitLogger(rtc::LogLevel::Warning, [](rtc::LogLevel level, std::string message) {
-            BOOST_LOG_TRIVIAL(trace) << "[rtc:" << static_cast<int>(level) << "] " << message;
-        });
-    });
-}
-} // namespace
-
-namespace Slic3r { namespace GUI {
-
-WebRtcMediaController::WebRtcMediaController(std::function<void(const wxImage&, wxSize)> frame_sink,
-                                             std::function<void(Status)> on_status)
-    : m_frame_sink(std::move(frame_sink))
-    , m_on_status(std::move(on_status))
-{
-}
-
-WebRtcMediaController::~WebRtcMediaController()
-{
-    Stop();
-}
-
-void WebRtcMediaController::report(Status status)
-{
-    status.epoch = m_epoch.load();
-    BOOST_LOG_TRIVIAL(info) << "WebRTC: report kind=" << static_cast<int>(status.kind)
-                            << " code=" << static_cast<int>(status.code) << " epoch=" << status.epoch;
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        if (status.kind == Status::Connecting)
-            m_state = static_cast<wxMediaState>(4);
-        else if (status.kind == Status::Playing)
-            m_state = wxMEDIASTATE_PLAYING;
-        else
-            m_state = static_cast<wxMediaState>(3);
-    }
-    if (m_on_status)
-        m_on_status(status);
-}
-
-void WebRtcMediaController::set_signalling_channel(std::unique_ptr<ICameraSignalingChannel> channel)
-{
-    m_pending_signaling = std::move(channel);
-}
-
-void WebRtcMediaController::Play()
-{
-    std::unique_ptr<ICameraSignalingChannel> channel = std::move(m_pending_signaling);
-    // Tear down any previous attempt WITHOUT notifying: the Stopped that would
-    // otherwise be delivered (async, via CallAfter) races the new attempt's
-    // Connecting and makes the consumer cancel a session that is mid-connect.
-    teardown(false);
-    if (!channel)
-        return;
-
-    m_epoch.fetch_add(1);
-    m_alive.store(true);
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_signaling = std::move(channel);
-        m_jpeg_queue.clear();
-        m_pending_candidates.clear();
-        m_remote_description_set = false;
-        m_video_size = wxDefaultSize;
-        m_has_frame = false;
-        m_last_frame_time = {};
-    }
-
-    ICameraSignalingChannel* signaling = nullptr;
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        signaling = m_signaling.get();
-    }
-    signaling->on_ready = [this](std::vector<CameraIceServer> servers) {
-        if (m_alive.load())
-            on_ready(std::move(servers));
-    };
-    signaling->on_answer = [this](std::string sdp) {
-        if (m_alive.load())
-            on_answer(std::move(sdp));
-    };
-    signaling->on_ice = [this](std::string candidate, std::string mid) {
-        if (m_alive.load())
-            on_ice(std::move(candidate), std::move(mid));
-    };
-    signaling->on_unavailable = [this](CameraUnavailableReason reason, std::string detail) {
-        if (m_alive.load())
-            on_unavailable(reason, std::move(detail));
-    };
-
-    m_decode_thread = std::thread([this] { decode_loop(); });
-    report({Status::Connecting});
-    signaling->open();
-}
-
-void WebRtcMediaController::Stop()
-{
-    teardown(true);
-}
-
-void WebRtcMediaController::teardown(bool notify)
-{
-    const bool was_alive = m_alive.exchange(false);
-    if (!was_alive && !m_decode_thread.joinable())
-        return;
-
-    m_cond.notify_all();
-    std::unique_ptr<ICameraSignalingChannel> signaling;
-    std::shared_ptr<rtc::PeerConnection> peer_connection;
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        signaling = std::move(m_signaling);
-        peer_connection = std::move(m_peer_connection);
-        m_data_channel.reset();
-    }
-    if (signaling)
-        signaling->close();
-    if (peer_connection)
-        peer_connection->close();
-    if (m_decode_thread.joinable())
-        m_decode_thread.join();
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_jpeg_queue.clear();
-    }
-    if (was_alive && notify)
-        report({Status::Stopped});
-}
-
-wxMediaState WebRtcMediaController::GetState()
-{
-    std::lock_guard<std::mutex> lock(m_mutex);
-    return m_state;
-}
-
-wxSize WebRtcMediaController::GetVideoSize() const
-{
-    std::lock_guard<std::mutex> lock(m_mutex);
-    return m_video_size;
-}
-
-void WebRtcMediaController::bind_data_channel(const std::shared_ptr<rtc::DataChannel>& dc)
-{
-    const std::string label = dc->label();
-    dc->onOpen([label] { BOOST_LOG_TRIVIAL(info) << "WebRTC: data channel '" << label << "' open"; });
-    dc->onClosed([label] { BOOST_LOG_TRIVIAL(info) << "WebRTC: data channel '" << label << "' closed"; });
-    dc->onError([label](std::string e) {
-        BOOST_LOG_TRIVIAL(warning) << "WebRTC: data channel '" << label << "' error: " << e;
-    });
-    dc->onMessage(
-        [this](rtc::binary data) {
-            if (m_alive.load())
-                enqueue_jpeg(std::vector<std::byte>(data.begin(), data.end()));
-        },
-        [](rtc::string) {});
-}
-
-void WebRtcMediaController::on_ready(std::vector<CameraIceServer> servers)
-{
-    init_rtc_logger_once();
-    rtc::Configuration configuration;
-    // Allow complete-JPEG DataChannel messages up to 1 MiB. This value is
-    // advertised in SDP and becomes the upper bound for frames OrcaSonar can
-    // send to OrcaSlicer.
-    configuration.maxMessageSize = 1024 * 1024;
-    for (const CameraIceServer& server : servers) {
-        try {
-            rtc::IceServer ice_server(server.urls);
-            ice_server.username = server.username;
-            ice_server.password = server.credential;
-            configuration.iceServers.emplace_back(std::move(ice_server));
-        } catch (const std::exception& e) {
-            BOOST_LOG_TRIVIAL(warning) << "WebRTC: invalid ICE server: " << e.what();
-        }
-    }
-
-    BOOST_LOG_TRIVIAL(info) << "WebRTC: creating peer connection with " << configuration.iceServers.size() << " ice servers";
-    auto peer_connection = std::make_shared<rtc::PeerConnection>(std::move(configuration));
-    peer_connection->onLocalDescription([this](rtc::Description description) {
-        if (!m_alive.load())
-            return;
-        const std::string sdp(description);
-        BOOST_LOG_TRIVIAL(info) << "WebRTC: local description ready (" << description.typeString()
-                                << "), OFFER SDP:\n" << sdp;
-        std::lock_guard<std::mutex> lock(m_mutex);
-        if (m_signaling)
-            m_signaling->send_offer(sdp);
-    });
-    peer_connection->onLocalCandidate([this](rtc::Candidate candidate) {
-        if (!m_alive.load())
-            return;
-        std::lock_guard<std::mutex> lock(m_mutex);
-        if (m_signaling)
-            m_signaling->send_ice(std::string(candidate), candidate.mid());
-    });
-    peer_connection->onStateChange([this](rtc::PeerConnection::State state) {
-        BOOST_LOG_TRIVIAL(info) << "WebRTC: peer state -> " << static_cast<int>(state);
-        if (!m_alive.load())
-            return;
-        if (state == rtc::PeerConnection::State::Failed || state == rtc::PeerConnection::State::Disconnected)
-            report({Status::Failed, Status::ICE_FAILED});
-    });
-    peer_connection->onGatheringStateChange([](rtc::PeerConnection::GatheringState state) {
-        BOOST_LOG_TRIVIAL(info) << "WebRTC: gathering state -> " << static_cast<int>(state);
-    });
-
-    // Accept a DataChannel opened by the remote peer (OrcaSonar may create the
-    // "camera" channel from its side rather than answering the one we offer).
-    peer_connection->onDataChannel([this](std::shared_ptr<rtc::DataChannel> dc) {
-        BOOST_LOG_TRIVIAL(info) << "WebRTC: remote opened data channel '" << dc->label() << "'";
-        bind_data_channel(dc);
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_data_channel = std::move(dc);
-    });
-
-    rtc::DataChannelInit init;
-    init.reliability.unordered = true;
-    // init.reliability.maxPacketLifeTime = std::chrono::milliseconds(350);
-    // Request one complete JPEG frame per DataChannel message. OrcaSonar
-    // keeps the legacy chunked protocol for clients that omit this property.
-    init.protocol = "orca-jpeg";
-    auto data_channel = peer_connection->createDataChannel("camera", init);
-    if (data_channel)
-        bind_data_channel(data_channel);
-
-    // Camera media is carried as one complete JPEG per DataChannel message;
-    // no RTP video track or application-level framing is required.
-
-    std::shared_ptr<rtc::PeerConnection> peer_for_description;
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        if (!m_alive.load())
-            return;
-        m_peer_connection = std::move(peer_connection);
-        peer_for_description = m_peer_connection;
-        m_data_channel = std::move(data_channel);
-    }
-    if (peer_for_description)
-        peer_for_description->setLocalDescription();
-}
-
-void WebRtcMediaController::on_answer(std::string sdp)
-{
-    std::shared_ptr<rtc::PeerConnection> peer_connection;
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        peer_connection = m_peer_connection;
-    }
-    BOOST_LOG_TRIVIAL(info) << "WebRTC: applying remote answer (" << sdp.size() << " bytes), ANSWER SDP:\n" << sdp;
-    if (!peer_connection)
-        return;
-    try {
-        peer_connection->setRemoteDescription(rtc::Description(sdp, "answer"));
-    } catch (const std::exception& e) {
-        BOOST_LOG_TRIVIAL(warning) << "WebRTC: setRemoteDescription failed: " << e.what();
-        report({Status::Failed, Status::ICE_FAILED});
-        return;
-    }
-
-    // Flush any remote candidates that arrived before the answer.
-    std::vector<std::pair<std::string, std::string>> pending;
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_remote_description_set = true;
-        pending.swap(m_pending_candidates);
-    }
-    BOOST_LOG_TRIVIAL(info) << "WebRTC: remote description set, flushing " << pending.size()
-                            << " buffered candidate(s)";
-    for (const auto& c : pending) {
-        try {
-            peer_connection->addRemoteCandidate(rtc::Candidate(c.first, c.second));
-        } catch (const std::exception& e) {
-            BOOST_LOG_TRIVIAL(warning) << "WebRTC: addRemoteCandidate (buffered) failed: " << e.what();
-        }
-    }
-}
-
-void WebRtcMediaController::on_ice(std::string candidate, std::string mid)
-{
-    std::shared_ptr<rtc::PeerConnection> peer_connection;
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        if (!m_remote_description_set) {
-            m_pending_candidates.emplace_back(std::move(candidate), std::move(mid));
-            return;
-        }
-        peer_connection = m_peer_connection;
-    }
-    if (!peer_connection)
-        return;
-    try {
-        peer_connection->addRemoteCandidate(rtc::Candidate(candidate, mid));
-    } catch (const std::exception& e) {
-        BOOST_LOG_TRIVIAL(warning) << "WebRTC: addRemoteCandidate failed: " << e.what();
-    }
-}
-
-void WebRtcMediaController::on_unavailable(CameraUnavailableReason reason, std::string detail)
-{
-    BOOST_LOG_TRIVIAL(warning) << "WebRTC camera unavailable: " << detail;
-    Status::Code code = Status::UNAVAILABLE_ERROR;
-    if (reason == CameraUnavailableReason::Busy)
-        code = Status::UNAVAILABLE_BUSY;
-    else if (reason == CameraUnavailableReason::Disabled)
-        code = Status::UNAVAILABLE_DISABLED;
-    else if (reason == CameraUnavailableReason::Closed)
-        code = Status::SIGNALING_CLOSED;
-    report({Status::Failed, code});
-}
-
-void WebRtcMediaController::enqueue_jpeg(std::vector<std::byte> jpeg)
-{
-    std::lock_guard<std::mutex> lock(m_mutex);
-    if (m_jpeg_queue.size() >= 4)
-        m_jpeg_queue.pop_front();
-    m_jpeg_queue.emplace_back(std::move(jpeg));
-    m_cond.notify_one();
-}
-
-void WebRtcMediaController::deliver_jpeg(std::vector<std::byte> jpeg)
-{
-    const auto now = std::chrono::steady_clock::now();
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        if (m_last_frame_time != std::chrono::steady_clock::time_point{} &&
-            now - m_last_frame_time < std::chrono::milliseconds(33))
-            return;
-        m_last_frame_time = now;
-    }
-    wxMemoryInputStream stream(jpeg.data(), jpeg.size());
-    wxImage image;
-    if (!image.LoadFile(stream, wxBITMAP_TYPE_JPEG)) {
-        report({Status::Failed, Status::DECODE_ERROR});
-        return;
-    }
-    bool first_frame = false;
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_video_size = image.GetSize();
-        first_frame = !m_has_frame;
-        m_has_frame = true;
-    }
-    if (m_frame_sink)
-        m_frame_sink(image, image.GetSize());
-    if (first_frame)
-        report({Status::Playing});
-}
-
-void WebRtcMediaController::decode_loop()
-{
-    int stall_polls = 0;
-    std::unique_lock<std::mutex> lock(m_mutex);
-    while (m_alive.load()) {
-        const bool woke = m_cond.wait_for(lock, std::chrono::seconds(2), [this] {
-            return !m_alive.load() || !m_jpeg_queue.empty();
-        });
-        if (!m_alive.load())
-            break;
-        if (!woke && !m_has_frame) {
-            const int pc_state = m_peer_connection ? static_cast<int>(m_peer_connection->state()) : -1;
-            std::string dc = "none";
-            if (m_data_channel)
-                dc = "label='" + m_data_channel->label() + "' open=" +
-                     (m_data_channel->isOpen() ? "1" : "0");
-            lock.unlock();
-            BOOST_LOG_TRIVIAL(info) << "WebRTC: waiting for frames; peer_state=" << pc_state
-                                    << " data_channel=" << dc;
-            if (++stall_polls >= 8) { // ~16s connected with no frame -> give up so the UI can retry
-                report({Status::Failed, Status::TIMEOUT});
-                lock.lock();
-                break;
-            }
-            lock.lock();
-            continue;
-        }
-        stall_polls = 0;
-        if (!m_jpeg_queue.empty()) {
-            auto jpeg = std::move(m_jpeg_queue.front());
-            m_jpeg_queue.pop_front();
-            lock.unlock();
-            deliver_jpeg(std::move(jpeg));
-            lock.lock();
-        }
-    }
-}
-
-}} // namespace Slic3r::GUI

src/slic3r/GUI/WebRtcMediaController.hpp

@@ -1,93 +0,0 @@
-#pragma once
-
-#include "IMediaController.hpp"
-#include <slic3r/Utils/ICameraSignalingChannel.hpp>
-
-#include <wx/image.h>
-
-#include <atomic>
-#include <chrono>
-#include <cstddef>
-#include <condition_variable>
-#include <cstdint>
-#include <deque>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <thread>
-#include <vector>
-
-namespace rtc {
-class DataChannel;
-class PeerConnection;
-}
-
-namespace Slic3r { namespace GUI {
-
-class WebRtcMediaController : public IMediaController {
-public:
-    struct Status {
-        enum Kind { Connecting, Playing, Stopped, Failed } kind = Stopped;
-        enum Code {
-            ICE_FAILED,
-            SIGNALING_CLOSED,
-            UNAVAILABLE_BUSY,
-            UNAVAILABLE_ERROR,
-            UNAVAILABLE_DISABLED,
-            DECODE_ERROR,
-            TIMEOUT,
-        } code = ICE_FAILED;
-        // Identifies the Play attempt this status belongs to, so the
-        // consumer can drop CallAfter-queued events from a superseded attempt.
-        std::uint64_t epoch = 0;
-    };
-
-    WebRtcMediaController(std::function<void(const wxImage&, wxSize)> frame_sink,
-                          std::function<void(Status)> on_status);
-    ~WebRtcMediaController() override;
-
-    void set_signalling_channel(std::unique_ptr<ICameraSignalingChannel> channel);
-    std::uint64_t epoch() const { return m_epoch.load(); }
-    bool is_active() const { return m_alive.load(); }
-
-    void Load(wxURI) override {}
-    void Play() override;
-    void Stop() override;
-    wxMediaState GetState() override;
-    wxSize GetVideoSize() const override;
-
-private:
-    void teardown(bool notify);
-    void report(Status status);
-    void bind_data_channel(const std::shared_ptr<rtc::DataChannel>& dc);
-    void on_ready(std::vector<CameraIceServer> servers);
-    void on_answer(std::string sdp);
-    void on_ice(std::string candidate, std::string mid);
-    void on_unavailable(CameraUnavailableReason reason, std::string detail);
-    void decode_loop();
-    void enqueue_jpeg(std::vector<std::byte> jpeg);
-    void deliver_jpeg(std::vector<std::byte> jpeg);
-
-    mutable std::mutex m_mutex;
-    std::condition_variable m_cond;
-    std::deque<std::vector<std::byte>> m_jpeg_queue;
-    // Remote candidates can arrive before the answer; libdatachannel rejects
-    // addRemoteCandidate until a remote description is set, so buffer them.
-    std::vector<std::pair<std::string, std::string>> m_pending_candidates;
-    bool m_remote_description_set = false;
-    std::unique_ptr<ICameraSignalingChannel> m_pending_signaling;
-    std::unique_ptr<ICameraSignalingChannel> m_signaling;
-    std::shared_ptr<rtc::PeerConnection> m_peer_connection;
-    std::shared_ptr<rtc::DataChannel> m_data_channel;
-    std::thread m_decode_thread;
-    std::atomic<bool> m_alive{false};
-    std::atomic<std::uint64_t> m_epoch{0};
-    wxMediaState m_state = static_cast<wxMediaState>(3);
-    wxSize m_video_size = wxDefaultSize;
-    std::function<void(const wxImage&, wxSize)> m_frame_sink;
-    std::function<void(Status)> m_on_status;
-    bool m_has_frame = false;
-    std::chrono::steady_clock::time_point m_last_frame_time{};
-};
-
-}} // namespace Slic3r::GUI

src/slic3r/GUI/wxMediaCtrl3.cpp

@@ -4,14 +4,6 @@
 #include "libslic3r/Utils.hpp"
 #include <boost/log/trivial.hpp>
 #include <wx/dcclient.h>
-#include <cstdarg>
-#include <cstdlib>
-#include <cstring>
-#include <mutex>
-extern "C" {
-#include <libavformat/avformat.h>
-#include <libavutil/log.h>
-}
 #ifdef __WIN32__
 #include <versionhelpers.h>
 #include <wx/msw/registry.h>
@@ -51,13 +43,9 @@ wxMediaCtrl3::~wxMediaCtrl3()
     m_thread.join();
 }
 
-static void adjust_frame_size(wxSize& frame, wxSize const& video, wxSize const& window);
-
 void wxMediaCtrl3::Load(wxURI url)
 {
     std::unique_lock<std::mutex> lk(m_mutex);
-    if (m_external)
-        return;
     m_video_size = wxDefaultSize;
     m_error = 0;
     m_url.reset(new wxURI(url));
@@ -67,8 +55,6 @@ void wxMediaCtrl3::Load(wxURI url)
 void wxMediaCtrl3::Play()
 {
     std::unique_lock<std::mutex> lk(m_mutex);
-    if (m_external)
-        return;
     if (m_state != wxMEDIASTATE_PLAYING) {
         m_state = wxMEDIASTATE_PLAYING;
         wxMediaEvent event(wxEVT_MEDIA_STATECHANGED);
@@ -88,62 +74,6 @@ void wxMediaCtrl3::Stop()
     Refresh();
 }
 
-void wxMediaCtrl3::SetExternalFrame(const wxImage& frame, wxSize videoSize)
-{
-    if (!frame.IsOk())
-        return;
-    {
-        std::unique_lock<std::mutex> lk(m_mutex);
-        if (!m_external)
-            return;
-        m_frame = frame;
-        m_video_size = videoSize.IsFullySpecified() ? videoSize : frame.GetSize();
-        adjust_frame_size(m_frame_size, m_video_size, GetSize());
-    }
-    CallAfter([this] { Refresh(); });
-}
-
-#ifdef _WIN32
-void wxMediaCtrl3::SetExternalFrame(const wxBitmap& frame, wxSize videoSize)
-{
-    if (!frame.IsOk())
-        return;
-    {
-        std::unique_lock<std::mutex> lk(m_mutex);
-        if (!m_external)
-            return;
-        m_frame = frame;
-        m_video_size = videoSize.IsFullySpecified() ? videoSize : frame.GetSize();
-        adjust_frame_size(m_frame_size, m_video_size, GetSize());
-    }
-    CallAfter([this] { Refresh(); });
-}
-#endif
-
-void wxMediaCtrl3::BeginExternalStream()
-{
-    std::unique_lock<std::mutex> lk(m_mutex);
-    m_external = true;
-    m_url.reset();
-    m_active_url.reset();
-    m_video_size = wxDefaultSize;
-    m_frame = wxImage(m_idle_image);
-    m_cond.notify_all();
-    Refresh();
-}
-
-void wxMediaCtrl3::EndExternalStream()
-{
-    std::unique_lock<std::mutex> lk(m_mutex);
-    m_external = false;
-    m_url.reset();
-    m_active_url.reset();
-    m_video_size = wxDefaultSize;
-    m_frame = wxImage(m_idle_image);
-    m_cond.notify_all();
-    Refresh();
-}
-
 void wxMediaCtrl3::SetIdleImage(wxString const &image)
 {
     if (m_idle_image == image)
@@ -163,13 +93,13 @@ wxMediaState wxMediaCtrl3::GetState()
     return m_state;
 }
 
-int wxMediaCtrl3::GetLastError() const
+int wxMediaCtrl3::GetLastError()
 {
     std::unique_lock<std::mutex> lk(m_mutex);
     return m_error;
 }
 
-wxSize wxMediaCtrl3::GetVideoSize() const
+wxSize wxMediaCtrl3::GetVideoSize()
 {
     std::unique_lock<std::mutex> lk(m_mutex);
     return m_video_size;
@@ -255,210 +185,6 @@ void wxMediaCtrl3::bambu_log(void *ctx, int level, tchar const *msg2)
     BOOST_LOG_TRIVIAL(info) << msg.ToUTF8().data();
 }
 
-// FFmpeg's own diagnostics (HTTP status, "Invalid data found", demuxer choice,
-// missing stream dimensions, ...) are otherwise swallowed: a failed camera open
-// only surfaces as wxMediaCtrl3's generic error code, which MediaPlayCtrl maps to
-// the misleading "Player is malfunctioning" string. Forward them to the Orca log
-// instead. Verbosity defaults to AV_LOG_VERBOSE and can be raised at runtime with
-// ORCA_FFMPEG_LOG_LEVEL=debug|trace|... (or lowered to warning/error/quiet).
-static int ffmpeg_log_level_from_env()
-{
-    const char *env = std::getenv("ORCA_FFMPEG_LOG_LEVEL");
-    if (env == nullptr || *env == '\0')
-        return AV_LOG_VERBOSE;
-    const wxString v = wxString(env).Lower();
-    if (v == "quiet")   return AV_LOG_QUIET;
-    if (v == "panic")   return AV_LOG_PANIC;
-    if (v == "fatal")   return AV_LOG_FATAL;
-    if (v == "error")   return AV_LOG_ERROR;
-    if (v == "warning") return AV_LOG_WARNING;
-    if (v == "info")    return AV_LOG_INFO;
-    if (v == "verbose") return AV_LOG_VERBOSE;
-    if (v == "debug")   return AV_LOG_DEBUG;
-    if (v == "trace")   return AV_LOG_TRACE;
-    return AV_LOG_VERBOSE;
-}
-
-static void ffmpeg_log_callback(void *avcl, int level, const char *fmt, va_list vl)
-{
-    if (level > av_log_get_level())
-        return;
-    thread_local int print_prefix = 1;
-    char line[1024];
-    av_log_format_line2(avcl, level, fmt, vl, line, (int) sizeof(line), &print_prefix);
-    size_t len = std::strlen(line);
-    while (len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r' || line[len - 1] == ' '))
-        line[--len] = '\0';
-    if (len == 0)
-        return;
-    if (level <= AV_LOG_ERROR)
-        BOOST_LOG_TRIVIAL(error) << "ffmpeg: " << line;
-    else if (level <= AV_LOG_WARNING)
-        BOOST_LOG_TRIVIAL(warning) << "ffmpeg: " << line;
-    else if (level <= AV_LOG_INFO)
-        BOOST_LOG_TRIVIAL(info) << "ffmpeg: " << line;
-    else
-        BOOST_LOG_TRIVIAL(debug) << "ffmpeg: " << line;
-}
-
-static void install_ffmpeg_logger()
-{
-    av_log_set_level(ffmpeg_log_level_from_env());
-    av_log_set_callback(&ffmpeg_log_callback);
-}
-
-int wxMediaCtrl3::ffmpeg_interrupt_callback(void *opaque)
-{
-    auto *ctrl = static_cast<wxMediaCtrl3 *>(opaque);
-    std::lock_guard<std::mutex> lock(ctrl->m_mutex);
-    return ctrl->m_url != ctrl->m_active_url;
-}
-
-int wxMediaCtrl3::PlayFfmpeg(std::shared_ptr<wxURI> const &url, std::unique_lock<std::mutex> &lock)
-{
-    static std::once_flag logger_once;
-    std::call_once(logger_once, install_ffmpeg_logger);
-
-    if (avformat_network_init() < 0)
-        return 2;
-
-    AVFormatContext *format_context = avformat_alloc_context();
-    if (!format_context) {
-        avformat_network_deinit();
-        return 2;
-    }
-
-    format_context->interrupt_callback = {&wxMediaCtrl3::ffmpeg_interrupt_callback, this};
-    format_context->flags |= AVFMT_FLAG_NOBUFFER;
-    format_context->max_delay = 0;
-    m_active_url = url;
-
-    auto finish = [&](int error) {
-        lock.unlock();
-        avformat_close_input(&format_context);
-        avformat_network_deinit();
-        lock.lock();
-        m_active_url.reset();
-        return error;
-    };
-
-    const std::string uri = url->BuildURI().ToUTF8().data();
-    const wxString scheme = url->GetScheme();
-    const bool http_stream = scheme.CmpNoCase("http") == 0 || scheme.CmpNoCase("https") == 0;
-    AVDictionary *options = nullptr;
-    if (http_stream) {
-        // Live multipart MJPEG. fflags=nobuffer / AVFMT_FLAG_NOBUFFER / max_delay=0
-        // (set above) are the low-latency levers - they disable the demuxer
-        // read-ahead queue. probesize / analyzeduration only bound the one-off
-        // avformat_find_stream_info() at open; a 32-byte budget returned before a
-        // whole JPEG frame was seen, so width/height came back unset and the open
-        // was rejected. Give it room to identify one frame (a startup cost only).
-        // rw_timeout / timeout bound a wedged connect or read so a stale stream
-        // fails fast and is retried, instead of the reader thread hanging.
-        // avioflags=direct is deliberately NOT set: unbuffered reads make the
-        // mpjpeg demuxer emit "Packet corrupt" and bail on any short read across
-        // a multipart boundary.
-        av_dict_set(&options, "fflags", "nobuffer", 0);
-        av_dict_set(&options, "probesize", "5000000", 0);
-        av_dict_set(&options, "analyzeduration", "1000000", 0);
-        av_dict_set(&options, "rw_timeout", "5000000", 0);
-        av_dict_set(&options, "timeout", "5000000", 0);
-    } else {
-        av_dict_set(&options, "rtsp_transport", "tcp", 0);
-    }
-    lock.unlock();
-    int error = avformat_open_input(&format_context, uri.c_str(), nullptr, &options);
-    av_dict_free(&options);
-    lock.lock();
-    if (error < 0)
-        return finish(2);
-
-    lock.unlock();
-    error = avformat_find_stream_info(format_context, nullptr);
-    lock.lock();
-    if (error < 0)
-        return finish(2);
-
-    const int video_stream = av_find_best_stream(format_context, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
-    if (video_stream < 0)
-        return finish(2);
-
-    AVVideoDecoder decoder;
-    if (decoder.open(*format_context->streams[video_stream]->codecpar) < 0)
-        return finish(2);
-
-    // Prefer the dimensions the container reported. A small probe budget, or a
-    // camera that doesn't announce a size up front, can leave these unset - in
-    // that case fill them in from the first frame that decodes (below) rather
-    // than failing the open outright.
-    auto apply_video_size = [&](wxSize size) {
-        if (!size.IsFullySpecified() || size.x <= 0 || size.y <= 0)
-            return false;
-        m_video_size = size;
-        adjust_frame_size(m_frame_size, m_video_size, GetSize());
-        NotifyStopped();
-        return true;
-    };
-    bool have_size = apply_video_size({format_context->streams[video_stream]->codecpar->width,
-                                      format_context->streams[video_stream]->codecpar->height});
-    int size_probe_frames = 0; // frames spent still waiting for a usable size
-
-    AVPacket *packet = av_packet_alloc();
-    if (!packet)
-        return finish(2);
-
-    while (m_url == url) {
-        lock.unlock();
-        error = av_read_frame(format_context, packet);
-        lock.lock();
-        if (m_url != url)
-            break;
-        if (error < 0)
-            break;
-        if (packet->stream_index == video_stream) {
-            const int decode_error = decoder.decode(*packet);
-            if (decode_error == 0) {
-                if (!have_size) {
-                    have_size = apply_video_size(decoder.decoded_frame_size());
-                    if (!have_size) {
-                        av_packet_unref(packet);
-                        // MJPEG yields a sized frame on the first full packet; if
-                        // several seconds of frames never do, treat it as a bad
-                        // stream instead of sitting in "Loading..." forever.
-                        if (++size_probe_frames > 120)
-                            break;
-                        continue;
-                    }
-                }
-                auto frame_size = m_frame_size;
-                lock.unlock();
-#ifdef _WIN32
-                wxBitmap frame;
-                decoder.toWxBitmap(frame, frame_size);
-#else
-                wxImage frame;
-                decoder.toWxImage(frame, frame_size);
-#endif
-                lock.lock();
-                if (m_url != url)
-                    break;
-                if (frame.IsOk())
-                    m_frame = frame;
-                if (!m_refresh_pending.exchange(true)) {
-                    CallAfter([this] {
-                        m_refresh_pending.store(false);
-                        Refresh();
-                    });
-                }
-            }
-        }
-        av_packet_unref(packet);
-    }
-
-    av_packet_free(&packet);
-    return finish(m_url == url ? 2 : 1);
-}
-
 void wxMediaCtrl3::PlayThread()
 {
     using namespace std::chrono_literals;
@@ -471,22 +197,42 @@ void wxMediaCtrl3::PlayThread()
             continue;
         if (!url->HasScheme())
             break;
-        const wxString scheme = url->GetScheme();
-        const bool generic_ffmpeg = scheme.CmpNoCase("http") == 0 || scheme.CmpNoCase("https") == 0 ||
-                                    scheme.CmpNoCase("rtsp") == 0 || scheme.CmpNoCase("rtsps") == 0;
-        int error = 0;
-        if (generic_ffmpeg) {
-            error = PlayFfmpeg(url, lk);
-        } else {
-            lk.unlock();
-            Bambu_Tunnel tunnel = nullptr;
-            error = Bambu_Create(&tunnel, m_url->BuildURI().ToUTF8());
-            if (error == 0) {
-                Bambu_SetLogger(tunnel, &wxMediaCtrl3::bambu_log, this);
-                error = Bambu_Open(tunnel);
-                if (error == 0)
-                    error = Bambu_would_block;
+        lk.unlock();
+        Bambu_Tunnel tunnel = nullptr;
+        int error = Bambu_Create(&tunnel, m_url->BuildURI().ToUTF8());
+        if (error == 0) {
+            Bambu_SetLogger(tunnel, &wxMediaCtrl3::bambu_log, this);
+            error = Bambu_Open(tunnel);
+            if (error == 0)
+                error = Bambu_would_block;
+        }
+        lk.lock();
+        while (error == int(Bambu_would_block)) {
+            m_cond.wait_for(lk, 100ms);
+            if (m_url != url) {
+                error = 1;
+                break;
             }
+            lk.unlock();
+            error = Bambu_StartStream(tunnel, true);
+            lk.lock();
+        }
+        Bambu_StreamInfo info;
+        if (error == 0)
+            error = Bambu_GetStreamInfo(tunnel, 0, &info);
+        AVVideoDecoder decoder;
+        int minFrameDuration = 0;
+        if (error == 0) {
+            decoder.open(info);
+            m_video_size = { info.format.video.width, info.format.video.height };
+            adjust_frame_size(m_frame_size, m_video_size, GetSize());
+            minFrameDuration = 800 / info.format.video.frame_rate; // 80%
+            NotifyStopped();
+        }
+        Bambu_Sample sample;
+        while (error == 0) {
+            lk.unlock();
+            error = Bambu_ReadSample(tunnel, &sample);
             lk.lock();
             while (error == int(Bambu_would_block)) {
                 m_cond.wait_for(lk, 100ms);
@@ -494,88 +240,60 @@ void wxMediaCtrl3::PlayThread()
                     error = 1;
                     break;
                 }
-                lk.unlock();
-                error = Bambu_StartStream(tunnel, true);
-                lk.lock();
-            }
-            Bambu_StreamInfo info;
-            if (error == 0)
-                error = Bambu_GetStreamInfo(tunnel, 0, &info);
-            AVVideoDecoder decoder;
-            int minFrameDuration = 0;
-            if (error == 0) {
-                decoder.open(info);
-                m_video_size = { info.format.video.width, info.format.video.height };
-                adjust_frame_size(m_frame_size, m_video_size, GetSize());
-                minFrameDuration = 800 / info.format.video.frame_rate; // 80%
-                NotifyStopped();
-            }
-            Bambu_Sample sample;
-            while (error == 0) {
                 lk.unlock();
                 error = Bambu_ReadSample(tunnel, &sample);
                 lk.lock();
-                while (error == int(Bambu_would_block)) {
-                    m_cond.wait_for(lk, 100ms);
-                    if (m_url != url) {
-                        error = 1;
-                        break;
-                    }
-                    lk.unlock();
-                    error = Bambu_ReadSample(tunnel, &sample);
-                    lk.lock();
-                }
-                if (error == 0) {
-                    auto frame_size = m_frame_size;
-                    lk.unlock();
-                    decoder.decode(sample);
-#ifdef _WIN32
-                    wxBitmap bm;
-                    decoder.toWxBitmap(bm, frame_size);
-#else
-                    wxImage bm;
-                    decoder.toWxImage(bm, frame_size);
-#endif
-                    lk.lock();
-                    if (m_url != url) {
-                        error = 1;
-                        break;
-                    }
-                    if (bm.IsOk()) {
-                        auto now = std::chrono::system_clock::now();
-                        if (m_last_PTS && (sample.decode_time - m_last_PTS) < 30000000ULL) { // 3s
-                            auto next_PTS_expected = m_last_PTS_expected + std::chrono::milliseconds((sample.decode_time - m_last_PTS) / 10000ULL);
-                            // The frame is late, catch up a little
-                            auto next_PTS_practical = m_last_PTS_practical + std::chrono::milliseconds(minFrameDuration);
-                            auto next_PTS = std::max(next_PTS_expected, next_PTS_practical);
-                            if(now < next_PTS)
-                                std::this_thread::sleep_until(next_PTS);
-                            else
-                                next_PTS = now;
-                            //auto text = wxString::Format(L"wxMediaCtrl3 pts diff %ld\n", std::chrono::duration_cast<std::chrono::milliseconds>(next_PTS - next_PTS_expected).count());
-                            //OutputDebugString(text);
-                            m_last_PTS = sample.decode_time;
-                            m_last_PTS_expected = next_PTS_expected;
-                            m_last_PTS_practical = next_PTS;
-                        } else {
-                            // Resync
-                            m_last_PTS           = sample.decode_time;
-                            m_last_PTS_expected  = now;
-                            m_last_PTS_practical = now;
-                        }
-                        m_frame = bm;
-                    }
-                    CallAfter([this] { Refresh(); });
-                }
             }
-            if (tunnel) {
+            if (error == 0) {
+                auto frame_size = m_frame_size;
                 lk.unlock();
-                Bambu_Close(tunnel);
-                Bambu_Destroy(tunnel);
-                tunnel = nullptr;
+                decoder.decode(sample);
+#ifdef _WIN32
+                wxBitmap bm;
+                decoder.toWxBitmap(bm, frame_size);
+#else
+                wxImage bm;
+                decoder.toWxImage(bm, frame_size);
+#endif
                 lk.lock();
+                if (m_url != url) {
+                    error = 1;
+                    break;
+                }
+                if (bm.IsOk()) {
+                    auto now = std::chrono::system_clock::now();
+                    if (m_last_PTS && (sample.decode_time - m_last_PTS) < 30000000ULL) { // 3s
+                        auto next_PTS_expected = m_last_PTS_expected + std::chrono::milliseconds((sample.decode_time - m_last_PTS) / 10000ULL);
+                        // The frame is late, catch up a little
+                        auto next_PTS_practical = m_last_PTS_practical + std::chrono::milliseconds(minFrameDuration);
+                        auto next_PTS = std::max(next_PTS_expected, next_PTS_practical);
+                        if(now < next_PTS)
+                            std::this_thread::sleep_until(next_PTS);
+                        else
+                            next_PTS = now;
+                        //auto text = wxString::Format(L"wxMediaCtrl3 pts diff %ld\n", std::chrono::duration_cast<std::chrono::milliseconds>(next_PTS - next_PTS_expected).count());
+                        //OutputDebugString(text);
+                        m_last_PTS = sample.decode_time;
+                        m_last_PTS_expected = next_PTS_expected;
+                        m_last_PTS_practical = next_PTS;
+                    } else {
+                        // Resync
+                        m_last_PTS           = sample.decode_time;
+                        m_last_PTS_expected  = now;
+                        m_last_PTS_practical = now;
+                    }
+                    m_frame = bm;
+                }
+                CallAfter([this] { Refresh(); });
             }
         }
+        if (tunnel) {
+            lk.unlock();
+            Bambu_Close(tunnel);
+            Bambu_Destroy(tunnel);
+            tunnel = nullptr;
+            lk.lock();
+        }
         if (m_url == url)
             m_error = error;
         m_frame_size = wxDefaultSize;

src/slic3r/GUI/wxMediaCtrl3.h

@@ -13,51 +13,41 @@
 #include "wx/bitmap.h"
 #include "wx/uri.h"
 #include "wx/mediactrl.h"
-#include "IMediaController.hpp"
 
 wxDECLARE_EVENT(EVT_MEDIA_CTRL_STAT, wxCommandEvent);
 
 void wxMediaCtrl_OnSize(wxWindow * ctrl, wxSize const & videoSize, int width, int height);
 
 #define BAMBU_DYNAMIC
-#include <atomic>
 #include <condition_variable>
 #include <thread>
+#ifndef _WIN32
 #include <wx/image.h>
+#endif
 #include "Printer/BambuTunnel.h"
 
 class AVVideoDecoder;
 
-class wxMediaCtrl3 : public wxWindow, public Slic3r::GUI::IMediaController, BambuLib
+class wxMediaCtrl3 : public wxWindow, BambuLib
 {
 public:
     wxMediaCtrl3(wxWindow *parent);
 
-    ~wxMediaCtrl3() override;
+    ~wxMediaCtrl3();
 
-    void Load(wxURI url) override;
+    void Load(wxURI url);
 
-    void Play() override;
+    void Play();
 
-    void Stop() override;
-
-    // Render frames supplied by a controller which owns its own transport.
-    // The frame is copied while m_mutex is held; callers may release it after
-    // this method returns.
-    void SetExternalFrame(const wxImage& frame, wxSize videoSize);
-#ifdef _WIN32
-    void SetExternalFrame(const wxBitmap& frame, wxSize videoSize);
-#endif
-    void BeginExternalStream();
-    void EndExternalStream();
+    void Stop();
 
     void SetIdleImage(wxString const & image);
 
-    wxMediaState GetState() override;
+    wxMediaState GetState();
 
-    int GetLastError() const override;
+    int GetLastError();
 
-    wxSize GetVideoSize() const override;
+    wxSize GetVideoSize();
 
 protected:
     DECLARE_EVENT_TABLE()
@@ -69,10 +59,8 @@ protected:
     void DoSetSize(int x, int y, int width, int height, int sizeFlags) override;
 
     static void bambu_log(void *ctx, int level, tchar const *msg);
-    static int ffmpeg_interrupt_callback(void *opaque);
 
     void PlayThread();
-    int PlayFfmpeg(std::shared_ptr<wxURI> const &url, std::unique_lock<std::mutex> &lock);
 
     void NotifyStopped();
 
@@ -89,15 +77,12 @@ private:
 #endif
 
     std::shared_ptr<wxURI> m_url;
-    std::shared_ptr<wxURI> m_active_url;
-    bool m_external = false;
     std::uint64_t m_last_PTS{0};
     std::chrono::system_clock::time_point m_last_PTS_expected;
     std::chrono::system_clock::time_point m_last_PTS_practical;
-    mutable std::mutex m_mutex;
+    std::mutex m_mutex;
     std::condition_variable m_cond;
     std::thread m_thread;
-    std::atomic_bool m_refresh_pending{false};
 };
 
 #endif /* wxMediaCtrl3_h */

src/slic3r/Utils/3DPrinterOS.cpp

@@ -2,6 +2,7 @@
 
 #include <algorithm>
 #include <sstream>
+#include <system_error>
 #include <exception>
 #include <boost/format.hpp>
 #include <boost/log/trivial.hpp>
@@ -580,9 +581,10 @@ bool C3DPrinterOS::save_api_session(const std::string &session, const std::strin
     j.put("session", session);
     j.put("email", email);
     try {
-        auto temp_path = m_api_session_file_path + ".tmp";
-        pt::write_json(temp_path, j);
-        boost::filesystem::rename(temp_path, m_api_session_file_path);
+        std::ostringstream json;
+        pt::write_json(json, j);
+        if (const std::error_code ec = write_file_atomically(m_api_session_file_path, json.str()))
+            throw std::system_error(ec);
     } catch (const std::exception &err) {
         BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to write json to file. Path = "
                                  << m_api_session_file_path

src/slic3r/Utils/BBLPrinterAgent.cpp

@@ -1,23 +1,15 @@
 #include "BBLPrinterAgent.hpp"
 #include "BBLNetworkPlugin.hpp"
-#include "IPrinterAgent.hpp"
 #include "NetworkAgentFactory.hpp"
-#include "NetworkAgent.hpp"
 #include "libslic3r/Utils.hpp"
-#include "slic3r/GUI/GUI_App.hpp"
-#include "slic3r/GUI/DeviceCore/DevManager.h"
 
-#include <boost/format.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/nowide/fstream.hpp>
 #include <nlohmann/json.hpp>
-#include <cmath>
-#include <slic3r/GUI/DeviceManager.hpp>
 using json = nlohmann::json;
 
 #include <type_traits>
 #include <unordered_map>
-#include <memory>
 
 namespace Slic3r {
 
@@ -141,7 +133,7 @@ BBLPrinterAgent::~BBLPrinterAgent() = default;
 
 void BBLPrinterAgent::set_cloud_agent(std::shared_ptr<ICloudServiceAgent> cloud)
 {
-    (void) cloud;
+    m_cloud_agent = cloud;
     // BBL DLL manages tokens internally, so this is just for interface compliance
 }
 
@@ -149,94 +141,6 @@ void BBLPrinterAgent::set_cloud_agent(std::shared_ptr<ICloudServiceAgent> cloud)
 // Communication
 // ============================================================================
 
-int BBLPrinterAgent::command_ams_refresh_rfid(std::string dev_id, int ams_id, int slot_id, int sequence_id, bool lan_mode)
-{
-    nlohmann::json j;
-    if (ams_id == -1) {
-        const std::string gcode   = (boost::format("M620 R%1% \n") % slot_id).str();
-        j["print"]["command"]     = "gcode_line";
-        j["print"]["param"]       = gcode;
-        j["print"]["sequence_id"] = std::to_string(sequence_id);
-        return publish(dev_id, j, lan_mode);
-    }
-
-    j["print"]["command"]     = "ams_get_rfid";
-    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
-    j["print"]["ams_id"]      = ams_id;
-    j["print"]["slot_id"]     = slot_id;
-    return publish(dev_id, j, lan_mode);
-}
-
-int BBLPrinterAgent::command_ams_calibrate(std::string dev_id, int ams_id, int sequence_id, bool lan_mode)
-{
-    const std::string gcode = (boost::format("M620 C%1% \n") % ams_id).str();
-    nlohmann::json j;
-    j["print"]["command"] = "gcode_line";
-    j["print"]["param"] = gcode;
-    j["print"]["sequence_id"] = std::to_string(sequence_id);
-    return publish(dev_id, j, lan_mode);
-}
-
-int BBLPrinterAgent::command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode)
-{
-    const std::string gcode = (boost::format("M620 P%1% \n") % tray_id).str();
-    nlohmann::json j;
-    j["print"]["command"] = "gcode_line";
-    j["print"]["param"] = gcode;
-    j["print"]["sequence_id"] = std::to_string(sequence_id);
-    return publish(dev_id, j, lan_mode);
-}
-
-int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis, double unit, double input_val, int speed,
-                                           bool is_core_xy, bool supports_mqtt_axis_control, int sequence_id, bool lan_mode)
-{
-    nlohmann::json j;
-    j["print"]["sequence_id"] = std::to_string(sequence_id);
-
-    if (supports_mqtt_axis_control) {
-        int dir = input_val > 0 ? 1 : -1;
-        // i3-arch printers move the bed for Y/Z, so the on-screen direction is
-        // reversed -- same negation the g-code fallback below applies.
-        if (!is_core_xy && (axis == "Y" || axis == "Z"))
-            dir = -dir;
-
-        j["print"]["command"] = "xyz_ctrl";
-        j["print"]["axis"] = axis;
-        j["print"]["dir"] = dir;
-        j["print"]["mode"] = (std::abs(input_val) >= 10) ? 1 : 0;
-        return publish(dev_id, j, lan_mode);
-    }
-
-    double value = input_val;
-    if (!is_core_xy && (axis == "Y" || axis == "Z"))
-        value = -input_val;
-
-    std::string value_str = (boost::format("%.1f") % (value * unit)).str();
-    std::string gcode;
-    if (axis == "X" || axis == "Y" || axis == "Z") {
-        gcode = (boost::format("M211 S \nM211 X1 Y1 Z1\nM1002 push_ref_mode\nG91 \nG1 %1%%2% F%3%\nM1002 pop_ref_mode\nM211 R\n")
-                 % axis % value_str % speed).str();
-    } else if (axis == "E") {
-        gcode = (boost::format("M83 \nG0 %1%%2% F%3%\n") % axis % value_str % speed).str();
-    } else {
-        return -1;
-    }
-
-    j["print"]["command"] = "gcode_line";
-    j["print"]["param"] = gcode;
-    return publish(dev_id, j, lan_mode);
-}
-
-int BBLPrinterAgent::publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode)
-{
-    const int rtn = lan_mode ? send_message_to_printer(dev_id, j.dump(), 0, 0) : send_message(dev_id, j.dump(), 0, 0);
-    if (rtn == 0)
-        BOOST_LOG_TRIVIAL(info) << "publish_json: " << j.dump() << " code: " << rtn;
-    else
-        BOOST_LOG_TRIVIAL(error) << "publish_json: " << j.dump() << " code: " << rtn;
-    return rtn;
-}
-
 int BBLPrinterAgent::send_message(std::string dev_id, std::string json_str, int qos, int flag)
 {
     json_str = from_orca_payload(std::move(json_str));
@@ -261,23 +165,13 @@ int BBLPrinterAgent::send_message(std::string dev_id, std::string json_str, int
     return -1;
 }
 
-int BBLPrinterAgent::connect_printer(const PrinterConnectionParams& params)
+int BBLPrinterAgent::connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl)
 {
     auto& plugin = BBLNetworkPlugin::instance();
     auto agent = plugin.get_agent();
     auto func = plugin.get_connect_printer();
-#if !BBL_RELEASE_TO_PUBLIC
-    const bool use_ssl_for_mqtt = GUI::wxGetApp().app_config &&
-                                  GUI::wxGetApp().app_config->get_bool("enable_ssl_for_mqtt");
-#else
-    bool use_ssl_for_mqtt = true;
-    if (auto* dev_manager = GUI::wxGetApp().getDeviceManager()) {
-        if (auto* machine = dev_manager->get_my_machine(params.dev_id))
-            use_ssl_for_mqtt = machine->local_use_ssl;
-    }
-#endif
     if (func && agent) {
-        return func(agent, params.dev_id, params.host, params.username, params.password, use_ssl_for_mqtt);
+        return func(agent, dev_id, dev_ip, username, password, use_ssl);
     }
     return -1;
 }

src/slic3r/Utils/BBLPrinterAgent.hpp

@@ -5,7 +5,6 @@
 #include "ICloudServiceAgent.hpp"
 #include <string>
 #include <memory>
-#include <nlohmann/json.hpp>
 
 namespace Slic3r {
 
@@ -29,13 +28,7 @@ public:
 
     // Communication
     int send_message(std::string dev_id, std::string json_str, int qos, int flag) override;
-    int command_ams_refresh_rfid(std::string dev_id, int ams_id, int slot_id, int sequence_id, bool lan_mode) override;
-    int command_ams_calibrate(std::string dev_id, int ams_id, int sequence_id, bool lan_mode) override;
-    int command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode) override;
-    int command_axis_control(std::string dev_id, std::string axis, double unit, double input_val, int speed,
-                              bool is_core_xy, bool supports_mqtt_axis_control, int sequence_id, bool lan_mode) override;
-    std::string default_lan_username() const override { return "bblp"; }
-    int connect_printer(const PrinterConnectionParams& params) override;
+    int connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl) override;
     int disconnect_printer() override;
     int send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag) override;
 
@@ -106,7 +99,7 @@ public:
     static std::string from_orca_payload(std::string json_text);
 
 private:
-    int publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode);
+    std::shared_ptr<ICloudServiceAgent> m_cloud_agent;
 };
 
 } // namespace Slic3r

src/slic3r/Utils/CrealityPrintAgent.cpp

@@ -282,7 +282,7 @@ bool CrealityPrintAgent::parse_cfs_response(const std::string&    response,
     return true;
 }
 
-bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
+bool CrealityPrintAgent::fetch_filament_info(std::string dev_id)
 {
     if (device_info.dev_ip.empty()) {
         BOOST_LOG_TRIVIAL(warning)

src/slic3r/Utils/CrealityPrintAgent.hpp

@@ -41,7 +41,7 @@ public:
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
-    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
+    bool fetch_filament_info(std::string dev_id) override;
 
     // Parse the boxsInfo JSON returned by CrealityPrint::query_boxes_info() into
     // a flat list of loaded slots, plus the count of CFS boxes the printer reports.

src/slic3r/Utils/FileTransferUtils.cpp

@@ -224,4 +224,4 @@ void FileTransferJob::solve_result(ft_job_result result)
     res_json_.assign(result.json ? result.json : "");
 }
 
-} // namespace Slic3r
+} // namespace Slic3r

src/slic3r/Utils/FileTransferUtils.hpp

@@ -252,4 +252,4 @@ inline FileTransferModule &module()
     return *detail::g_mod;
 }
 
-} // namespace Slic3r
+} // namespace Slic3r

src/slic3r/Utils/Http.cpp

@@ -1,6 +1,5 @@
 #include "Http.hpp"
 
-#include <atomic>
 #include <cstdlib>
 #include <functional>
 #include <thread>
@@ -15,19 +14,8 @@
 
 #include <curl/curl.h>
 
-#include <openssl/err.h>
-#include <openssl/ssl.h>
+#ifdef OPENSSL_CERT_OVERRIDE
 #include <openssl/x509.h>
-#include <openssl/x509err.h>
-
-#ifdef _WIN32
-#    ifndef NOMINMAX
-#        define NOMINMAX
-#    endif
-#    include <windows.h>
-#    include <wincrypt.h>
-// wincrypt.h uses this token for a certificate-name property identifier.
-#    undef X509_NAME
 #endif
 
 namespace fs = boost::filesystem;
@@ -134,7 +122,7 @@ struct Http::priv
 	std::string error_buffer;    // Used for CURLOPT_ERRORBUFFER
     std::string headers;
 	size_t limit;
-	std::atomic_bool cancel;
+	bool cancel;
     std::unique_ptr<form_file> putFile;
 
 	std::thread io_thread;
@@ -272,9 +260,9 @@ int Http::priv::xfercb(void *userp, curl_off_t dltotal, curl_off_t dlnow, curl_o
 		self->progressfn(progress, cb_cancel);
 	}
 
-	if (cb_cancel) { self->cancel.store(true); }
+	if (cb_cancel) { self->cancel = true; }
 
-	return self->cancel.load();
+	return self->cancel;
 }
 
 int Http::priv::xfercb_legacy(void *userp, double dltotal, double dlnow, double ultotal, double ulnow)
@@ -485,7 +473,7 @@ void Http::priv::http_perform()
 
 	if (res != CURLE_OK) {
 		if (res == CURLE_ABORTED_BY_CALLBACK) {
-			if (cancel.load()) {
+			if (cancel) {
 				// The abort comes from the request being cancelled programatically
 				Progress dummyprogress(0, 0, 0, 0, std::string());
 				bool cancel = true;
@@ -796,7 +784,7 @@ void Http::perform_sync()
 
 void Http::cancel()
 {
-	if (p) { p->cancel.store(true); }
+	if (p) { p->cancel = true; }
 }
 
 void Http::print() const
@@ -951,45 +939,6 @@ std::string Http::tls_system_cert_store()
     return ret;
 }
 
-void Http::add_platform_root_certificates(SSL_CTX* ssl_context)
-{
-#ifdef _WIN32
-    X509_STORE* openssl_store = SSL_CTX_get_cert_store(ssl_context);
-    if (!openssl_store)
-        throw std::runtime_error("unable to get OpenSSL certificate store");
-
-    const auto load_store = [&](DWORD location) {
-        HCERTSTORE windows_store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
-                                                 location | CERT_STORE_OPEN_EXISTING_FLAG | CERT_STORE_READONLY_FLAG,
-                                                 L"ROOT");
-        if (!windows_store)
-            return;
-
-        PCCERT_CONTEXT windows_certificate = nullptr;
-        while ((windows_certificate = CertEnumCertificatesInStore(windows_store, windows_certificate)) != nullptr) {
-            const unsigned char* encoded = windows_certificate->pbCertEncoded;
-            X509* certificate = d2i_X509(nullptr, &encoded, static_cast<long>(windows_certificate->cbCertEncoded));
-            if (!certificate) {
-                ERR_clear_error();
-                continue;
-            }
-
-            ERR_clear_error();
-            if (X509_STORE_add_cert(openssl_store, certificate) != 1)
-                ERR_clear_error();
-            X509_free(certificate);
-        }
-
-        CertCloseStore(windows_store, 0);
-    };
-
-    load_store(CERT_SYSTEM_STORE_CURRENT_USER);
-    load_store(CERT_SYSTEM_STORE_LOCAL_MACHINE);
-#else
-    (void)ssl_context;
-#endif
-}
-
 std::string Http::url_encode(const std::string &str)
 {
 	::CURL *curl = ::curl_easy_init();

src/slic3r/Utils/Http.hpp

@@ -11,8 +11,6 @@
 #include "libslic3r/Exception.hpp"
 #include "libslic3r_version.h"
 
-typedef struct ssl_ctx_st SSL_CTX;
-
 #define MAX_SIZE_TO_FILE    3*1024
 
 namespace Slic3r {
@@ -200,10 +198,6 @@ public:
     // Return empty string on success or error message on fail.
     static std::string tls_global_init();
     static std::string tls_system_cert_store();
-    // Add platform root certificates to a standalone OpenSSL context. This
-    // supplements set_default_verify_paths() on platforms where OpenSSL does
-    // not use the native certificate store.
-    static void add_platform_root_certificates(SSL_CTX* ssl_context);
 
 	// converts the given string to an url_encoded_string
 	static std::string url_encode(const std::string &str);

src/slic3r/Utils/ICameraSignalingChannel.hpp

@@ -1,39 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <string>
-#include <vector>
-
-namespace Slic3r {
-
-struct CameraIceServer {
-    std::string urls;
-    std::string username;
-    std::string credential;
-};
-
-enum class CameraUnavailableReason {
-    Busy,
-    Error,
-    Disabled,
-    Closed,
-};
-
-class ICameraSignalingChannel {
-public:
-    virtual ~ICameraSignalingChannel() = default;
-
-    virtual void open() = 0;
-    virtual void close() = 0;
-    virtual void send_offer(std::string sdp) = 0;
-    virtual void send_ice(std::string candidate, std::string mid) = 0;
-
-    // These callbacks are invoked by the channel's worker thread. Consumers
-    // must marshal UI work to the GUI thread themselves.
-    std::function<void(std::vector<CameraIceServer>)> on_ready;
-    std::function<void(std::string)> on_answer;
-    std::function<void(std::string, std::string)> on_ice;
-    std::function<void(CameraUnavailableReason, std::string)> on_unavailable;
-};
-
-} // namespace Slic3r

src/slic3r/Utils/ICloudServiceAgent.hpp

@@ -1,11 +1,11 @@
 #ifndef __I_CLOUD_SERVICE_AGENT_HPP__
 #define __I_CLOUD_SERVICE_AGENT_HPP__
 
-#include "ICameraSignalingChannel.hpp"
 #include "bambu_networking.hpp"
 #include "CloudProvider.hpp"
 #include "../../libslic3r/ProjectTask.hpp"
 #include <string>
+#include <string_view>
 #include <map>
 #include <vector>
 #include <functional>
@@ -328,17 +328,6 @@ public:
      */
     virtual int get_camera_url(std::string dev_id, std::function<void(std::string)> callback) = 0;
 
-    /**
-     * Create a camera signaling channel object for P2P camera streaming over WebRTC.
-     * 
-     */
-    virtual std::unique_ptr<ICameraSignalingChannel>
-    create_camera_signaling_channel(const std::string& dev_id)
-    {
-        (void) dev_id;
-        return nullptr;
-    }
-
     /**
      * Fetch staff-picked designs from model mall.
      */

src/slic3r/Utils/IPrinterAgent.hpp

@@ -11,11 +11,6 @@
 #define ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE -7020 // a translation exists; this printer lacks the capability
 #include <string>
 #include <memory>
-#include <vector>
-#include <functional>
-#include <cmath>
-#include <nlohmann/json.hpp>
-#include <boost/format.hpp>
 
 namespace Slic3r {
 
@@ -34,17 +29,6 @@ struct AgentInfo {
     std::string description; ///< Brief description of the agent's capabilities, e.g. "Orca printer agent"
 };
 
-struct PrinterConnectionParams
-{
-    std::string dev_id;
-    std::string host; // host address, usually the IP address without the http/https protocol
-    std::string port; // optional
-    std::string username;
-    std::string password;
-    bool use_ssl = false; // indicates if http or https
-    std::string ca_file;
-};
-
 /**
  * FilamentSyncMode - Modes for filament data synchronization.
  *
@@ -59,15 +43,6 @@ enum class FilamentSyncMode {
     pull          ///< On-demand fetch via REST API (blocking call)
 };
 
-enum class CameraStreamMode {
-    none = 0,
-    http,  // LAN or Cloud
-    https, // LAN or Cloud over TLS
-    rtsp,  // LAN only
-    webrtc, // Cloud only
-    http_snapshot // HTTP endpoint returning one image per request
-};
-
 /**
  * IPrinterAgent - Interface for printer operations.
  *
@@ -109,112 +84,10 @@ public:
      */
     virtual int send_message(std::string dev_id, std::string json_str, int qos, int flag) = 0;
 
-    // why: gcode is firmware dialect, not a waist concept - commands whose body is Bambu-dialect
-    // gcode live on the agent that speaks it; the default is an honest refusal that MachineObject's
-    // publish funnel turns into a dialog.
-    virtual int command_ams_refresh_rfid(std::string, int, int, int, bool)
-    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
-    virtual int command_ams_calibrate(std::string, int, int, bool)
-    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
-    virtual int command_ams_select_tray(std::string, std::string, int, bool)
-    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
-    virtual int command_start_camera(std::string)
-    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
-
-private:
-    int publish_command_json(std::string dev_id, const nlohmann::json& j, bool lan_mode)
-    {
-        return lan_mode ? send_message_to_printer(dev_id, j.dump(), 0, 0)
-                         : send_message(dev_id, j.dump(), 0, 0);
-    }
-
-public:
-    virtual int command_xyz_abs(std::string dev_id, int sequence_id, bool lan_mode)
-    {
-        nlohmann::json j;
-        j["print"]["command"]     = "gcode_line";
-        j["print"]["param"]       = "G90 \n";
-        j["print"]["sequence_id"] = std::to_string(sequence_id);
-        return publish_command_json(dev_id, j, lan_mode);
-    }
-    virtual int command_auto_leveling(std::string dev_id, int sequence_id, bool lan_mode)
-    {
-        nlohmann::json j;
-        j["print"]["command"]     = "gcode_line";
-        j["print"]["param"]       = "G29 \n";
-        j["print"]["sequence_id"] = std::to_string(sequence_id);
-        return publish_command_json(dev_id, j, lan_mode);
-    }
-    virtual int command_go_home(std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode)
-    {
-        nlohmann::json j;
-        j["print"]["sequence_id"] = std::to_string(sequence_id);
-        if (supports_mqtt_homing) {
-            j["print"]["command"] = "back_to_center";
-        } else {
-            j["print"]["command"] = "gcode_line";
-            j["print"]["param"]   = is_printing ? "G28 X\n" : "G28 \n";
-        }
-        return publish_command_json(dev_id, j, lan_mode);
-    }
-    virtual int command_set_bed(std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode)
-    {
-        nlohmann::json j;
-        j["print"]["sequence_id"] = std::to_string(sequence_id);
-        if (supports_mqtt_bed_ctrl) {
-            j["print"]["command"] = "set_bed_temp";
-            j["print"]["temp"]    = temp;
-        } else {
-            j["print"]["command"] = "gcode_line";
-            j["print"]["param"]   = (boost::format("M140 S%1%\n") % temp).str();
-        }
-        return publish_command_json(dev_id, j, lan_mode);
-    }
-    virtual int command_set_nozzle(std::string dev_id, int temp, int sequence_id, bool lan_mode)
-    {
-        nlohmann::json j;
-        j["print"]["command"]     = "gcode_line";
-        j["print"]["param"]       = (boost::format("M104 S%1%\n") % temp).str();
-        j["print"]["sequence_id"] = std::to_string(sequence_id);
-        return publish_command_json(dev_id, j, lan_mode);
-    }
-
-    virtual int command_axis_control(std::string dev_id, std::string axis, double unit, double input_val, int speed,
-                                      bool is_core_xy, bool supports_mqtt_axis_control, int sequence_id, bool lan_mode)
-    {
-        (void) supports_mqtt_axis_control;
-
-        double value = input_val;
-        if (!is_core_xy && (axis == "Y" || axis == "Z"))
-            value = -input_val;
-
-        std::string value_str = (boost::format("%.1f") % (value * unit)).str();
-        std::string gcode;
-        if (axis == "X" || axis == "Y" || axis == "Z") {
-            gcode = (boost::format("G91 \nG1 %1%%2% F%3%\nG90 \n") % axis % value_str % speed).str();
-        } else if (axis == "E") {
-            gcode = (boost::format("M83 \nG0 %1%%2% F%3%\n") % axis % value_str % speed).str();
-        } else {
-            return -1;
-        }
-
-        nlohmann::json j;
-        j["print"]["command"]     = "gcode_line";
-        j["print"]["param"]       = gcode;
-        j["print"]["sequence_id"] = std::to_string(sequence_id);
-        return publish_command_json(dev_id, j, lan_mode);
-    }
-
-    /**
-     * Default LAN account username for this agent's protocol, if it has a fixed one.
-     * Returns an empty string if the agent has no fixed default (e.g. caller must supply one).
-     */
-    virtual std::string default_lan_username() const { return {}; }
-
     /**
      * Establish a direct LAN connection to a printer.
      */
-    virtual int connect_printer(const PrinterConnectionParams& params) = 0;
+    virtual int connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl) = 0;
 
     /**
      * Tear down the active LAN printer connection.
@@ -232,16 +105,12 @@ public:
     /**
      * Validate current user certificates for the printer.
      */
-    virtual int check_cert() { return BAMBU_NETWORK_SUCCESS; }
+    virtual int check_cert() = 0;
 
     /**
      * Install or refresh device certificate for LAN TLS.
      */
-    virtual void install_device_cert(std::string dev_id, bool lan_only)
-    {
-        (void) dev_id;
-        (void) lan_only;
-    }
+    virtual void install_device_cert(std::string dev_id, bool lan_only) = 0;
 
     // ========================================================================
     // Discovery
@@ -257,11 +126,7 @@ public:
     /**
      * Ping the binding endpoint to check printer readiness.
      */
-    virtual int ping_bind(std::string ping_code)
-    {
-        (void) ping_code;
-        return BAMBU_NETWORK_SUCCESS;
-    }
+    virtual int ping_bind(std::string ping_code) = 0;
 
     /**
      * Perform binding detection/handshake on a LAN printer.
@@ -271,50 +136,23 @@ public:
     /**
      * Execute the multi-stage printer binding workflow.
      */
-    virtual int bind(std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link,
-                     std::string timezone, bool improved, OnUpdateStatusFn update_fn)
-    {
-        (void) dev_ip;
-        (void) dev_id;
-        (void) dev_model;
-        (void) sec_link;
-        (void) timezone;
-        (void) improved;
-        (void) update_fn;
-        return BAMBU_NETWORK_SUCCESS;
-    }
+    virtual int bind(std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn) = 0;
 
     /**
      * Remove the association between account and printer.
      */
-    virtual int unbind(std::string dev_id)
-    {
-        (void) dev_id;
-        return BAMBU_NETWORK_SUCCESS;
-    }
+    virtual int unbind(std::string dev_id) = 0;
 
     /**
      * Request a one-time bind ticket from the server.
      */
-    virtual int request_bind_ticket(std::string* ticket)
-    {
-        if (ticket)
-            *ticket = {};
-        return BAMBU_NETWORK_SUCCESS;
-    }
+    virtual int request_bind_ticket(std::string* ticket) = 0;
 
     /**
      * Fetch the cloud snapshot image captured at a print failure.
      * Returns 0 if the request was dispatched; the image body arrives via callback(body, http_status).
      */
-    virtual int get_hms_snapshot(std::string dev_id, std::string file_name,
-                                 std::function<void(std::string, int)> callback)
-    {
-        (void) dev_id;
-        (void) file_name;
-        (void) callback;
-        return -1;
-    }
+    virtual int get_hms_snapshot(std::string dev_id, std::string file_name, std::function<void(std::string, int)> callback) = 0;
 
     /**
      * Register callback for fatal HTTP errors.
@@ -330,7 +168,7 @@ public:
     virtual std::string get_user_selected_machine() = 0;
 
     /**
-     * Update the selected cloud machine preference.
+     * Update the selected machine preference.
      */
     virtual int set_user_selected_machine(std::string dev_id) = 0;
 
@@ -446,20 +284,12 @@ public:
      */
     virtual FilamentSyncMode get_filament_sync_mode() const { return FilamentSyncMode::none; }
 
-    /**
-     * Get the camera stream mode for this agent. This value can be deterministic and derived at
-     * runtime if the printer supports multiple camera stream modes. E.g. LAN => HTTP/HTTPS/RTSP, Cloud => WebRTC.
-     *
-     * @return CameraStreamMode indicating how the camera stream is obtained or used:
-     */
-    virtual CameraStreamMode get_camera_stream_mode() const { return CameraStreamMode::none; }
-
     /**
      * Refresh filament info from the printer synchronously.
      * Should only be called when get_filament_sync_mode() returns FilamentSyncMode::pull.
      * Populates the MachineObject's DevFilaSystem with fetched filament data.
      */
-    virtual bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) { return false; }
+    virtual bool fetch_filament_info(std::string dev_id) { return false; }
 
     /**
      * Translate one filament id across the printer boundary.
@@ -470,12 +300,6 @@ public:
      */
     virtual std::string to_orca_filament_id(const std::string& printer_filament_id) const { return printer_filament_id; }
     virtual std::string from_orca_filament_id(const std::string& orca_filament_id) const { return orca_filament_id; }
-
-    /**
-     * Get the current camera stream URL for this agent's active machine.
-     * Only meaningful when get_camera_stream_mode() returns an HTTP, HTTPS, or RTSP mode.
-     */
-    virtual std::string get_camera_url() const { return {}; }
 };
 
 } // namespace Slic3r

src/slic3r/Utils/Moonraker.cpp

@@ -38,25 +38,12 @@ wxString Moonraker::get_test_failed_msg(wxString &msg) const
 
 std::string Moonraker::make_url(const std::string &path) const
 {
-    const bool has_scheme = m_host.find("http://") == 0 || m_host.find("https://") == 0;
-    const bool use_ssl    = m_host.find("https://") == 0;
-    std::string base      = has_scheme ? m_host : ("http://" + m_host);
-
-    const size_t authority_start = base.find("://") + 3;
-    const size_t authority_end   = base.find('/', authority_start);
-    const std::string authority  = base.substr(authority_start, authority_end - authority_start);
-    const size_t closing_bracket = authority.rfind(']');
-    const bool has_port = closing_bracket != std::string::npos
-        ? closing_bracket + 1 < authority.size() && authority[closing_bracket + 1] == ':'
-        : authority.find(':') != std::string::npos;
-    if (!has_port) {
-        const std::string default_port = use_ssl ? ":7130" : ":7125";
-        base.insert(authority_end == std::string::npos ? base.size() : authority_end, default_port);
+    if (m_host.find("http://") == 0 || m_host.find("https://") == 0) {
+        if (m_host.back() == '/')
+            return (boost::format("%1%%2%") % m_host % path).str();
+        return (boost::format("%1%/%2%") % m_host % path).str();
     }
-
-    if (base.back() == '/')
-        return (boost::format("%1%%2%") % base % path).str();
-    return (boost::format("%1%/%2%") % base % path).str();
+    return (boost::format("http://%1%/%2%") % m_host % path).str();
 }
 
 void Moonraker::set_auth(Http &http) const
@@ -66,8 +53,6 @@ void Moonraker::set_auth(Http &http) const
     //      filled the user/password fields — those are PrusaLink/OctoPrint conventions.
     if (!m_apikey.empty())
         http.header("X-Api-Key", m_apikey);
-    const bool use_ssl = m_host.find("https://") == 0;
-    http.tls_verify(use_ssl);
     if (!m_cafile.empty())
         http.ca_file(m_cafile);
 }

src/slic3r/Utils/MoonrakerPrinterAgent.cpp

@@ -1,6 +1,5 @@
 #include "MoonrakerPrinterAgent.hpp"
 #include "Http.hpp"
-#include "IPrinterAgent.hpp"
 #include "libslic3r/Preset.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
@@ -137,9 +136,9 @@ int MoonrakerPrinterAgent::send_message_to_printer(std::string dev_id, std::stri
     return handle_request(dev_id, json_str);
 }
 
-int MoonrakerPrinterAgent::connect_printer(const PrinterConnectionParams& params)
+int MoonrakerPrinterAgent::connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl)
 {
-    if (params.dev_id.empty() || params.host.empty()) {
+    if (dev_id.empty() || dev_ip.empty()) {
         BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: connect_printer missing dev_id or dev_ip";
         return BAMBU_NETWORK_ERR_INVALID_HANDLE;
     }
@@ -149,7 +148,7 @@ int MoonrakerPrinterAgent::connect_printer(const PrinterConnectionParams& params
     uint64_t gen;
     {
         std::lock_guard<std::recursive_mutex> lock(connect_mutex);
-        init_device_info(params.dev_id, params.host, params.username, params.password, params.use_ssl, params.port);
+        init_device_info(dev_id, dev_ip, username, password, use_ssl);
         gen = ++connect_generation;
         base_url = device_info.base_url;
         api_key  = device_info.api_key;
@@ -171,7 +170,7 @@ int MoonrakerPrinterAgent::connect_printer(const PrinterConnectionParams& params
     // Launch connection in background thread (capture by value to avoid data races)
     {
         std::lock_guard<std::recursive_mutex> lock(connect_mutex);
-        connect_thread = std::thread([this, dev_id = params.dev_id, base_url, api_key, gen]() { perform_connection_async(dev_id, base_url, api_key, gen); });
+        connect_thread = std::thread([this, dev_id, base_url, api_key, gen]() { perform_connection_async(dev_id, base_url, api_key, gen); });
     }
 
     return BAMBU_NETWORK_SUCCESS;
@@ -192,6 +191,14 @@ int MoonrakerPrinterAgent::disconnect_printer()
     return BAMBU_NETWORK_SUCCESS;
 }
 
+int MoonrakerPrinterAgent::check_cert() { return BAMBU_NETWORK_SUCCESS; }
+
+void MoonrakerPrinterAgent::install_device_cert(std::string dev_id, bool lan_only)
+{
+    (void) dev_id;
+    (void) lan_only;
+}
+
 bool MoonrakerPrinterAgent::start_discovery(bool start, bool sending)
 {
     (void) sending;
@@ -201,6 +208,12 @@ bool MoonrakerPrinterAgent::start_discovery(bool start, bool sending)
     return true;
 }
 
+int MoonrakerPrinterAgent::ping_bind(std::string ping_code)
+{
+    (void) ping_code;
+    return BAMBU_NETWORK_SUCCESS;
+}
+
 int MoonrakerPrinterAgent::bind_detect(std::string dev_ip, std::string sec_link, detectResult& detect)
 {
     (void) sec_link;
@@ -208,7 +221,7 @@ int MoonrakerPrinterAgent::bind_detect(std::string dev_ip, std::string sec_link,
     detect.dev_id   = device_info.dev_id.empty() ? dev_ip : device_info.dev_id;
     detect.model_id = device_info.model_id.empty() ? device_info.model_name : device_info.model_id;
     // Prefer fetched hostname, then preset model name, then generic fallback
-    detect.dev_name     = device_info.dev_name.empty() ? dev_ip : device_info.dev_name;
+    detect.dev_name     = device_info.dev_name;
     detect.model_id     = device_info.model_id;
     detect.version      = device_info.version;
     detect.connect_type = "lan";
@@ -217,6 +230,41 @@ int MoonrakerPrinterAgent::bind_detect(std::string dev_ip, std::string sec_link,
     return BAMBU_NETWORK_SUCCESS;
 }
 
+int MoonrakerPrinterAgent::bind(
+    std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn)
+{
+    (void) dev_ip;
+    (void) dev_id;
+    (void) dev_model;
+    (void) sec_link;
+    (void) timezone;
+    (void) improved;
+    (void) update_fn;
+    return BAMBU_NETWORK_SUCCESS;
+}
+
+int MoonrakerPrinterAgent::unbind(std::string dev_id)
+{
+    (void) dev_id;
+    return BAMBU_NETWORK_SUCCESS;
+}
+
+int MoonrakerPrinterAgent::request_bind_ticket(std::string* ticket)
+{
+    if (ticket)
+        *ticket = "";
+    return BAMBU_NETWORK_SUCCESS;
+}
+
+int MoonrakerPrinterAgent::get_hms_snapshot(std::string dev_id, std::string file_name, std::function<void(std::string, int)> callback)
+{
+    // No BBL cloud snapshot source; report failure so the caller falls back.
+    (void) dev_id;
+    (void) file_name;
+    (void) callback;
+    return -1;
+}
+
 int MoonrakerPrinterAgent::set_server_callback(OnServerErrFn fn)
 {
     std::lock_guard<std::recursive_mutex> lock(state_mutex);
@@ -337,7 +385,7 @@ int MoonrakerPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusF
     if (update_fn)
         update_fn(PrintingStageSending, 0, "Starting print...");
     std::string gcode = "SDCARD_PRINT_FILE FILENAME=" + upload_filename;
-    if (!send_gcode_sync(device_info.dev_id, gcode)) {
+    if (!send_gcode(device_info.dev_id, gcode)) {
         return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
     }
 
@@ -530,7 +578,7 @@ void MoonrakerPrinterAgent::build_ams_payload(int ams_count, int max_lane_index,
     }
 }
 
-bool MoonrakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
+bool MoonrakerPrinterAgent::fetch_filament_info(std::string dev_id)
 {
     std::vector<AmsTrayData> trays;
     int max_lane_index = 0;
@@ -987,11 +1035,14 @@ int MoonrakerPrinterAgent::handle_request(const std::string& dev_id, const std::
             }
             response["print"]["param"] = gcode;
 
-            send_gcode_async(dev_id, gcode, [this, dev_id, response](bool success) mutable {
-                response["print"]["result"] = success ? "success" : "failed";
+            if (send_gcode(dev_id, gcode)) {
+                response["print"]["result"] = "success";
                 dispatch_message(dev_id, response.dump());
-            });
-            return BAMBU_NETWORK_SUCCESS;
+                return BAMBU_NETWORK_SUCCESS;
+            }
+            response["print"]["result"] = "failed";
+            dispatch_message(dev_id, response.dump());
+            return BAMBU_NETWORK_ERR_CONNECTION_TO_PRINTER_FAILED;
         }
 
         // Print control commands
@@ -1010,7 +1061,7 @@ int MoonrakerPrinterAgent::handle_request(const std::string& dev_id, const std::
             if (json["print"].contains("temp") && json["print"]["temp"].is_number()) {
                 int         temp  = json["print"]["temp"].get<int>();
                 std::string gcode = "SET_HEATER_TEMPERATURE HEATER=heater_bed TARGET=" + std::to_string(temp);
-                send_gcode_async(dev_id, gcode);
+                send_gcode(dev_id, gcode);
                 return BAMBU_NETWORK_SUCCESS;
             }
         }
@@ -1025,21 +1076,20 @@ int MoonrakerPrinterAgent::handle_request(const std::string& dev_id, const std::
                 }
                 std::string heater = (extruder_idx == 0) ? "extruder" : "extruder" + std::to_string(extruder_idx);
                 std::string gcode  = "SET_HEATER_TEMPERATURE HEATER=" + heater + " TARGET=" + std::to_string(temp);
-                send_gcode_async(dev_id, gcode);
+                send_gcode(dev_id, gcode);
                 return BAMBU_NETWORK_SUCCESS;
             }
         }
 
         if (cmd == "home") {
-            send_gcode_async(dev_id, "G28");
-            return BAMBU_NETWORK_SUCCESS;
+            return send_gcode(dev_id, "G28") ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_SEND_MSG_FAILED;
         }
     }
 
     return BAMBU_NETWORK_SUCCESS;
 }
 
-bool MoonrakerPrinterAgent::init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port)
+bool MoonrakerPrinterAgent::init_device_info(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl)
 {
     device_info         = MoonrakerDeviceInfo{};
     auto* preset_bundle = GUI::wxGetApp().preset_bundle;
@@ -1049,12 +1099,12 @@ bool MoonrakerPrinterAgent::init_device_info(const std::string& dev_id, const st
 
     auto&       preset      = preset_bundle->printers.get_edited_preset();
     const auto& printer_cfg = preset.config;
+    device_info.dev_ip      = dev_ip;
 
-    device_info.dev_ip     = dev_ip;
     device_info.api_key    = password;
     device_info.model_name = printer_cfg.opt_string("printer_model");
     device_info.model_id   = preset.get_printer_type(preset_bundle);
-    device_info.base_url   = normalize_base_url(use_ssl, dev_ip, port);
+    device_info.base_url   = use_ssl ? "https://" + dev_ip : "http://" + dev_ip;
     device_info.dev_id     = dev_id;
     device_info.version    = "";
     device_info.dev_name   = device_info.dev_id;
@@ -1174,45 +1224,7 @@ bool MoonrakerPrinterAgent::query_printer_status(const std::string& base_url,
     return true;
 }
 
-void MoonrakerPrinterAgent::send_gcode_async(const std::string& dev_id, const std::string& gcode,
-                                             std::function<void(bool)> on_result) const
-{
-    (void) dev_id;
-    const std::string base_url = device_info.base_url;
-    const std::string api_key  = device_info.api_key;
-    auto http = Http::post(join_url(base_url, "/printer/gcode/script"));
-    if (!api_key.empty()) {
-        http.header("X-Api-Key", api_key);
-    }
-    http.header("Content-Type", "application/json")
-        .set_post_body(nlohmann::json{{"script", gcode}}.dump())
-        .timeout_connect(5)
-        .timeout_max(10)
-        .on_complete([on_result](std::string body, unsigned status_code) {
-            (void) body;
-            const bool success = status_code == 200;
-            if (!success) {
-                BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: send_gcode failed: HTTP error " << status_code;
-            }
-            if (on_result) {
-                on_result(success);
-            }
-        })
-        .on_error([on_result](std::string body, std::string err, unsigned status_code) {
-            (void) body;
-            std::string error = err;
-            if (status_code > 0) {
-                error += " (HTTP " + std::to_string(status_code) + ")";
-            }
-            BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: send_gcode failed: " << error;
-            if (on_result) {
-                on_result(false);
-            }
-        })
-        .perform();
-}
-
-bool MoonrakerPrinterAgent::send_gcode_sync(const std::string& dev_id, const std::string& gcode) const
+bool MoonrakerPrinterAgent::send_gcode(const std::string& dev_id, const std::string& gcode) const
 {
     nlohmann::json payload;
     payload["script"]       = gcode;
@@ -2017,20 +2029,17 @@ bool MoonrakerPrinterAgent::upload_gcode(const std::string& local_path,
 
 int MoonrakerPrinterAgent::pause_print(const std::string& dev_id)
 {
-    send_gcode_async(dev_id, "PAUSE");
-    return BAMBU_NETWORK_SUCCESS;
+    return send_gcode(dev_id, "PAUSE") ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_SEND_MSG_FAILED;
 }
 
 int MoonrakerPrinterAgent::resume_print(const std::string& dev_id)
 {
-    send_gcode_async(dev_id, "RESUME");
-    return BAMBU_NETWORK_SUCCESS;
+    return send_gcode(dev_id, "RESUME") ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_SEND_MSG_FAILED;
 }
 
 int MoonrakerPrinterAgent::cancel_print(const std::string& dev_id)
 {
-    send_gcode_async(dev_id, "CANCEL_PRINT");
-    return BAMBU_NETWORK_SUCCESS;
+    return send_gcode(dev_id, "CANCEL_PRINT") ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_SEND_MSG_FAILED;
 }
 
 bool MoonrakerPrinterAgent::send_jsonrpc_command(const std::string&    base_url,
@@ -2097,13 +2106,13 @@ void MoonrakerPrinterAgent::perform_connection_async(const std::string& dev_id,
             if (is_stale()) {
                 return;
             }
-            device_info.dev_name     = fetched_info.dev_name.empty() ? dev_id : fetched_info.dev_name;
+            device_info.dev_name     = fetched_info.dev_name;
             device_info.version      = fetched_info.version;
             device_info.klippy_state = fetched_info.klippy_state;
         }
 
 // Orca todo: disable websocket for now, as we don't use MonitorPanel for Moonraker printers yet
-#if 1
+#if 0
         // Query initial status
         nlohmann::json initial_status;
         if (query_printer_status(base_url, api_key, initial_status, error_msg)) {
@@ -2144,11 +2153,26 @@ bool MoonrakerPrinterAgent::is_numeric(const std::string& value)
     return !value.empty() && std::all_of(value.begin(), value.end(), [](unsigned char c) { return std::isdigit(c) != 0; });
 }
 
-std::string MoonrakerPrinterAgent::normalize_base_url(bool use_ssl, const std::string& host, const std::string& port)
+std::string MoonrakerPrinterAgent::normalize_base_url(std::string host, const std::string& port)
 {
-    std::string value = use_ssl ? "https://" : "http://";
-    value += host;
-    value += port.empty() ? "" : (":" + port);
+    boost::trim(host);
+    if (host.empty()) {
+        return "";
+    }
+
+    std::string value = host;
+    if (is_numeric(port) && value.find("://") == std::string::npos && value.find(':') == std::string::npos) {
+        value += ":" + port;
+    }
+
+    if (!boost::istarts_with(value, "http://") && !boost::istarts_with(value, "https://")) {
+        value = "http://" + value;
+    }
+
+    if (value.size() > 1 && value.back() == '/') {
+        value.pop_back();
+    }
+
     return value;
 }
 

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -28,15 +28,24 @@ public:
 
     // Communication
     int send_message(std::string dev_id, std::string json_str, int qos, int flag) override;
-    int connect_printer(const PrinterConnectionParams& params) override;
+    int connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl) override;
     int disconnect_printer() override;
     int send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag) override;
 
+    // Certificates
+    int check_cert() override;
+    void install_device_cert(std::string dev_id, bool lan_only) override;
+
     // Discovery
     bool start_discovery(bool start, bool sending) override;
 
     // Binding
+    int ping_bind(std::string ping_code) override;
     int bind_detect(std::string dev_ip, std::string sec_link, detectResult& detect) override;
+    int bind(std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn) override;
+    int unbind(std::string dev_id) override;
+    int request_bind_ticket(std::string* ticket) override;
+    int get_hms_snapshot(std::string dev_id, std::string file_name, std::function<void(std::string, int)> callback) override;
     int set_server_callback(OnServerErrFn fn) override;
 
     // Machine Selection
@@ -62,7 +71,7 @@ public:
 
     // Pull-mode agent (on-demand filament sync)
     FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::pull; }
-    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
+    bool fetch_filament_info(std::string dev_id) override;
 
 protected:
     struct MoonrakerDeviceInfo
@@ -94,7 +103,7 @@ protected:
     void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
 
     // Methods that derived classes may need to override or access
-    virtual bool init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port);
+    virtual bool init_device_info(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl);
     virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
 
     // State access for derived classes
@@ -102,7 +111,7 @@ protected:
 
     // Helpers
     bool        is_numeric(const std::string& value);
-    std::string normalize_base_url(bool use_ssl, const std::string& host, const std::string& port);
+    std::string normalize_base_url(std::string host, const std::string& port);
     std::string sanitize_filename(const std::string& filename);
     std::string join_url(const std::string& base_url, const std::string& path) const;
 
@@ -119,9 +128,7 @@ private:
 
     bool fetch_object_list(const std::string& base_url, const std::string& api_key, std::set<std::string>& objects, std::string& error) const;
     bool query_printer_status(const std::string& base_url, const std::string& api_key, nlohmann::json& status, std::string& error) const;
-    bool send_gcode_sync(const std::string& dev_id, const std::string& gcode) const;
-    void send_gcode_async(const std::string& dev_id, const std::string& gcode,
-                          std::function<void(bool)> on_result = {}) const;
+    bool send_gcode(const std::string& dev_id, const std::string& gcode) const;
 
     void announce_printhost_device();
     void dispatch_local_connect(int state, const std::string& dev_id, const std::string& msg);

src/slic3r/Utils/NetworkAgent.cpp

@@ -1,10 +1,11 @@
-#include "NetworkAgent.hpp"
-
+#include <stdio.h>
 #include <stdlib.h>
+#include <set>
+#include <algorithm>
 
 #include <boost/log/trivial.hpp>
-#include <nlohmann/json.hpp>
-#include "IPrinterAgent.hpp"
+#include "libslic3r/Utils.hpp"
+#include "NetworkAgent.hpp"
 #include "BBLNetworkPlugin.hpp"
 
 namespace Slic3r {
@@ -114,8 +115,6 @@ void NetworkAgent::add_cloud_agent(const std::string& provider, std::shared_ptr<
 
 void NetworkAgent::set_printer_agent(std::shared_ptr<IPrinterAgent> printer_agent)
 {
-    m_user_machine_list_generation.fetch_add(1);
-
     // Disconnect all callbacks from the old agent
     auto old_printer_agent = m_printer_agent;
 
@@ -433,26 +432,10 @@ int NetworkAgent::check_user_task_report(int* task_id, bool* printable, const st
 
 int NetworkAgent::get_user_print_info(unsigned int* http_code, std::string* http_body, const std::string& provider)
 {
-    const std::string request_agent_id = m_printer_agent_id;
-    const std::uint64_t request_generation = m_user_machine_list_generation.fetch_add(1) + 1;
     const auto cloud_agent = get_cloud_agent(provider);
-    if (!cloud_agent)
-        return -1;
-
-    const int result = cloud_agent->get_user_print_info(http_code, http_body);
-    if (result == 0 && http_body) {
-        try {
-            nlohmann::json response = nlohmann::json::parse(*http_body);
-            response["provider"] = provider;
-            response["agent_id"] = request_agent_id;
-            response["generation"] = request_generation;
-            *http_body = response.dump();
-        }
-        catch (const std::exception& e) {
-            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " metadata injection exception=" << e.what();
-        }
-    }
-    return result;
+    if (cloud_agent)
+        return cloud_agent->get_user_print_info(http_code, http_body);
+    return -1;
 }
 
 int NetworkAgent::get_user_tasks(TaskQueryParams params, std::string* http_body, const std::string& provider)
@@ -532,15 +515,6 @@ int NetworkAgent::get_camera_url(std::string dev_id, std::function<void(std::str
     return -1;
 }
 
-std::unique_ptr<ICameraSignalingChannel>
-NetworkAgent::create_camera_signaling_channel(const std::string& dev_id, const std::string& provider)
-{
-    const auto cloud_agent = get_cloud_agent(provider);
-    if (cloud_agent)
-        return cloud_agent->create_camera_signaling_channel(dev_id);
-    return nullptr;
-}
-
 int NetworkAgent::get_design_staffpick(int offset, int limit, std::function<void(std::string)> callback, const std::string& provider)
 {
     const auto cloud_agent = get_cloud_agent(provider);
@@ -793,81 +767,10 @@ int NetworkAgent::send_message(std::string dev_id, std::string json_str, int qos
     return -1;
 }
 
-int NetworkAgent::command_ams_refresh_rfid(std::string dev_id, int ams_id, int slot_id, int sequence_id, bool lan_mode)
+int NetworkAgent::connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl)
 {
     if (m_printer_agent)
-        return m_printer_agent->command_ams_refresh_rfid(dev_id, ams_id, slot_id, sequence_id, lan_mode);
-    return -1;
-}
-
-int NetworkAgent::command_ams_calibrate(std::string dev_id, int ams_id, int sequence_id, bool lan_mode)
-{
-    if (m_printer_agent)
-        return m_printer_agent->command_ams_calibrate(dev_id, ams_id, sequence_id, lan_mode);
-    return -1;
-}
-
-int NetworkAgent::command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode)
-{
-    if (m_printer_agent)
-        return m_printer_agent->command_ams_select_tray(dev_id, tray_id, sequence_id, lan_mode);
-    return -1;
-}
-
-int NetworkAgent::command_start_camera(std::string dev_id)
-{
-    if (m_printer_agent)
-        return m_printer_agent->command_start_camera(dev_id);
-    return -1;
-}
-
-int NetworkAgent::command_xyz_abs(std::string dev_id, int sequence_id, bool lan_mode)
-{
-    if (m_printer_agent)
-        return m_printer_agent->command_xyz_abs(dev_id, sequence_id, lan_mode);
-    return -1;
-}
-
-int NetworkAgent::command_auto_leveling(std::string dev_id, int sequence_id, bool lan_mode)
-{
-    if (m_printer_agent)
-        return m_printer_agent->command_auto_leveling(dev_id, sequence_id, lan_mode);
-    return -1;
-}
-
-int NetworkAgent::command_go_home(std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode)
-{
-    if (m_printer_agent)
-        return m_printer_agent->command_go_home(dev_id, is_printing, supports_mqtt_homing, sequence_id, lan_mode);
-    return -1;
-}
-
-int NetworkAgent::command_set_bed(std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode)
-{
-    if (m_printer_agent)
-        return m_printer_agent->command_set_bed(dev_id, temp, supports_mqtt_bed_ctrl, sequence_id, lan_mode);
-    return -1;
-}
-
-int NetworkAgent::command_set_nozzle(std::string dev_id, int temp, int sequence_id, bool lan_mode)
-{
-    if (m_printer_agent)
-        return m_printer_agent->command_set_nozzle(dev_id, temp, sequence_id, lan_mode);
-    return -1;
-}
-
-int NetworkAgent::command_axis_control(std::string dev_id, std::string axis, double unit, double input_val, int speed,
-                                        bool is_core_xy, bool supports_mqtt_axis_control, int sequence_id, bool lan_mode)
-{
-    if (m_printer_agent)
-        return m_printer_agent->command_axis_control(dev_id, axis, unit, input_val, speed, is_core_xy, supports_mqtt_axis_control, sequence_id, lan_mode);
-    return -1;
-}
-
-int NetworkAgent::connect_printer(const PrinterConnectionParams& params)
-{
-    if (m_printer_agent)
-        return m_printer_agent->connect_printer(params);
+        return m_printer_agent->connect_printer(dev_id, dev_ip, username, password, use_ssl);
     return -1;
 }
 
@@ -885,13 +788,6 @@ int NetworkAgent::send_message_to_printer(std::string dev_id, std::string json_s
     return -1;
 }
 
-std::string NetworkAgent::default_lan_username() const
-{
-    if (m_printer_agent)
-        return m_printer_agent->default_lan_username();
-    return {};
-}
-
 int NetworkAgent::check_cert()
 {
     if (m_printer_agent)
@@ -950,14 +846,8 @@ std::string NetworkAgent::get_user_selected_machine()
 
 int NetworkAgent::set_user_selected_machine(std::string dev_id)
 {
-    BOOST_LOG_TRIVIAL(trace) << "NetworkAgent::set_user_selected_machine: dev_id=" << dev_id
-                            << " printer_agent=" << (m_printer_agent ? m_printer_agent->get_agent_info().id : "<null>");
-    if (m_printer_agent) {
-        const int result = m_printer_agent->set_user_selected_machine(dev_id);
-        BOOST_LOG_TRIVIAL(trace) << "NetworkAgent::set_user_selected_machine: result=" << result;
-        return result;
-    }
-    BOOST_LOG_TRIVIAL(warning) << "NetworkAgent::set_user_selected_machine: no printer agent";
+    if (m_printer_agent)
+        return m_printer_agent->set_user_selected_machine(dev_id);
     return -1;
 }
 
@@ -977,27 +867,15 @@ int NetworkAgent::stop_subscribe(std::string module)
 
 int NetworkAgent::add_subscribe(std::vector<std::string> dev_list)
 {
-    BOOST_LOG_TRIVIAL(trace) << "NetworkAgent::add_subscribe: count=" << dev_list.size()
-                            << " printer_agent=" << (m_printer_agent ? m_printer_agent->get_agent_info().id : "<null>");
-    if (m_printer_agent) {
-        const int result = m_printer_agent->add_subscribe(std::move(dev_list));
-        BOOST_LOG_TRIVIAL(trace) << "NetworkAgent::add_subscribe: result=" << result;
-        return result;
-    }
-    BOOST_LOG_TRIVIAL(warning) << "NetworkAgent::add_subscribe: no printer agent";
+    if (m_printer_agent)
+        return m_printer_agent->add_subscribe(std::move(dev_list));
     return -1;
 }
 
 int NetworkAgent::del_subscribe(std::vector<std::string> dev_list)
 {
-    BOOST_LOG_TRIVIAL(trace) << "NetworkAgent::del_subscribe: count=" << dev_list.size()
-                            << " printer_agent=" << (m_printer_agent ? m_printer_agent->get_agent_info().id : "<null>");
-    if (m_printer_agent) {
-        const int result = m_printer_agent->del_subscribe(std::move(dev_list));
-        BOOST_LOG_TRIVIAL(trace) << "NetworkAgent::del_subscribe: result=" << result;
-        return result;
-    }
-    BOOST_LOG_TRIVIAL(warning) << "NetworkAgent::del_subscribe: no printer agent";
+    if (m_printer_agent)
+        return m_printer_agent->del_subscribe(std::move(dev_list));
     return -1;
 }
 
@@ -1043,10 +921,10 @@ FilamentSyncMode NetworkAgent::get_filament_sync_mode() const
     return FilamentSyncMode::none;
 }
 
-bool NetworkAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool NetworkAgent::fetch_filament_info(std::string dev_id)
 {
     if (m_printer_agent) {
-        return m_printer_agent->fetch_filament_info(dev_id, sync_mode);
+        return m_printer_agent->fetch_filament_info(dev_id);
     }
     return false;
 }
@@ -1065,20 +943,6 @@ std::string NetworkAgent::from_orca_filament_id(const std::string& orca_filament
     return orca_filament_id;
 }
 
-CameraStreamMode NetworkAgent::get_camera_stream_mode() const
-{
-    if (m_printer_agent)
-        return m_printer_agent->get_camera_stream_mode();
-    return CameraStreamMode::none;
-}
-
-std::string NetworkAgent::get_local_camera_stream_url() const
-{
-    if (m_printer_agent)
-        return m_printer_agent->get_camera_url();
-    return {};
-}
-
 int NetworkAgent::request_bind_ticket(std::string* ticket)
 {
     if (m_printer_agent)

src/slic3r/Utils/NetworkAgent.hpp

@@ -2,22 +2,16 @@
 #define __NETWORK_Agent_HPP__
 
 #include "bambu_networking.hpp"
-
 #include "libslic3r/ProjectTask.hpp"
 #include "ICloudServiceAgent.hpp"
 #include "IPrinterAgent.hpp"
-
 #include <map>
-#include <atomic>
-#include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace Slic3r {
 
-class IPrinterAgent;
-
 // Forward declaration
 class BBLNetworkPlugin;
 
@@ -56,7 +50,6 @@ public:
     // Sub-agent accessors
     std::shared_ptr<ICloudServiceAgent> get_cloud_agent(const std::string& provider = ORCA_CLOUD_PROVIDER) const;
     std::shared_ptr<IPrinterAgent> get_printer_agent() const { return m_printer_agent; }
-    std::uint64_t get_user_machine_list_generation() const { return m_user_machine_list_generation.load(); }
 
     // Shared agent management
     void add_cloud_agent(const std::string& provider, std::shared_ptr<ICloudServiceAgent> agent);
@@ -116,7 +109,6 @@ public:
     int query_bind_status(std::vector<std::string> query_list, unsigned int* http_code, std::string* http_body, const std::string& provider = ORCA_CLOUD_PROVIDER);
     int modify_printer_name(std::string dev_id, std::string dev_name, const std::string& provider = ORCA_CLOUD_PROVIDER);
     int get_camera_url(std::string dev_id, std::function<void(std::string)> callback, const std::string& provider = ORCA_CLOUD_PROVIDER);
-    std::unique_ptr<ICameraSignalingChannel> create_camera_signaling_channel(const std::string& dev_id, const std::string& provider = ORCA_CLOUD_PROVIDER);
     int get_design_staffpick(int offset, int limit, std::function<void(std::string)> callback, const std::string& provider = ORCA_CLOUD_PROVIDER);
     int start_publish(PublishParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, std::string* out, const std::string& provider = ORCA_CLOUD_PROVIDER);
     int get_model_publish_url(std::string* url, const std::string& provider = ORCA_CLOUD_PROVIDER);
@@ -150,21 +142,9 @@ public:
     int set_on_local_message_fn(OnMessageFn fn);
     int set_server_callback(OnServerErrFn fn);
     int send_message(std::string dev_id, std::string json_str, int qos, int flag);
-    int command_ams_refresh_rfid(std::string dev_id, int ams_id, int slot_id, int sequence_id, bool lan_mode);
-    int command_ams_calibrate(std::string dev_id, int ams_id, int sequence_id, bool lan_mode);
-    int command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode);
-    int command_start_camera(std::string dev_id);
-    int command_xyz_abs(std::string dev_id, int sequence_id, bool lan_mode);
-    int command_auto_leveling(std::string dev_id, int sequence_id, bool lan_mode);
-    int command_go_home(std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode);
-    int command_set_bed(std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode);
-    int command_set_nozzle(std::string dev_id, int temp, int sequence_id, bool lan_mode);
-    int command_axis_control(std::string dev_id, std::string axis, double unit, double input_val, int speed,
-                              bool is_core_xy, bool supports_mqtt_axis_control, int sequence_id, bool lan_mode);
-    int connect_printer(const PrinterConnectionParams& params);
+    int connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl);
     int disconnect_printer();
     int send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag);
-    std::string default_lan_username() const;
     int check_cert();
     void install_device_cert(std::string dev_id, bool lan_only);
     bool start_discovery(bool start, bool sending);
@@ -184,9 +164,7 @@ public:
     int start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
     int start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
     FilamentSyncMode get_filament_sync_mode() const;
-    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull);
-    CameraStreamMode get_camera_stream_mode() const;
-    std::string get_local_camera_stream_url() const;
+    bool fetch_filament_info(std::string dev_id);
     std::string to_orca_filament_id(const std::string& printer_filament_id) const;
     std::string from_orca_filament_id(const std::string& orca_filament_id) const;
     int request_bind_ticket(std::string* ticket);
@@ -217,7 +195,6 @@ private:
     std::map<std::string, std::shared_ptr<ICloudServiceAgent>> m_cloud_agents;
     std::shared_ptr<IPrinterAgent> m_printer_agent;
     std::string m_printer_agent_id;
-    std::atomic<std::uint64_t> m_user_machine_list_generation{0};
 };
 
 }

src/slic3r/Utils/NetworkAgentFactory.cpp

@@ -16,10 +16,8 @@
 #include <mutex>
 #include <utility>
 #include <slic3r/GUI/GUI_App.hpp>
-#include <slic3r/GUI/I18N.hpp>
 #include <slic3r/plugin/PluginDescriptor.hpp>
 #include <slic3r/plugin/PythonPluginInterface.hpp>
-#include <wx/msgdlg.h>
 
 namespace Slic3r {
 namespace {
@@ -316,21 +314,6 @@ void NetworkAgentFactory::register_python_printer_agent(const std::string& plugi
 
     std::shared_ptr<IPrinterAgent> cached_agent;
 
-    auto reject_conflicting_capability = [plugin_key, capability_name](const std::string& error_message) {
-        if (!wxTheApp || GUI::wxGetApp().is_closing())
-            return;
-        GUI::wxGetApp().CallAfter([plugin_key, capability_name, error_message]() {
-            if (GUI::wxGetApp().is_closing())
-                return;
-            PluginManager& manager = PluginManager::instance();
-            manager.set_plugin_error(plugin_key, error_message);
-            // note: the unload callback triggered by disabling will call deregister,
-            // which will be a no-op since the printer agent is never registered
-            manager.set_capability_enabled({PluginCapabilityType::PrinterConnection, capability_name, plugin_key}, false);
-            wxMessageBox(wxString::FromUTF8(error_message.c_str()), _L("Plugins"), wxOK | wxICON_WARNING, GUI::wxGetApp().GetTopWindow());
-        });
-    };
-
     {
         std::lock_guard<std::mutex> lock(s_registry_mutex);
 
@@ -349,10 +332,9 @@ void NetworkAgentFactory::register_python_printer_agent(const std::string& plugi
         auto& python_agent_ids = get_python_printer_agent_ids();
         for (const auto& pair : python_agent_ids) {
             if (pair.first != capability_key && pair.second == info.id) {
-                const std::string error_message = "Printer-agent '" + info.name + "' could not be enabled: agent ID '" + info.id +
-                                                  "' is already registered by capability '" + pair.first.second + "' from plugin '" + pair.first.first + "'.";
-                BOOST_LOG_TRIVIAL(warning) << error_message;
-                reject_conflicting_capability(error_message);
+                BOOST_LOG_TRIVIAL(warning) << "Printer-agent plugin '" << capability_name << "' uses duplicate agent ID '" << info.id
+                                           << "' already registered by capability '" << pair.first.second << "' from plugin '"
+                                           << pair.first.first << "'";
                 return;
             }
         }
@@ -372,22 +354,12 @@ void NetworkAgentFactory::register_python_printer_agent(const std::string& plugi
 
         auto& agents = get_printer_agents();
         auto agent_it = agents.find(info.id);
-        // why: reject only when the ID is owned by SOMEONE ELSE - a built-in has an empty
-        //   plugin_identifier, another plugin/capability has a different plugin_full_ref. When it
-        //   IS the same plugin_full_ref, this capability is just re-registering itself, so fall
-        //   through and refresh.
         if (agent_it != agents.end() && agent_it->second.plugin_identifier != plugin_full_ref) {
-            const std::string error_message = "Printer-agent '" + info.name + "' could not be enabled: agent ID '" + info.id +
-                                              "' is already registered by '" + agent_it->second.display_name + "'.";
-            BOOST_LOG_TRIVIAL(warning) << error_message;
-            reject_conflicting_capability(error_message);
+            BOOST_LOG_TRIVIAL(warning) << "Printer-agent plugin '" << capability_name << "' uses agent ID '" << info.id
+                                       << "' already registered by '" << agent_it->second.display_name << "'";
             return;
         }
 
-        // why: insert_or_assign, not emplace - reaching here means the ID is new, or the same
-        //   capability is re-registering (same plugin_full_ref). In the re-register case we WANT to
-        //   overwrite so the factory closure points at the current live capability instance; emplace
-        //   would silently keep the stale entry.
         agents.insert_or_assign(info.id, PrinterAgentInfo(info.id, info.name, plugin_full_ref, std::move(factory)));
         python_agent_ids[capability_key] = info.id;
 

src/slic3r/Utils/OrcaCloudServiceAgent.cpp

@@ -83,7 +83,6 @@ constexpr const char* ORCA_UNSUBSCRIBE_PLUGINS = "/api/v1/plugins/subscriptions"
 constexpr const char* ORCA_PLUGINS_MINE        = "/api/v1/plugins/mine";
 constexpr const char* ORCA_PLUGINS_BASE        = "/api/v1/plugins";
 constexpr const char* ORCA_PLUGIN_DOWNLOAD_URL = "/api/v1/plugins/download";
-constexpr const char* ORCA_CLOUD_PRINTER       = "/api/v1/printers";
 
 constexpr const char* ORCA_CLOUD_LOGIN_PATH = "/orcaslicer-login";
 
@@ -1476,15 +1475,8 @@ void OrcaCloudServiceAgent::save_sync_state()
     if (sync_state_path.empty())
         return;
 
-    try {
-        std::string tmp_path = sync_state_path + ".tmp";
-        std::ofstream ofs(tmp_path, std::ios::out | std::ios::trunc);
-        if (ofs.good()) {
-            ofs << std::to_string(sync_state.last_sync_timestamp);
-            ofs.close();
-            boost::filesystem::rename(tmp_path, sync_state_path);
-        }
-    } catch (...) {}
+    if (const std::error_code ec = write_file_atomically(sync_state_path, std::to_string(sync_state.last_sync_timestamp)))
+        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: failed to save the sync state: " << ec.message();
 }
 
 void OrcaCloudServiceAgent::clear_sync_state()
@@ -1573,22 +1565,10 @@ void OrcaCloudServiceAgent::persist_user_secret(const std::string& secret)
             wxFileName::Mkdir(path.GetPath(), wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
         }
 
-        const std::string tmp_path = secret_fallback_path + ".tmp";
-        std::ofstream ofs(tmp_path, std::ios::out | std::ios::trunc | std::ios::binary);
-        if (ofs.good()) {
-            ofs << signed_payload;
-            ofs.flush();
-            ofs.close();
-
-            if (wxRenameFile(wxString::FromUTF8(tmp_path.c_str()), wxString::FromUTF8(secret_fallback_path.c_str()), true)) {
-                stored = true;
-            } else {
-                wxRemoveFile(wxString::FromUTF8(tmp_path.c_str()));
-                BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: failed to atomically replace user secret file";
-            }
-        } else {
-            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: cannot open user secret file for write - " << secret_fallback_path;
-        }
+        if (const std::error_code ec = write_file_atomically(secret_fallback_path, signed_payload, /*binary=*/true))
+            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: cannot write user secret file " << secret_fallback_path << ": " << ec.message();
+        else
+            stored = true;
     } else {
         // Use wxSecretStore only
         wxSecretStore store = wxSecretStore::GetDefault();
@@ -2624,51 +2604,11 @@ int OrcaCloudServiceAgent::check_user_task_report(int* task_id, bool* printable)
 
 int OrcaCloudServiceAgent::get_user_print_info(unsigned int* http_code, std::string* http_body)
 {
-    std::string response;
-    unsigned int code = 0;
-    int result = http_get(ORCA_CLOUD_PRINTER, &response, &code);
-
+    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_user_print_info (stub)";
     if (http_code)
-        *http_code = code;
-
-    if (result != 0 || code != 200)
-        return result != 0 ? result : BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED;
-
-    try {
-        auto resp_json = nlohmann::json::parse(response);
-        nlohmann::json devices = nlohmann::json::array();
-
-        for (const auto& printer : resp_json.value("data", nlohmann::json::array())) {
-            const std::string role = printer.value("access_role", "");
-            if (role.empty() || role == "viewer")
-                continue;
-
-            nlohmann::json device;
-            device["dev_id"]   = printer.value("id", "");
-            device["dev_name"] = printer.value("name", "");
-            if (printer.contains("model") && printer["model"].is_string())
-                device["dev_model_name"] = printer["model"].get<std::string>();
-
-            bool online = false;
-            if (printer.contains("status_snapshot") && printer["status_snapshot"].is_object()) {
-                const auto& status = printer["status_snapshot"].value("status", nlohmann::json::object());
-                online = status.value("connection", nlohmann::json::object()).value("state", "") == "online";
-                if (status.contains("job") && status["job"].is_object())
-                    device["task_status"] = status["job"].value("state", "");
-            }
-            device["dev_online"] = online;
-            devices.push_back(std::move(device));
-        }
-
-        if (http_body) {
-            nlohmann::json out;
-            out["devices"] = std::move(devices);
-            *http_body = out.dump();
-        }
-    } catch (const std::exception&) {
-        return BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED;
-    }
-
+        *http_code = 200;
+    if (http_body)
+        *http_body = "{}";
     return BAMBU_NETWORK_SUCCESS;
 }
 

src/slic3r/Utils/OrcaCloudServiceAgent.hpp

@@ -1,7 +1,6 @@
 #ifndef __ORCA_CLOUD_SERVICE_AGENT_HPP__
 #define __ORCA_CLOUD_SERVICE_AGENT_HPP__
 
-#include "ICameraSignalingChannel.hpp"
 #include "ICloudServiceAgent.hpp"
 #include <cstdlib>
 #include <string>
@@ -242,7 +241,6 @@ public:
     // ICloudServiceAgent Interface Implementation - Model Mall & Publishing
     // ========================================================================
     int get_camera_url(std::string dev_id, std::function<void(std::string)> callback) override;
-    // std::unique_ptr<ICameraSignalingChannel> create_camera_signaling_channel(const std::string& dev_id) override;
     int get_design_staffpick(int offset, int limit, std::function<void(std::string)> callback) override;
     int start_publish(PublishParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, std::string* out) override;
     int get_model_publish_url(std::string* url) override;