trcc-linux 9.3.6__tar.gz → 9.3.7__tar.gz

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.3.6
+Version: 9.3.7
 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.3.6 → trcc_linux-9.3.7}/pyproject.toml

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

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/__version__.py

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

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/adapters/device/factory.py

@@ -519,8 +519,10 @@ class _BulkLikeProtocol(DeviceProtocol):
 
     def _ensure_device(self) -> None:
         if self._device is None:
+            log.debug("%s: creating device %04X:%04X", self._label, self._vid, self._pid)
             self._device = self._make_device(self._vid, self._pid)
             assert self._device is not None
+            log.debug("%s: starting handshake", self._label)
             result = self._device.handshake()
             self._handshake_result = result
             if result.resolution:
@@ -528,7 +530,8 @@ class _BulkLikeProtocol(DeviceProtocol):
                 log.info("%s handshake OK: PM=%d, resolution=%s",
                          self._label, result.model_id, result.resolution)
             else:
-                log.warning("%s handshake: no resolution detected", self._label)
+                log.warning("%s handshake: no resolution detected (result=%s)",
+                            self._label, result)
 
     def _do_handshake(self) -> Optional[HandshakeResult]:
         self._ensure_device()
@@ -678,6 +681,7 @@ class DeviceProtocolFactory:
         """
         protocol = getattr(device_info, 'protocol', 'scsi')
         implementation = getattr(device_info, 'implementation', '')
+        log.debug("create_protocol: protocol=%s impl=%s", protocol, implementation)
 
         factory_fn = cls._PROTOCOL_REGISTRY.get(
             (protocol, implementation),
@@ -687,9 +691,8 @@ class DeviceProtocolFactory:
             raise ValueError(f"Unknown protocol: {protocol!r}")
 
         result = factory_fn(device_info)
-        log.info("Created %s for %s", type(result).__name__,
-                 getattr(device_info, 'path',
-                         f'{device_info.vid:04X}:{device_info.pid:04X}'))
+        path = getattr(device_info, 'path', f'{device_info.vid:04X}:{device_info.pid:04X}')
+        log.info("create_protocol: %s for %s", type(result).__name__, path)
         return result
 
     @classmethod
@@ -704,7 +707,10 @@ class DeviceProtocolFactory:
         """
         key = cls._device_key(device_info)
         if key not in cls._protocols:
+            log.debug("get_protocol: cache miss for %s — creating", key)
             cls._protocols[key] = cls.create_protocol(device_info)
+        else:
+            log.debug("get_protocol: cache hit for %s", key)
         return cls._protocols[key]
 
     @classmethod

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/adapters/device/led.py

