trcc-linux 9.2.2__tar.gz → 9.2.3__tar.gz

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.2.2
+Version: 9.2.3
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.2.2"
+version = "9.2.3"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/__version__.py

@@ -1,4 +1,4 @@
 """TRCC Linux version information. History in doc/CHANGELOG.md."""
 
-__version__ = "9.2.2"
+__version__ = "9.2.3"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/adapters/device/detector.py

@@ -19,13 +19,13 @@ from typing import Any, Callable, List, Optional
 
 from trcc.core.models import (
     ALL_DEVICES,
-    BULK_DEVICES,
-    HID_LCD_DEVICES,
-    LED_DEVICES,
-    LY_DEVICES,
-    SCSI_DEVICES,
+    BULK_DEVICES,  # noqa: F401 — re-exported for downstream importers
+    HID_LCD_DEVICES,  # noqa: F401
+    LED_DEVICES,  # noqa: F401
+    LY_DEVICES,  # noqa: F401
+    SCSI_DEVICES,  # noqa: F401
     DetectedDevice,
-    DeviceEntry,  # noqa: F401 — re-export for downstream importers
+    DeviceEntry,  # noqa: F401
 )
 
 log = logging.getLogger(__name__)
@@ -51,13 +51,7 @@ def enable_hid_testing() -> None:
 
 ScsiResolver = Callable[[int, int], Optional[str]]
 
-_REGISTRIES: list[tuple[dict[tuple[int, int], DeviceEntry], str]] = [
-    (SCSI_DEVICES, 'scsi'),
-    (HID_LCD_DEVICES, 'hid'),
-    (BULK_DEVICES, 'bulk'),
-    (LY_DEVICES, 'ly'),
-    (LED_DEVICES, 'hid'),
-]
+# Protocol comes from DeviceEntry.protocol — models.py is the single source of truth.
 
 
 class DeviceDetector:
@@ -96,31 +90,29 @@ class DeviceDetector:
             return []
 
         devices: List[DetectedDevice] = []
