Merge remote-tracking branch 'upstream/main'

Author: github-actions[bot]

main-ui/devices/trimui/trim_ui_brick.py

@@ -24,8 +24,8 @@ def __init__(self, device_name, main_ui_mode):
         self.audio_player = AudioPlayerDelegateSdl2()
         script_dir = Path(__file__).resolve().parent
         source = script_dir / 'brick-system.json'
-        ConfigCopier.ensure_config("/mnt/SDCARD/Saves/brick-system.json", source)
-        self.system_config = SystemConfig("/mnt/SDCARD/Saves/brick-system.json")
+        ConfigCopier.ensure_config("/mnt/SDCARD/Saves/trim-ui-brick-system.json", source)
+        self.system_config = SystemConfig("/mnt/SDCARD/Saves/trim-ui-brick-system.json")
 
         if(main_ui_mode):
             trim_stock_json_file = script_dir / 'stock/brick.json'

main-ui/devices/trimui/trim_ui_smart_pro.py

@@ -24,8 +24,8 @@ def __init__(self, device_name,main_ui_mode):
 
         script_dir = Path(__file__).resolve().parent
         source = script_dir / 'brick-system.json'
-        ConfigCopier.ensure_config("/mnt/SDCARD/Saves/brick-system.json", source)
-        self.system_config = SystemConfig("/mnt/SDCARD/Saves/brick-system.json")
+        ConfigCopier.ensure_config("/mnt/SDCARD/Saves/trim-ui-smart-pro-system.json", source)
+        self.system_config = SystemConfig("/mnt/SDCARD/Saves/trim-ui-smart-pro-system.json")
         if(main_ui_mode):
             trim_stock_json_file = script_dir / 'stock/brick.json'
             ConfigCopier.ensure_config(TrimUISmartPro.TRIMUI_STOCK_CONFIG_LOCATION, trim_stock_json_file)

main-ui/devices/trimui/trim_ui_smart_pro_s.py

@@ -1,3 +1,5 @@
+import json
+import os
 from pathlib import Path
 import threading
 from audio.audio_player_delegate_sdl2 import AudioPlayerDelegateSdl2
@@ -9,10 +11,13 @@
 from devices.miyoo.system_config import SystemConfig
 from devices.miyoo_trim_common import MiyooTrimCommon
 from devices.trimui.trim_ui_device import TrimUIDevice
+from devices.utils.file_watcher import FileWatcher
+from display.display import Display
 from utils import throttle
 from utils.config_copier import ConfigCopier
 
 from utils.ffmpeg_image_utils import FfmpegImageUtils
+from utils.logger import PyUiLogger
 from utils.py_ui_config import PyUiConfig
 
 class TrimUISmartProS(TrimUIDevice):
@@ -24,12 +29,17 @@ def __init__(self, device_name,main_ui_mode):
 
         script_dir = Path(__file__).resolve().parent
         source = script_dir / 'brick-system.json'
-        ConfigCopier.ensure_config("/mnt/SDCARD/Saves/brick-system.json", source)
-        self.system_config = SystemConfig("/mnt/SDCARD/Saves/brick-system.json")
+        ConfigCopier.ensure_config("/mnt/SDCARD/Saves/trim-ui-smart-pro-s-system.json", source)
+        self.system_config = SystemConfig("/mnt/SDCARD/Saves/trim-ui-smart-pro-s-system.json")
+        self.mainui_volume = 0
+
         if(main_ui_mode):
+            self.on_mainui_config_change()
             trim_stock_json_file = script_dir / 'stock/brick.json'
             ConfigCopier.ensure_config(TrimUISmartProS.TRIMUI_STOCK_CONFIG_LOCATION, trim_stock_json_file)
 
+            self.mainui_config_thread, self.mainui_config_thread_stop_event = FileWatcher().start_file_watcher(
+                TrimUISmartProS.TRIMUI_STOCK_CONFIG_LOCATION, self.on_mainui_config_change, interval=0.2, repeat_trigger_for_mtime_granularity_issues=True)
 
             self.miyoo_games_file_parser = MiyooGamesFileParser()        
             self.ensure_wpa_supplicant_conf()
@@ -60,6 +70,10 @@ def startup_init(self, include_wifi=True):
         config_volume = self.system_config.get_volume()
         self._set_volume(config_volume)
 
+    def _set_volume(self, user_volume):
+        # Investigate sending volume key
+        pass
+
     #Untested
     @throttle.limit_refresh(5)
     def is_hdmi_connected(self):
@@ -159,6 +173,27 @@ def get_audio_system(self):
     def get_core_name_overrides(self, core_name):
         return [core_name, core_name+"-64"]
 