@@ -308,6 +308,7 @@ class LedHidSender(LedDevice):
             True if all chunks were sent successfully.
         """
         if self._sending:
+            log.debug("send_led_data: already sending — skipped")
             return False
 
         self._sending = True
@@ -329,7 +330,8 @@ class LedHidSender(LedDevice):
 
             return True
 
-        except Exception:
+        except Exception as e:
+            log.warning("send_led_data: failed: %s", e)
             return False
         finally:
             self._sending = False

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/adapters/infra/data_repository.py

@@ -19,7 +19,7 @@ import logging
 import os
 import shutil
 import subprocess
-from typing import List, Optional
+from typing import Any, List, Optional
 
 from ...core.models import ThemeDir  # noqa: F401 — re-export for back-compat
 from ...core.paths import (
@@ -160,6 +160,7 @@ class DataManager:
     @staticmethod
     def extract_7z(archive: str, target_dir: str) -> bool:
         """Extract a .7z archive into target_dir using 7z CLI. Returns True on success."""
+        log.debug("extract_7z: %s → %s", archive, target_dir)
         os.makedirs(target_dir, exist_ok=True)
         try:
             # Validate archive members before extraction (zip-slip prevention)
@@ -168,17 +169,20 @@ class DataManager:
                 capture_output=True, text=True, timeout=30,
                 creationflags=_NO_WINDOW,
             )
-            if listing.returncode == 0:
-                archive_norm = os.path.normpath(archive)
-                for line in listing.stdout.splitlines():
-                    if line.startswith('Path = '):
-                        member = line[7:]
-                        # Skip the archive path itself (7z lists it first)
-                        if os.path.normpath(member) == archive_norm:
-                            continue
-                        if not DataManager.is_safe_archive_member(member):
-                            log.warning("Blocked unsafe archive member: %s", member)
-                            return False
+            if listing.returncode != 0:
+                log.warning("extract_7z: listing failed (rc=%d): %s",
+                            listing.returncode, listing.stderr.strip())
+                return False
+            archive_norm = os.path.normpath(archive)
+            for line in listing.stdout.splitlines():
+                if line.startswith('Path = '):
+                    member = line[7:]
+                    # Skip the archive path itself (7z lists it first)
+                    if os.path.normpath(member) == archive_norm:
+                        continue
+                    if not DataManager.is_safe_archive_member(member):
+                        log.warning("Blocked unsafe archive member: %s", member)
+                        return False
 
             result = subprocess.run(
                 ['7z', 'x', archive, f'-o{target_dir}', '-y'],
@@ -186,16 +190,17 @@ class DataManager:
                 creationflags=_NO_WINDOW,
             )
             if result.returncode == 0:
-                log.info("Extracted %s", os.path.basename(archive))
+                log.info("extract_7z: OK %s", os.path.basename(archive))
                 return True
-            log.warning("7z failed (rc=%d): %s", result.returncode, result.stderr.decode())
+            log.warning("extract_7z: failed (rc=%d): %s",
+                        result.returncode, result.stderr.decode(errors='replace'))
         except FileNotFoundError:
             log.warning(
-                "7z not found — cannot extract %s\n%s",
+                "extract_7z: 7z not found — cannot extract %s\n%s",
                 archive, DataManager._7z_install_help(),
             )
         except Exception as e:
-            log.warning("7z extraction failed: %s", e)
+            log.warning("extract_7z: failed: %s", e)
         return False
 
     # ------------------------------------------------------------------
@@ -337,11 +342,16 @@ class DataManager:
         for base in (_PKG_DATA_DIR, DataManager._data_dir()):
             path = os.path.join(base, subdir, archive_name) if subdir else os.path.join(base, archive_name)
             if os.path.isfile(path):
+                log.debug("_fetch_archive: found local %s", path)
                 return path
+            log.debug("_fetch_archive: not at %s", path)
         user = os.path.join(DataManager._data_dir(), subdir, archive_name) if subdir else os.path.join(DataManager._data_dir(), archive_name)
         url_path = f'{subdir}/{archive_name}' if subdir else archive_name
-        if DataManager.download_archive(DataManager.GITHUB_BASE_URL + url_path, user):
+        url = DataManager.GITHUB_BASE_URL + url_path
+        log.info("_fetch_archive: downloading %s", url)
+        if DataManager.download_archive(url, user):
             return user
+        log.warning("_fetch_archive: all sources exhausted for %s", archive_name)
         return None
 
     # ------------------------------------------------------------------
@@ -419,18 +429,23 @@ class DataManager:
             else:
                 log.info(msg)
 
-        # All ensure_* are idempotent — each checks for existing content before extracting
-        _report(f"Downloading themes for {width}x{height}...")
-        DataManager.ensure_themes(width, height)
-        _report(f"Downloading web previews for {width}x{height}...")
-        DataManager.ensure_web(width, height)
-        _report(f"Downloading mask themes for {width}x{height}...")
-        DataManager.ensure_web_masks(width, height)
+        def _run(label: str, fn: callable, *args: Any) -> None:  # type: ignore[type-arg]
+            _report(f"Downloading {label}...")
+            try:
+                ok = fn(*args)
+                if not ok:
+                    log.warning("ensure_all: %s returned False", label)
+            except Exception:
+                log.exception("ensure_all: %s failed", label)
+
+        log.info("ensure_all: starting %dx%d", width, height)
+        _run(f"themes {width}x{height}", DataManager.ensure_themes, width, height)
+        _run(f"web {width}x{height}", DataManager.ensure_web, width, height)
+        _run(f"masks {width}x{height}", DataManager.ensure_web_masks, width, height)
         if width != height:
-            _report(f"Downloading web previews for {height}x{width}...")
-            DataManager.ensure_web(height, width)
-            _report(f"Downloading mask themes for {height}x{width}...")
-            DataManager.ensure_web_masks(height, width)
+            log.debug("ensure_all: non-square — also ensuring portrait %dx%d", height, width)
+            _run(f"web {height}x{width}", DataManager.ensure_web, height, width)
+            _run(f"masks {height}x{width}", DataManager.ensure_web_masks, height, width)
         DataManager.mark_resolution_installed(width, height)
         _report(f"Data ready for {width}x{height}.")
 

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/conf.py

@@ -366,6 +366,7 @@ class Settings:
     @staticmethod
     def save_device_setting(key: str, setting: str, value):
         """Save a single setting for a device."""
+        log.debug("save_device_setting: %s.%s = %r", key, setting, value)
         config = load_config()
         devices = config.setdefault('devices', {})
         dev_cfg = devices.setdefault(key, {})

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/core/app.py

@@ -137,6 +137,8 @@ class TrccApp:
         """
         detect_fn = self._builder.build_detect_fn()
         found: list[DetectedDevice] = detect_fn()