-        for registry, protocol in _REGISTRIES:
-            for (vid, pid), entry in registry.items():
-                usb_dev: Any = usb.core.find(idVendor=vid, idProduct=pid)
-                if usb_dev is None:
-                    continue
-
-                impl = 'hid_led' if registry is LED_DEVICES else entry.implementation
-                usb_path = f'usb:{usb_dev.bus}:{usb_dev.address}'
-                scsi_dev = (
-                    scsi_resolver(vid, pid)
-                    if scsi_resolver and protocol == 'scsi'
-                    else None
-                )
-
-                devices.append(DetectedDevice(
-                    vid=vid, pid=pid,
-                    vendor_name=entry.vendor, product_name=entry.product,
-                    usb_path=usb_path,
-                    scsi_device=scsi_dev,
-                    implementation=impl,
-                    model=entry.model,
-                    button_image=entry.button_image,
-                    protocol=protocol,
-                    device_type=entry.device_type,
-                ))
+        for (vid, pid), entry in ALL_DEVICES.items():
+            usb_dev: Any = usb.core.find(idVendor=vid, idProduct=pid)
+            if usb_dev is None:
+                continue
+
+            usb_path = f'usb:{usb_dev.bus}:{usb_dev.address}'
+            scsi_dev = (
+                scsi_resolver(vid, pid)
+                if scsi_resolver and entry.protocol == 'scsi'
+                else None
+            )
+
+            devices.append(DetectedDevice(
+                vid=vid, pid=pid,
+                vendor_name=entry.vendor, product_name=entry.product,
+                usb_path=usb_path,
+                scsi_device=scsi_dev,
+                implementation=entry.implementation,
+                model=entry.model,
+                button_image=entry.button_image,
+                protocol=entry.protocol,
+                device_type=entry.device_type,
+            ))
 
         log.info(
             "Detected %d device(s): %s", len(devices),

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/adapters/device/factory.py

@@ -25,7 +25,6 @@ from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple
 
 from trcc.core.models import (
     DEVICE_TYPE_NAMES,
-    LED_DEVICE_TYPE_NAME,
     PROTOCOL_NAMES,
     HandshakeResult,
 )
@@ -626,12 +625,12 @@ class DeviceProtocolFactory:
     # ControllerBuilder calls configure_scsi() to inject the platform-specific
     # implementation (e.g. WindowsScsiProtocol) at composition time.
     _PROTOCOL_REGISTRY: ClassVar[Dict[Tuple[str, str], Callable[..., DeviceProtocol]]] = {
-        ('scsi', ''):       lambda di: ScsiProtocol(di.path),
-        ('bulk', ''):       lambda di: BulkProtocol(vid=di.vid, pid=di.pid),
-        ('ly', ''):         lambda di: LyProtocol(vid=di.vid, pid=di.pid),
-        ('hid', 'hid_led'): lambda di: LedProtocol(vid=di.vid, pid=di.pid),
-        ('hid', ''):        lambda di: HidProtocol(vid=di.vid, pid=di.pid,
-                                device_type=getattr(di, 'device_type', 2)),
+        ('scsi', ''):  lambda di: ScsiProtocol(di.path),
+        ('bulk', ''):  lambda di: BulkProtocol(vid=di.vid, pid=di.pid),
+        ('ly', ''):    lambda di: LyProtocol(vid=di.vid, pid=di.pid),
+        ('led', ''):   lambda di: LedProtocol(vid=di.vid, pid=di.pid),
+        ('hid', ''):   lambda di: HidProtocol(vid=di.vid, pid=di.pid,
+                           device_type=getattr(di, 'device_type', 2)),
     }
 
     @classmethod
@@ -805,8 +804,6 @@ class DeviceProtocolFactory:
         protocol = getattr(device_info, 'protocol', 'scsi')
         device_type = getattr(device_info, 'device_type', 1)
 
-        implementation = getattr(device_info, 'implementation', '')
-
         from trcc.core.models import PROTOCOL_TRAITS
         traits = PROTOCOL_TRAITS.get(protocol)
         if traits is None:
@@ -818,18 +815,6 @@ class DeviceProtocolFactory:
         else:
             active = "none"
 
-        # LED devices report as "led" protocol
-        if implementation == "hid_led":
-            return ProtocolInfo(
-                protocol="led",
-                device_type=1,
-                protocol_display=PROTOCOL_NAMES.get("led", "LED"),
-                device_type_display=LED_DEVICE_TYPE_NAME,
-                active_backend=active,
-                backends=backends,
-                transport_open=False,
-            )
-
         return ProtocolInfo(
             protocol=protocol,
             device_type=device_type,

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/api/__init__.py

@@ -34,24 +34,11 @@ from trcc.adapters.device.factory import DeviceProtocolFactory
 from trcc.adapters.device.led import probe_led_model
 from trcc.adapters.infra.dc_config import DcConfig
 from trcc.adapters.infra.dc_parser import load_config_json
-from trcc.adapters.render.qt import QtRenderer
 from trcc.services import DeviceService, MediaService, OverlayService
-from trcc.services.system import set_instance
+from trcc.services.system import SystemService
 
 log = logging.getLogger(__name__)
 
-# ── Initialization via commands (composition root) ────────────────────
-# 1. InitPlatformCommand  — logging, OS, settings, renderer
-# 2. DiscoverDevicesCommand — triggered per endpoint that needs a device
-
-from trcc.core.app import TrccApp  # noqa: E402
-from trcc.core.commands.initialize import InitPlatformCommand  # noqa: E402
-
-_trcc_app = TrccApp.init()
-_trcc_app.os_bus.dispatch(InitPlatformCommand(
-    renderer_factory=QtRenderer,
-))
-
 # ── App ────────────────────────────────────────────────────────────────
 
 app = FastAPI(title="TRCC Linux", version=__version__)
@@ -65,9 +52,8 @@ _device_svc = DeviceService(
     get_protocol_info=DeviceProtocolFactory.get_protocol_info,
 )
 
-# System service (composition root — adapter wired here)
-_system_svc = _trcc_app.build_system()
-set_instance(_system_svc)
+# System service — None until configure_app() is called by trcc serve
+_system_svc: SystemService | None = None
 
 # Lazy-initialized devices (set when device is selected)
 _display_dispatcher = None  # LCDDevice | None
@@ -83,6 +69,23 @@ def set_current_image(img) -> None:
     _current_image = img
 
 
+def configure_app() -> None:
+    """Initialize platform, renderer, and system service.
+
+    Called once by CLI serve command before uvicorn starts. Not called at
+    import time so tests can import the module without triggering side effects.
+    """
+    global _system_svc  # noqa: PLW0603
+    from trcc.adapters.render.qt import QtRenderer
+    from trcc.core.app import TrccApp
+    from trcc.services.system import set_instance
+
+    trcc_app = TrccApp.init()
+    trcc_app.bootstrap(renderer_factory=QtRenderer)
+    _system_svc = trcc_app.build_system()
+    set_instance(_system_svc)
+
+
 # ── Video playback (background thread) ───────────────────────────────
 
 _media_service: MediaService | None = None
@@ -125,7 +128,7 @@ def start_video_playback(
             if frame is None:
                 break
             if should_send:
-                _device_svc.send_pil(frame, width, height)
+                _device_svc.send_frame(frame, width, height)
             stop_event.wait(interval)
 
     _video_thread = threading.Thread(target=_pump, daemon=True, name="api-video")
@@ -190,12 +193,15 @@ def start_overlay_loop(
 
     def _loop() -> None:
         while not stop_event.is_set():
+            if _system_svc is None:
+                stop_event.wait(2.0)
+                continue
             metrics = _system_svc.all_metrics
             if overlay.would_change(metrics):
                 overlay.update_metrics(metrics)
                 frame = overlay.render(metrics=metrics)
                 if frame is not None:
-                    _device_svc.send_pil(frame, width, height)
+                    _device_svc.send_frame(frame, width, height)
             stop_event.wait(2.0)
 
     _overlay_thread = threading.Thread(target=_loop, daemon=True, name="api-overlay")
@@ -242,7 +248,7 @@ def start_led_loop() -> None:
     def _loop() -> None:
         tick_count = 0
         while not stop_event.is_set():
-            if tick_count % 20 == 0:
+            if tick_count % 20 == 0 and _system_svc is not None:
                 try:
                     led.update_metrics(_system_svc.all_metrics)
                 except Exception:

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/api/devices.py

@@ -203,7 +203,7 @@ async def send_image(device_id: int, image: UploadFile, rotation: int = 0,
 
     # Encode and send via service (handles JPEG vs RGB565, rotation, byte order)
     # Frame capture is automatic via on_frame_sent callback
-    ok = _device_svc.send_pil(img, w, h)
+    ok = _device_svc.send_frame(img, w, h)
 
     if not ok:
         raise HTTPException(status_code=500, detail="Send failed (device busy or error)")

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/api/display.py

@@ -156,8 +156,8 @@ async def render_overlay(dc_path: str, send: bool = True) -> dict:
     import trcc.api as api
 
     lcd = _get_display()
-    result = lcd.render_overlay_from_dc(
-        safe_path, send=send, metrics=api._system_svc.all_metrics)
+    metrics = api._system_svc.all_metrics if api._system_svc is not None else None
+    result = lcd.render_overlay_from_dc(safe_path, send=send, metrics=metrics)
     return dispatch_result(result)
 
 
@@ -427,10 +427,10 @@ async def create_theme(
         api._overlay_svc = overlay_svc
         from trcc.services.system import get_all_metrics
         frame = overlay_svc.render(get_all_metrics())
-        lcd.frame.send_pil(frame)
+        lcd.frame.send_frame(frame)
         api.set_current_image(frame)
     else:
-        lcd.frame.send_pil(img)
+        lcd.frame.send_frame(img)
         api.set_current_image(img)
 
     return {"success": True, "animated": False, "resolution": f"{w}x{h}"}

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/api/system.py

@@ -12,8 +12,12 @@ router = APIRouter(prefix="/system", tags=["system"])
 
 
 def _get_system_svc():
-    """Get the shared SystemService instance (initialized in api/__init__.py)."""
+    """Get the shared SystemService instance (initialized by configure_app())."""
+    from fastapi import HTTPException
+
     import trcc.api as api
+    if api._system_svc is None:
+        raise HTTPException(status_code=503, detail="System service not initialized")
     return api._system_svc
 
 
@@ -30,10 +34,6 @@ def get_metrics_by_category(category: str) -> dict:
     """Filtered metrics by category (cpu, gpu, mem, disk, net, fan)."""
     from fastapi import HTTPException
 
-    svc = _get_system_svc()
-    m = svc.all_metrics
-    all_data = dataclasses.asdict(m)
-
     prefix_map = {
         "cpu": "cpu_",
         "gpu": "gpu_",
@@ -52,6 +52,9 @@ def get_metrics_by_category(category: str) -> dict:
             detail=f"Unknown category '{category}'. Use: {', '.join(sorted(prefix_map.keys()))}",
         )
 
+    svc = _get_system_svc()
+    m = svc.all_metrics
+    all_data = dataclasses.asdict(m)
     return {k: v for k, v in all_data.items() if k.startswith(prefix)}
 
 

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/cli/__init__.py

@@ -1011,7 +1011,7 @@ def _cmd_serve(
 
     import uvicorn
 
-    from trcc.api import app as api_app, configure_auth, set_pairing_code  # noqa: I001
+    from trcc.api import app as api_app, configure_app, configure_auth, set_pairing_code  # noqa: I001
     from trcc.conf import Settings
 
     # Token resolution: explicit --token > persistent config > auto-generate
@@ -1052,6 +1052,7 @@ def _cmd_serve(
         print("  After pairing, the phone stays connected across restarts.\n")
 
     _print_serve_qr(host, port, token, bool(ssl_kwargs))
+    configure_app()
     uvicorn.run(api_app, host=host, port=port, **ssl_kwargs)
     return 0
 

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/cli/_display.py

@@ -84,7 +84,7 @@ def test(device=None, loop=False, preview=False):
             for (r, g, b), name in colors:
                 print(f"  Displaying: {name}")
                 img = ImageService.solid_color(r, g, b, w, h)
-                svc.send_pil(img, w, h)
+                svc.send_frame(img, w, h)
                 if preview:
                     print(ImageService.to_ansi(img))
                 time.sleep(1)
@@ -165,7 +165,7 @@ def play_video(builder, video_path, *, device=None, loop=True, duration=0,
         def _on_frame(img):
             svc = lcd._device_svc
             if svc:
-                svc.send_pil(img, w, h)
+                svc.send_frame(img, w, h)
             if preview:
                 from trcc.services import ImageService
                 print(ImageService.to_ansi_cursor_home(img), flush=True)
@@ -252,10 +252,10 @@ def screencast(builder, *, device=None, x=0, y=0, w=0, h=0, fps=10, preview=Fals
             raw = proc.stdout.read(frame_size)
             if len(raw) < frame_size:
                 break
-            # Detach from raw buffer immediately — send_pil may hold a ref
+            # Detach from raw buffer immediately — send_frame may hold a ref
             qimg = QImage(raw, lcd_w, lcd_h, lcd_w * 3,
                           QImage.Format.Format_RGB888).copy()
-            svc.send_pil(qimg, lcd_w, lcd_h)
+            svc.send_frame(qimg, lcd_w, lcd_h)
             frames += 1
             if preview:
                 print(ImageService.to_ansi_cursor_home(qimg), flush=True)

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/cli/_theme.py

@@ -104,7 +104,7 @@ def load_theme(builder, name, *, device=None, preview=False):
 
         loop_result = lcd._display_svc._run_tick_loop(
             metrics_fn=metrics_fn,
-            on_frame=lambda img: svc.send_pil(img, w, h),
+            on_frame=lambda img: svc.send_frame(img, w, h),
             on_progress=lambda p, c, t: print(
                 f"\r  {c} / {t} ({p:.0f}%)", end="", flush=True),
         )

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/core/app.py

@@ -129,9 +129,13 @@ class TrccApp:
     # ── Device scanning ──────────────────────────────────────────────────────
 
     def scan(self) -> list[Device]:
-        """Detect hardware, build and connect LCDDevice/LEDDevice, store buses.
+        """Detect hardware, build and connect LCDDevice/LEDDevice in parallel.
 
-        init() → OS → scan() is the correct sequence:
+        Detection is sequential (single USB enumerate call), then one thread
+        per device for connect + _wire_bus (USB handshakes run concurrently).
+        _wire_bus fires EnsureDataCommand per resolution in a background thread.
+
+        Sequence: bootstrap() or init() → OS → scan()
           - LCD found → lcd_bus built and stored
           - LED found → led_bus built and stored
           - Notifies observers with DEVICES_CHANGED
@@ -140,20 +144,47 @@ class TrccApp:
         found: list[DetectedDevice] = detect_fn()
 
         self._devices = {}
-        for detected in found:
+        lock = threading.Lock()
+
+        def _connect_one(detected: DetectedDevice) -> None:
             device = self._builder.build_device(detected)
             try:
                 device.connect(detected)
             except Exception:
                 log.warning("scan: connect failed for %s — skipping", detected.path)
-                continue
-            self._devices[detected.path] = device
-            self._wire_bus(device)
+                return
+            with lock:
+                self._devices[detected.path] = device
+                self._wire_bus(device)
+
+        threads = [
+            threading.Thread(target=_connect_one, args=(d,), daemon=True)
+            for d in found
+        ]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join(timeout=30)
 
         log.debug("scan: %d device(s) found", len(self._devices))
         self._notify(AppEvent.DEVICES_CHANGED, list(self._devices.values()))
         return list(self._devices.values())
 
+    def bootstrap(self, renderer_factory: Any = None) -> list[Device]:
+        """Init platform + connect all devices in parallel.
+
+        Single call that every composition root (GUI, API, CLI serve) makes
+        before starting its UI. After this returns:
+          - Platform initialized (logging, OS, settings, renderer)
+          - All devices connected and their buses ready
+          - EnsureDataCommand running in background per resolution
+
+        Returns the list of connected devices (same as scan()).
+        """
+        from .commands.initialize import InitPlatformCommand
+        self.os_bus.dispatch(InitPlatformCommand(renderer_factory=renderer_factory))
+        return self.scan()
+
     def device_connected(self, detected: DetectedDevice) -> None:
         """Build, connect, and register a newly discovered device, notify observers."""
         device = self._builder.build_device(detected)

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/core/lcd_device.py

@@ -412,14 +412,14 @@ class LCDDevice(Device):
         from ..services import ImageService
         w, h = self.lcd_size
         img = ImageService.open_and_resize(image_path, w, h)
-        self._device_svc.send_pil(img, w, h)
+        self._device_svc.send_frame(img, w, h)
         return {"success": True, "image": img, "message": f"Sent {image_path}"}
 
     def send_color(self, r: int, g: int, b: int) -> dict:
         from ..services import ImageService
         w, h = self.lcd_size
         img = ImageService.solid_color(r, g, b, w, h)
-        self._device_svc.send_pil(img, w, h)
+        self._device_svc.send_frame(img, w, h)
         return {"success": True, "image": img,
                 "message": f"Sent color #{r:02x}{g:02x}{b:02x}"}
 
@@ -428,13 +428,13 @@ class LCDDevice(Device):
         if not self._device_svc.selected:
             return {"success": False, "error": "No device selected"}
         w, h = self.lcd_size
-        self._device_svc.send_pil_async(image, w, h)
+        self._device_svc.send_frame_async(image, w, h)
         return {"success": True}
 
     def send_async(self, image: Any, width: int, height: int) -> None:
         if self._device_svc.is_busy:
             return
-        self._device_svc.send_pil_async(image, width, height)
+        self._device_svc.send_frame_async(image, width, height)
 
     def load_image(self, path: Any) -> dict:
         image = self._display_svc.load_image_file(Path(path))
@@ -447,7 +447,7 @@ class LCDDevice(Device):
         from ..services import ImageService
         w, h = self.lcd_size
         img = ImageService.solid_color(255, 0, 0, w, h)
-        self._device_svc.send_pil(img, w, h)
+        self._device_svc.send_frame(img, w, h)
         return {"success": True, "image": img, "message": "Device reset — RED"}
 
     # ── Display settings (brightness/rotation/split) ─────────────

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/core/models.py

@@ -350,7 +350,7 @@ LED_DEVICES: dict[tuple[int, int], DeviceEntry] = {
     (0x0416, 0x8001): DeviceEntry(
         vendor="Winbond", product="LED Controller",
         model="LED_DIGITAL", implementation="hid_led",
-        protocol="hid", device_type=1,
+        protocol="led", device_type=1,
     ),
 }
 

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/gui/__init__.py

@@ -22,18 +22,11 @@ def launch(verbosity: int = 0, decorated: bool = False,
 
     Returns the Qt exit code.
     """
-    from trcc.core.app import TrccApp
-
-    # ── Bootstrap via commands ────────────────────────────────────────────
-    # 1. InitPlatformCommand  — logging, OS, settings, renderer
-    # 2. DiscoverDevicesCommand — dispatched after Qt + IPC are ready (below)
-    from trcc.core.commands.initialize import InitPlatformCommand
-    app = TrccApp.init()
+    # ── Bootstrap — platform init + parallel device scan ─────────────────
     from trcc.adapters.render.qt import QtRenderer
-    app.os_bus.dispatch(InitPlatformCommand(
-        verbosity=verbosity,
-        renderer_factory=QtRenderer,
-    ))
+    from trcc.core.app import AppEvent, TrccApp
+    app = TrccApp.init()
+    app.bootstrap(renderer_factory=QtRenderer)
 
     # ── Platform deps ─────────────────────────────────────────────────────
     setup    = app.build_setup()
@@ -97,11 +90,11 @@ def launch(verbosity: int = 0, decorated: bool = False,
     ipc_server.start()
     window._ipc_server = ipc_server
 
-    # ── Register window as observer, discover devices, start metrics ─────
-    # DiscoverDevicesCommand dispatches DEVICES_CHANGED → window.on_app_event → handlers created
-    from trcc.core.commands.initialize import DiscoverDevicesCommand
+    # ── Register window as observer, replay scan results, start metrics ──
+    # bootstrap() already ran scan(); registering now replays DEVICES_CHANGED
+    # so window.on_app_event creates handlers for all pre-discovered devices.
     app.register(window)  # type: ignore[arg-type]
-    app.os_bus.dispatch(DiscoverDevicesCommand())
+    app._notify(AppEvent.DEVICES_CHANGED, list(app._devices.values()))
     app.start_metrics_loop()
 
     # ── IPC raise + signals ───────────────────────────────────────────────

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/qt_components/lcd_handler.py

@@ -21,7 +21,12 @@ import trcc.conf as _conf
 from trcc.conf import Settings
 
 from ..core.command_bus import CommandBus
-from ..core.commands.lcd import SetBrightnessCommand, SetRotationCommand, SetSplitModeCommand
+from ..core.commands.lcd import (
+    SetBrightnessCommand,
+    SetResolutionCommand,
+    SetRotationCommand,
+    SetSplitModeCommand,
+)
 from ..core.lcd_device import LCDDevice
 from ..core.models import (
     DEFAULT_BRIGHTNESS_LEVEL,
@@ -121,10 +126,10 @@ class LCDHandler(BaseHandler):
         self._device_key = Settings.device_config_key(
             device.device_index, device.vid, device.pid)
 
-        # Resolution change — update Settings + DisplayService (triggers data download)
+        # Resolution change — dispatch via bus so EnsureDataCommand fires automatically
         cur_w, cur_h = self._lcd.lcd_size
         if (w, h) != (cur_w, cur_h):
-            self._lcd.set_resolution(w, h)
+            self._bus.dispatch(SetResolutionCommand(width=w, height=h))
             self._w['preview'].set_resolution(w, h)
             self._w['image_cut'].set_resolution(w, h)
             self._w['video_cut'].set_resolution(w, h)

{trcc_linux-9.2.2 → trcc_linux-9.2.3}/src/trcc/services/device.py

@@ -209,7 +209,7 @@ class DeviceService:
             with self._send_lock:
                 self._send_busy = False
 
-    def send_pil(self, image: Any, width: int, height: int) -> bool:
+    def send_frame(self, image: Any, width: int, height: int) -> bool:
         """Encode image for device and send.
 
         Delegates encoding strategy to ImageService.encode_for_device() —
@@ -247,7 +247,7 @@ class DeviceService:
         self._send_queue.append((data, width, height))
         self._send_event.set()
 
-    def send_pil_async(self, image: Any, width: int, height: int) -> None:
+    def send_frame_async(self, image: Any, width: int, height: int) -> None:
         """Encode image and queue for the persistent send worker.
 
         Encoding runs inline (~0.5ms), then routes through the same