-    def _set_lumination_to_config(self):
-        with open("/sys/class/backlight/backlight0/brightness", "w") as f:
-            f.write(str((self.system_config.brightness * 255) // 20))
+    def get_volume(self):
+        try:
+            return self.mainui_volume * 5
+        except:
+            return 0
+        
+    def on_mainui_config_change(self):
+        path = TrimUISmartProS.TRIMUI_STOCK_CONFIG_LOCATION
+        if not os.path.exists(path):
+            PyUiLogger.get_logger().warning(f"File not found: {path}")
+            return
+
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            old_volume = self.mainui_volume
+            self.mainui_volume = data.get("vol")
+            if(old_volume != self.mainui_volume):
+                Display.volume_changed(self.mainui_volume * 5)
+
+        except Exception as e:
+            PyUiLogger.get_logger().warning(f"Error reading {path}: {e}")
+            return None

main-ui/devices/utils/file_watcher.py

@@ -6,25 +6,31 @@
 
 class FileWatcher():
 
-    def watch_file(self,path, callback, interval=1.0):
+    def watch_file(self,path, callback, interval, repeat_trigger_for_mtime_granularity_issues):
         last_mtime = None
+        prev_loop_executed_counter = 0.0
+        last_mtime = os.stat(path).st_mtime_ns
         while True:
             try:
-                mtime = os.path.getmtime(path)
-                if last_mtime is None:
-                    last_mtime = mtime
-                elif mtime != last_mtime:
+                mtime = os.stat(path).st_mtime_ns
+                if mtime != last_mtime:
+                    PyUiLogger.get_logger().info(f"{path} detection changed.")        
                     last_mtime = mtime
                     callback()
+                    if repeat_trigger_for_mtime_granularity_issues:
+                       prev_loop_executed_counter = 2.0
+                elif(prev_loop_executed_counter > 0.0):
+                    callback()
+                    prev_loop_executed_counter -= interval
             except FileNotFoundError:
                 PyUiLogger.get_logger().warning(f"{path} not found for file watcher.")        
             time.sleep(interval)
 
-    def start_file_watcher(self,path, callback, interval=1.0):
+    def start_file_watcher(self,path, callback, interval=1.0, repeat_trigger_for_mtime_granularity_issues=False):
         stop_event = threading.Event()
         thread = threading.Thread(
             target=self.watch_file,
-            args=(path, callback, interval),
+            args=(path, callback, interval, repeat_trigger_for_mtime_granularity_issues),
             daemon=True
         )
         thread.start()

main-ui/display/display.py

@@ -88,6 +88,10 @@ class Display:
     top_bar_text = None
     _image_texture_cache = ImageTextureCache()
     _text_texture_cache = TextTextureCache()
+    _problematic_images = set()  # Class-level set to track images that won't load properly
+    _problematic_image_keywords = [
+        "No such file or directory",
+    ]
 
     @classmethod
     def init(cls):
@@ -489,12 +493,19 @@ def _render_surface_texture(cls, x, y, texture, surface, render_mode: RenderMode
             return render_w, render_h
 
     @classmethod
-    def log_sdl_error_and_clear_cache(cls):
+    def log_sdl_error_and_clear_cache(cls, image_path=None):
         err = sdl2.sdlttf.TTF_GetError()
         err_msg = err.decode('utf-8') if err else "Unknown error"
-        PyUiLogger.get_logger().warning(f"Clearing cache : {err_msg}")
-        cls._text_texture_cache.clear_cache()
-        cls._image_texture_cache.clear_cache()
+        PyUiLogger.get_logger().warning(f"SDL Error received on loading {image_path} : {err_msg}")
+        
+        if any(keyword in err_msg for keyword in cls._problematic_image_keywords):
+            if(image_path is not None):
+                cls._problematic_images.add(image_path)
+                PyUiLogger.get_logger().warning(f"Marking as image to permanently stop trying to load: {image_path}")
+        else:
+            PyUiLogger.get_logger().warning(f"Clearing cache : {err_msg}")
+            cls._text_texture_cache.clear_cache()
+            cls._image_texture_cache.clear_cache()
 
 
     @classmethod
@@ -576,7 +587,7 @@ def image_load(cls, image_path):
 
     @classmethod
     def render_image(cls, image_path: str, x: int, y: int, render_mode=RenderMode.TOP_LEFT_ALIGNED, target_width=None, target_height=None, resize_type=None):
-        if(image_path is None):
+        if(image_path is None or image_path in cls._problematic_images):
             return 0, 0
 
         cache : CachedImageTexture = cls._image_texture_cache.get_texture(image_path)
@@ -587,7 +598,7 @@ def render_image(cls, image_path: str, x: int, y: int, render_mode=RenderMode.TO
         else:
             surface = Display.image_load(image_path)
             if not surface:
-                cls.log_sdl_error_and_clear_cache()
+                cls.log_sdl_error_and_clear_cache(image_path)
                 surface = Display.image_load(image_path)
                 if not surface:
                     PyUiLogger.get_logger().error(f"Failed to load image: {image_path}")

main-ui/menus/games/utils/roms_list_manager.py

@@ -71,15 +71,29 @@ def load_from_file(self):
 
             with open(self.entries_file, 'r') as f:
                 data = json.load(f)
-                self._entries = [RomsListEntry(**entry) for entry in data]
+                validated_entries = []
+                for entry_data in data:
+                    entry = RomsListEntry(**entry_data)
+                    if os.path.exists(entry.rom_file_path):
+                        validated_entries.append(entry)
+                    else:
+                        PyUiLogger.get_logger().warning(
+                            f"ROM file not found, removing from list: {entry.rom_file_path}"
+                        )
+
+                self._entries = validated_entries
                 self._entries_dict = {
                     self._entry_key(entry.rom_file_path, entry.game_system_name): entry
                     for entry in self._entries
                 }
 
+            # Save back the validated list in case some entries were removed
+            self.save_to_file()
+
         except Exception as e:
             PyUiLogger.get_logger().error(f"Failed to load entries: {e}")
 
+
     def get_games(self) -> List[RomInfo]:
         return self.rom_info_list