+        log.info("scan: detected %d device(s): %s", len(found),
+                 ", ".join(f"{d.path} ({d.protocol})" for d in found) or "(none)")
 
         self._devices = {}
         lock = threading.Lock()
@@ -148,6 +150,9 @@ class TrccApp:
             except Exception:
                 log.warning("scan: connect failed for %s — skipping", detected.path)
                 return
+            info = device.device_info
+            res = getattr(info, 'resolution', (0, 0)) if info else (0, 0)
+            log.info("scan: connected %s %dx%d", detected.path, *res)
             with lock:
                 self._devices[detected.path] = device
                 self._wire_device(device)
@@ -161,7 +166,7 @@ class TrccApp:
         for t in threads:
             t.join(timeout=30)
 
-        log.debug("scan: %d device(s) found", len(self._devices))
+        log.info("scan: %d of %d device(s) connected", len(self._devices), len(found))
         self._notify(AppEvent.DEVICES_CHANGED, list(self._devices.values()))
         return list(self._devices.values())
 
@@ -175,9 +180,13 @@ class TrccApp:
         before starting its UI.  Blocks until data is ready so the UI always
         starts with themes present — no empty-list-then-populate flash.
         """
+        log.info("bootstrap: init_platform")
         self.init_platform(renderer_factory=renderer_factory)
+        log.info("bootstrap: scanning devices")
         devices = self.scan()
+        log.info("bootstrap: ensuring data for %d device(s)", len(devices))
         self._ensure_data_blocking()
+        log.info("bootstrap: complete")
         return devices
 
     def init_platform(
@@ -216,45 +225,72 @@ class TrccApp:
         """
         ensure_fn = self._ensure_data_fn
         if ensure_fn is None:
+            log.warning("_ensure_data_blocking: no ensure_fn injected — skipping")
             return
+        log.info("_ensure_data_blocking: processing %d device(s)", len(self._devices))
         seen: set[tuple[int, int]] = set()
         for device in self._devices.values():
+            path = getattr(device.device_info, 'path', '?') if device.device_info else '?'
             if not device.is_lcd:
+                log.debug("_ensure_data_blocking: skip non-LCD %s", path)
                 continue
             info = device.device_info
             w, h = getattr(info, 'resolution', (0, 0))
-            if w and h and (w, h) not in seen:
-                seen.add((w, h))
-                ensure_fn(w, h, progress_fn=lambda msg: self._notify(AppEvent.BOOTSTRAP_PROGRESS, msg))
-                device.notify_data_ready()
+            if not (w and h):
+                log.warning("_ensure_data_blocking: skip %s — resolution (0,0)", path)
+                continue
+            if (w, h) in seen:
+                log.debug("_ensure_data_blocking: skip %s — duplicate %dx%d", path, w, h)
+                continue
+            seen.add((w, h))
+            log.info("_ensure_data_blocking: ensuring data %dx%d for %s", w, h, path)
+            ensure_fn(w, h, progress_fn=lambda msg: self._notify(AppEvent.BOOTSTRAP_PROGRESS, msg))
+            device.notify_data_ready()
+        log.info("_ensure_data_blocking: done — %d resolution(s) processed", len(seen))
 
     def _ensure_data_background(self, device: Device, w: int, h: int) -> None:
         """Ensure theme data in a background thread (hotplug path)."""
         ensure_fn = self._ensure_data_fn
+        path = getattr(device.device_info, 'path', '?') if device.device_info else '?'
+        log.info("_ensure_data_background: starting %dx%d for %s", w, h, path)
 
         def _bg() -> None:
-            if ensure_fn is not None:
-                ensure_fn(w, h)
-            device.notify_data_ready()
+            try:
+                if ensure_fn is not None:
+                    ensure_fn(w, h)
+                else:
+                    log.warning("_ensure_data_background: no ensure_fn for %s", path)
+                device.notify_data_ready()
+                log.info("_ensure_data_background: done %dx%d for %s", w, h, path)
+            except Exception:
+                log.exception("_ensure_data_background: failed %dx%d for %s", w, h, path)
 
         threading.Thread(target=_bg, daemon=True, name="data-extract").start()
 
     def device_connected(self, detected: DetectedDevice) -> None:
         """Build, connect, and register a newly discovered device, notify observers."""
+        log.info("device_connected: hotplug %s (%s)", detected.path, detected.protocol)
         device = self._builder.build_device(detected)
         try:
             device.connect(detected)
         except Exception:
             log.warning("device_connected: connect failed for %s", detected.path)
             return
+        info = device.device_info
+        res = getattr(info, 'resolution', (0, 0)) if info else (0, 0)
+        log.info("device_connected: connected %s %dx%d", detected.path, *res)
         self._devices[detected.path] = device
         self._wire_device(device)
         # Hotplug: ensure data in background (UI already running, can't block).
         if device.is_lcd:
-            info = device.device_info
-            w, h = getattr(info, 'resolution', (0, 0))
+            w, h = res
             if w and h:
+                log.info("device_connected: triggering data download %dx%d", w, h)
                 self._ensure_data_background(device, w, h)
+            else:
+                log.warning("device_connected: LCD %s has no resolution — skipping data download", detected.path)
+        else:
+            log.debug("device_connected: non-LCD %s — no data download needed", detected.path)
         self._notify(AppEvent.DEVICE_CONNECTED, device)
 
     def device_lost(self, path: str) -> None:
@@ -280,7 +316,10 @@ class TrccApp:
         if isinstance(device, LCDDevice):
             self._lcd_device = device
             log.debug("LCD device ready: %s", getattr(device, 'device_path', '?'))
-            device.initialize_pipeline(self._settings)
+            if self._settings is not None:
+                device.initialize_pipeline(self._settings)
+            else:
+                log.warning("_wire_device: settings not initialized — skipping pipeline init")
         elif isinstance(device, LEDDevice):
             self._led_device = device
             log.debug("LED device ready: %s", getattr(device, 'device_path', '?'))

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/core/lcd_device.py

@@ -91,9 +91,12 @@ class LCDDevice(Device):
         res = getattr(info, 'resolution', (0, 0))
         if res and res != (0, 0):
             w, h = res
+            self.log.info("initialize_pipeline: %dx%d", w, h)
             settings.set_resolution(w, h)
             self.set_resolution(w, h)
             self.initialize(settings.user_data_dir)
+        else:
+            self.log.warning("initialize_pipeline: skipped — resolution is %s", res)
 
     def set_data_ready_callback(self, fn: Any) -> None:
         """Register a callback invoked when background data extraction completes."""
@@ -177,6 +180,7 @@ class LCDDevice(Device):
         """
         proxy_result = self._try_proxy_route(detected)
         if proxy_result is not None:
+            self.log.info("connect: routing through active proxy instance")
             self._set_proxy(self._proxy)
             proxy_result["resolution"] = getattr(self._proxy, 'resolution', (0, 0))
             proxy_result["device_path"] = getattr(self._proxy, 'device_path', '')
@@ -775,6 +779,7 @@ class LCDDevice(Device):
             old_path = cfg.get("theme_path")
             if not old_path:
                 return {"success": False, "error": "No saved theme"}
+            self.log.info("restore_last_theme: migrating old config theme_path=%s", old_path)
             video_exts = {'.mp4', '.avi', '.mkv', '.webm'}
             image_exts = {'.png', '.jpg', '.jpeg', '.bmp', '.gif'}
             suffix = Path(old_path).suffix.lower()
@@ -787,6 +792,7 @@ class LCDDevice(Device):
             else:
                 theme_name = Path(old_path).name
                 theme_type = "local"
+            self.log.info("restore_last_theme: migrated → name=%s type=%s", theme_name, theme_type)
 
         # Resolve path from name + device resolution
         w, h = self.lcd_size
@@ -1319,16 +1325,18 @@ class LCDDevice(Device):
                 result = self._load_config_json_fn(str(json_path))
                 if result is not None:
                     overlay_config = result[0]
-            except Exception:
-                pass
+                    self.log.debug("load_overlay_config_from_dir: loaded from config.json")
+            except Exception as e:
+                self.log.warning("load_overlay_config_from_dir: config.json parse failed: %s", e)
 
         if overlay_config is None and self._dc_config_cls is not None:
             dc_path = p / 'config1.dc'
             if dc_path.exists():
                 try:
                     overlay_config = self._dc_config_cls(dc_path).to_overlay_config()
-                except Exception:
-                    pass
+                    self.log.debug("load_overlay_config_from_dir: loaded from config1.dc")
+                except Exception as e:
+                    self.log.warning("load_overlay_config_from_dir: config1.dc parse failed: %s", e)
 
         return overlay_config or None
 

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/core/led_device.py

@@ -23,6 +23,7 @@ def _forward_to_proxy(method):
     @functools.wraps(method)
     def wrapper(self, *args, **kwargs):
         if self._proxy is not None:
+            log.debug("proxy forward: %s → %s", method.__name__, type(self._proxy).__name__)
             return getattr(self._proxy, method.__name__)(*args, **kwargs)
         return method(self, *args, **kwargs)
     return wrapper
@@ -78,10 +79,12 @@ class LEDDevice(Device):
         Returns: {"success": bool, "status": str}
         """
         if self._svc:
+            log.debug("LED connect: already connected (status=%s)", self._init_status)
             return {"success": True, "status": self._init_status or ""}
 
         proxy_result = self._try_proxy_route(detected)
         if proxy_result is not None:
+            log.info("LED connect: routing through proxy instance")
             proxy_result["status"] = f"Connected (via {proxy_result['proxy'].value})"
             return proxy_result
 
@@ -95,6 +98,8 @@ class LEDDevice(Device):
             (d for d in self._device_svc.devices
              if d.implementation == 'hid_led'), None)
         if not led_dev:
+            log.warning("LED connect: no LED device found in %d detected devices",
+                        len(self._device_svc.devices))
             return {"success": False, "error": "No LED device found"}
 
         self._device = led_dev
@@ -469,17 +474,23 @@ class LEDDevice(Device):
     def tick(self) -> None:
         """Advance one LED animation frame and send to hardware."""
         if not self._svc:
+            log.debug("tick: no service — skipping")
             return
         colors = self._svc.tick()
         if self._svc.has_protocol:
-            self._svc.send_colors(colors)
+            ok = self._svc.send_colors(colors)
+            if not ok:
+                log.warning("tick: send_colors failed")
 
     def tick_with_result(self) -> dict:
         """Advance one animation frame. Returns colors + display_colors (GUI use)."""
         if not self._svc:
+            log.debug("tick_with_result: no service — skipping")
             return {"colors": [], "display_colors": []}
         colors = self._svc.tick()
         display_colors = self._svc.apply_mask(colors)
         if self._svc.has_protocol:
-            self._svc.send_colors(colors)
+            ok = self._svc.send_colors(colors)
+            if not ok:
+                log.warning("tick_with_result: send_colors failed")
         return {"colors": colors, "display_colors": display_colors}

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/gui/lcd_handler.py

@@ -111,6 +111,8 @@ class LCDHandler(BaseHandler):
 
     def apply_device_config(self, device: DeviceInfo, w: int, h: int) -> None:
         """First-time device setup + full widget refresh."""
+        self.log.info("apply_device_config: device_index=%d %04x:%04x %dx%d",
+                      device.device_index, device.vid, device.pid, w, h)
         self._device_key = Settings.device_config_key(
             device.device_index, device.vid, device.pid)
         # Per-device child logger — tags handler logs with device index
@@ -155,8 +157,10 @@ class LCDHandler(BaseHandler):
 
     def _on_data_ready(self) -> None:
         """Background data extraction finished — re-probe dirs and update UI."""
+        self.log.info("_on_data_ready: refreshing dirs and theme lists")
         self._lcd.refresh_dirs()
-        self._update_theme_directories()
+        auto_loaded = self._update_theme_directories()
+        self.log.info("_on_data_ready: done, auto_loaded=%s", auto_loaded)
 
     def _restore_brightness(self, cfg: dict) -> None:
         self._brightness_level = cfg.get('brightness_level', DEFAULT_BRIGHTNESS_LEVEL)
@@ -210,6 +214,9 @@ class LCDHandler(BaseHandler):
         """Restore last theme + overlay, or clear preview if none."""
         self.log.debug("_restore_theme_and_preview: cfg keys=%s", list(cfg.keys()))
         result = self._lcd.restore_last_theme()
+        if not result.get("success"):
+            self.log.info("_restore_theme_and_preview: no saved theme — %s",
+                          result.get("error", "unknown"))
         if result.get("success"):
             image = result.get("image")
             is_animated = result.get("is_animated", False)
@@ -302,6 +309,8 @@ class LCDHandler(BaseHandler):
             Settings.save_device_setting(self._device_key, 'theme_name', path.name)
             Settings.save_device_setting(self._device_key, 'theme_type', 'local')
             Settings.save_device_setting(self._device_key, 'mask_id', '')
+        elif persist and not self._device_key:
+            self.log.warning("_select_theme_from_path: not persisting — device_key is empty")
 
     def select_cloud_theme(self, theme_info: Any) -> None:
         """Handle cloud theme selection (video backgrounds)."""
@@ -695,6 +704,7 @@ class LCDHandler(BaseHandler):
                         self.log.info("Data ready: auto-loading first theme: %s", item)
                         self._select_theme_from_path(item, persist=True, overlay_config=True)
                         return True
+                self.log.debug("_update_theme_directories: no valid theme found for auto-load in %s", td.path)
         return False
 
     @property

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/gui/led_handler.py

@@ -98,6 +98,8 @@ class LEDHandler(BaseHandler):
         self._style_id = led_style
 
         style_info = LED_STYLES.get(led_style)
+        if not style_info:
+            log.warning("LED show: unknown style %d — panel init skipped", led_style)
         if style_info:
             self._panel.initialize(
                 led_style, style_info.segment_count, style_info.zone_count,

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/gui/trcc_app.py

@@ -405,13 +405,18 @@ class TRCCApp(QMainWindow):
              if h.device_info and h.device_info.device_index == last_idx),
             None,
         )
-        if not target:
+        if target:
+            log.debug("_rebuild_all_handlers: restored last device index=%d path=%s", last_idx, target)
+        else:
             target = next(
                 (p for p, h in self._handlers.items() if isinstance(h, LCDHandler)),
                 next(iter(self._handlers), None),
             )
+            log.debug("_rebuild_all_handlers: fallback to first LCD/device: %s", target)
         if target:
             self._activate_device(target)
+        else:
+            log.warning("_rebuild_all_handlers: no device to activate")
 
     def _add_handler(self, device: Any) -> None:
         """Create handler for one new device."""
@@ -421,6 +426,7 @@ class TRCCApp(QMainWindow):
             return
         path = info.path
 
+        added = False
         match device:
             case LEDDevice() if path not in self._handlers:
                 handler: BaseHandler = LEDHandler(
@@ -428,6 +434,7 @@ class TRCCApp(QMainWindow):
                     make_timer=self._make_timer)
                 self._handlers[path] = handler
                 log.info("LED handler added: %s", path)
+                added = True
             case LCDDevice() if path not in self._handlers:
                 widgets = {
                     'preview': self.uc_preview,
@@ -444,9 +451,13 @@ class TRCCApp(QMainWindow):
                     is_visible_fn=self.is_app_visible)
                 self._handlers[path] = lcd_handler
                 log.info("LCD handler added: %s", path)
+                added = True
                 # Wire IPC frame capture if server is already running
                 if self._ipc_server and lcd_handler.display.device_service:
                     lcd_handler.display.device_service.on_frame_sent = self._ipc_server.capture_frame
+        if not added and path not in self._handlers:
+            log.warning("_add_handler: unhandled device type %s path=%s — skipped",
+                        type(device).__name__, path)
 
         # Resolve button image from handshake PM+SUB before sidebar builds.
         # HID devices: pm_byte != fbl_code (e.g. PM=63 → FBL=114).
@@ -496,6 +507,7 @@ class TRCCApp(QMainWindow):
         """Switch panel stack to show the given device."""
         if path == self._active_path:
             return
+        log.info("_activate_device: %s", path)
         # Stop previous device's timers before switching — prevents
         # stale video frames writing to the shared preview widget.
         if self._active_path:
@@ -505,6 +517,8 @@ class TRCCApp(QMainWindow):
         self._active_path = path
         handler = self._handlers.get(path)
         if handler is None:
+            log.warning("_activate_device: no handler for path=%s (known: %s)",
+                        path, list(self._handlers.keys()))
             return
 
         # Persist last active device so we restore it on next launch
@@ -517,15 +531,19 @@ class TRCCApp(QMainWindow):
                 if info:
                     w, h = info.resolution
                     if (w, h) == (0, 0):
+                        log.debug("_activate_device: LCD %s resolution (0,0) — starting handshake", path)
                         self._start_handshake(info)
                     elif not handler.device_key:
+                        log.debug("_activate_device: LCD %s first-time config %dx%d", path, w, h)
                         handler.apply_device_config(info, w, h)
                         self._update_ldd_icon()
                     else:
+                        log.debug("_activate_device: LCD %s reactivate %dx%d", path, w, h)
                         handler.reactivate(w, h)
         elif isinstance(handler, LEDHandler):
             info = handler.device_info
             if info and not handler.active:
+                log.debug("_activate_device: LED %s — showing", path)
                 handler.show(info)
 
         self._show_view(handler.view_name)

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/services/display.py

@@ -216,6 +216,7 @@ class DisplayService:
     def set_resolution(self, width: int, height: int) -> None:
         """Set LCD resolution and update sub-services."""
         if width == self._width and height == self._height:
+            self.log.debug("set_resolution: no change (%dx%d)", width, height)
             return
         self.log.info("Resolution changed: %dx%d -> %dx%d",
                  self._width, self._height, width, height)

{trcc_linux-9.3.6 → trcc_linux-9.3.7}/src/trcc/services/led.py

@@ -392,6 +392,8 @@ class LEDService:
     def send_colors(self, colors: List[Tuple[int, int, int]]) -> bool:
         """Send pre-computed colors to device. Returns success."""
         if not colors or not self._protocol:
+            log.debug("send_colors: skipped (colors=%d, protocol=%s)",
+                       len(colors) if colors else 0, self._protocol is not None)
             return False
 
         send_colors = self.apply_mask(colors)
@@ -402,7 +404,7 @@ class LEDService:
                 send_colors, is_on, self.state.global_on, self.state.brightness
             )
         except Exception as e:
-            log.debug("LED send error: %s", e)
+            log.warning("send_colors: failed: %s", e)
             return False
 
     def send_tick(self) -> bool: