Merge remote-tracking branch 'upstream/main'

Author: github-actions[bot]

main-ui/controller/key_watcher_controller_miyoo_mini.py

@@ -103,7 +103,6 @@ def read_event(self, fd):
 
     def poll_keyboard(self):
         logger = PyUiLogger.get_logger()
-        logger.debug("Starting keyboard polling on fd %d", self.fd)
 
         while True:
             now = time.time()

main-ui/devices/device_common.py

@@ -236,9 +236,11 @@ def monitor_wifi(self):
 
             time.sleep(10)
 
-    @throttle.limit_refresh(10)
+    @throttle.limit_refresh(15)
     def get_wifi_status(self):
         if(self.is_wifi_enabled()):
+            if(self.get_ip_addr_text() in ["Off","Error","Connecting"]):
+                return WifiStatus.OFF
             wifi_connection_quality_info = self.get_wifi_connection_quality_info()
             # Composite score out of 100 based on weighted contribution
             # Adjust weights as needed based on empirical testing

main-ui/devices/miyoo/mini/miyoo_mini_common.py

@@ -1,16 +1,14 @@
-import ctypes
-import fcntl
+import time
+from asyncio import sleep
 import json
-import math
 from pathlib import Path
 import subprocess
 import threading
-import time
-from zoneinfo import reset_tzpath
+import os
+from utils.logger import PyUiLogger
 from controller.controller_inputs import ControllerInput
 from controller.key_state import KeyState
 from controller.key_watcher import KeyWatcher
-import os
 from controller.key_watcher_controller_miyoo_mini import InputResult, KeyEvent, KeyWatcherControllerMiyooMini
 from devices.miyoo.mini.miyoo_mini_flip_shared_memory_writer import MiyooMiniFlipSharedMemoryWriter
 from devices.miyoo.mini.miyoo_mini_flip_specific_model_variables import MiyooMiniSpecificModelVariables
@@ -20,14 +18,12 @@
 from devices.miyoo_trim_common import MiyooTrimCommon
 from devices.utils.file_watcher import FileWatcher
 from devices.utils.process_runner import ProcessRunner
-from display.display import Display
 from menus.games.utils.rom_info import RomInfo
-from menus.settings.timezone_menu import TimezoneMenu
 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
+from utils.time_logger import log_timing
 
 MAX_VOLUME = 20
 MIN_RAW_VALUE = -60
@@ -43,47 +39,21 @@ class MiyooMiniCommon(MiyooDevice):
 
 
     def __init__(self, device_name, main_ui_mode, miyoo_mini_specific_model_variables: MiyooMiniSpecificModelVariables):
+
         self.device_name = device_name
         self.miyoo_mini_specific_model_variables = miyoo_mini_specific_model_variables
         self.controller_interface = self.build_controller_interface()
-        self.unknown_axis_ranges = {}  # axis -> (min, max)
-        self.unknown_axis_stats = {}   # axis -> (sum, count)
-        self.sdl_axis_names = {
-            0: "SDL_CONTROLLER_AXIS_LEFTX",
-            1: "SDL_CONTROLLER_AXIS_LEFTY",
-            2: "SDL_CONTROLLER_AXIS_RIGHTX",
-            3: "SDL_CONTROLLER_AXIS_RIGHTY",
-            4: "SDL_CONTROLLER_AXIS_TRIGGERLEFT",
-            5: "SDL_CONTROLLER_AXIS_TRIGGERRIGHT"
-        }
-
 
         ConfigCopier.ensure_config("/mnt/SDCARD/Saves/mini-flip-system.json", Path(__file__).resolve().parent  / 'mini-flip-system.json')
         self.system_config = SystemConfig("/mnt/SDCARD/Saves/mini-flip-system.json")
+        
         if(main_ui_mode):
-            os.environ["TZPATH"] = "/mnt/SDCARD/miyoo285/zoneinfo"
-            reset_tzpath()  # reload TZPATH
             self.miyoo_mini_flip_shared_memory_writer = MiyooMiniFlipSharedMemoryWriter()
             self.miyoo_games_file_parser = MiyooGamesFileParser()        
-            self._set_lumination_to_config()
-            self._set_contrast_to_config()
-            self._set_saturation_to_config()
-            self._set_brightness_to_config()
-            self.ensure_wpa_supplicant_conf()
-            self.init_gpio()
             self.mainui_volume = None
             self.mainui_config_thread, self.mainui_config_thread_stop_event = FileWatcher().start_file_watcher(
                 "/appconfigs/system.json", self.on_mainui_config_change, interval=0.2)
             threading.Thread(target=self.startup_init, daemon=True).start()
-        
-        if(PyUiConfig.enable_button_watchers()):
-            from controller.controller import Controller
-            #/dev/miyooio if we want to get rid of miyoo_inputd
-            # debug in terminal: hexdump  /dev/miyooio
-            self.volume_key_watcher = KeyWatcher("/dev/input/event0")
-            Controller.add_button_watcher(self.volume_key_watcher.poll_keyboard)
-            volume_key_polling_thread = threading.Thread(target=self.volume_key_watcher.poll_keyboard, daemon=True)
-            volume_key_polling_thread.start()
 
         super().__init__()
 
@@ -100,19 +70,31 @@ def on_mainui_config_change(self):
             old_volume = self.mainui_volume
             self.mainui_volume = data.get("vol")
             if(old_volume != self.mainui_volume):
+                from display.display import Display
                 Display.volume_changed(self.mainui_volume * 5)
 
         except Exception as e:
             PyUiLogger.get_logger().warning(f"Error reading {path}: {e}")
             return None
 
     def startup_init(self, include_wifi=True):
-        config_volume = self.system_config.get_volume()
-        self._set_volume(config_volume)
         if(self.is_wifi_enabled()):
             self.start_wifi_services()
         self.on_mainui_config_change()
-        self.apply_timezone(self.system_config.get_timezone())
+        self._set_lumination_to_config()
+        self._set_contrast_to_config()
+        self._set_saturation_to_config()
+        self._set_brightness_to_config()
+        self.ensure_wpa_supplicant_conf()
+        self.init_gpio()
+        if(PyUiConfig.enable_button_watchers()):
+            from controller.controller import Controller
+            #/dev/miyooio if we want to get rid of miyoo_inputd
+            # debug in terminal: hexdump  /dev/miyooio
+            self.volume_key_watcher = KeyWatcher("/dev/input/event0")
+            Controller.add_button_watcher(self.volume_key_watcher.poll_keyboard)
+            volume_key_polling_thread = threading.Thread(target=self.volume_key_watcher.poll_keyboard, daemon=True)
+            volume_key_polling_thread.start()
 
     def build_controller_interface(self):
         key_mappings = {}  
@@ -346,63 +328,64 @@ def get_volume(self):
             return self.mainui_volume * 5
         except:
             return 0
-        
-    def _set_volume_raw(self, value: int, add: int = 0) -> int:
-        try:
-            fd = os.open("/dev/mi_ao", os.O_RDWR)
-        except OSError:
-            return 0
-
-        # Prepare buffers
-        buf2 = (ctypes.c_int * 2)(0, 0)
-        buf1 = (ctypes.c_uint64 * 2)(ctypes.sizeof(buf2), ctypes.cast(buf2, ctypes.c_void_p).value)
 
-        # Get previous volume
-        fcntl.ioctl(fd, MI_AO_GETVOLUME, buf1)
-        prev_value = buf2[1]
+    def volume_up(self):
+        try:
+            subprocess.run(
+                ["send_event", "/dev/input/event0", "115:1"],
+                check=False
+            )
+        except Exception as e:
+            PyUiLogger.get_logger().exception(f"Failed to set volume via input events: {e}")
 
-        if add:
-            value = prev_value + add
+    def volume_down(self):
+        try:
+            subprocess.run(
+                ["send_event", "/dev/input/event0", "114:1"],
+                check=False
+            )
+        except Exception as e:
+            PyUiLogger.get_logger().exception(f"Failed to set volume via input events: {e}")
+
+    def change_volume(self, amount):
+        self.system_config.reload_config()
+        volume = self.get_volume() + amount
+        if(volume < 0):
+            volume = 0
+        elif(volume > 100):
+            volume = 100
+        if(amount > 0):
+            self.volume_up()
         else:
-            value += MIN_RAW_VALUE
-
-        # Clamp value
-        value = max(MIN_RAW_VALUE, min(MAX_RAW_VALUE, value))
-
-        if value == prev_value:
-            os.close(fd)
-            return prev_value
-
-        buf2[1] = value
-        fcntl.ioctl(fd, MI_AO_SETVOLUME, buf1)
-
-        # Handle mute
-        if prev_value <= MIN_RAW_VALUE < value:
-            buf2[1] = 0
-            fcntl.ioctl(fd, MI_AO_SETMUTE, buf1)
-        elif prev_value > MIN_RAW_VALUE >= value:
-            buf2[1] = 1
-            fcntl.ioctl(fd, MI_AO_SETMUTE, buf1)
-
-        os.close(fd)
-        return value
-
+            self.volume_down()
+        sleep(0.1)
+        self.on_mainui_config_change()
 
     def _set_volume(self, volume: int) -> int:
-        #Breaks keymon somehow
-        if(False):
-            volume = max(0, min(MAX_VOLUME, volume))
+        event_dev = "/dev/input/event0"
 
-            volume_raw = 0
-            if volume != 0:
-                volume_raw = round(48 * math.log10(1 + volume))  # volume curve
+        try:
+            # Send volume-down (114) 20 times
+            for _ in range(20):
+                subprocess.run(
+                    ["send_event", event_dev, "114:1"],
+                    check=False
+                )
+            time.sleep(0.2)
+            # Send volume-up (115) volume//5 times
+            for _ in range(volume // 5):
+                subprocess.run(
+                    ["send_event", event_dev, "115:1"],
+                    check=False
+                )
+
+        except Exception as e:
+            PyUiLogger.get_logger().exception(f"Failed to set volume via input events: {e}")
 
-            self._set_volume_raw(volume_raw, 0)
         return volume
 
     def fix_sleep_sound_bug(self):
-        config_volume = self.system_config.get_volume()
-        self._set_volume(config_volume)
+        pass #uneeded
 
 
     def run_game(self, rom_info: RomInfo) -> subprocess.Popen:
@@ -468,14 +451,8 @@ def supports_timezone_setting(self):
         return True
 
     def prompt_timezone_update(self):
-        timezone_menu = TimezoneMenu()
-        tz = timezone_menu.ask_user_for_timezone(timezone_menu.list_timezone_files('/mnt/SDCARD/miyoo285/zoneinfo/', verify_via_datetime=False))
-
-        if (tz is not None):
-            self.system_config.set_timezone(tz)
-            self.apply_timezone(tz)
-            Display.display_message_multiline(["Timezone changed","Reloading UI..."],2000)           
-            self.exit_pyui()
+        #No timezone update for miyoo mini
+        pass
 
     def apply_timezone(self, timezone):
         ProcessRunner.run(["rm", "-f", "/tmp/localtime"])

main-ui/devices/miyoo/mini/sprig_miyoo_mini_common.py

@@ -22,6 +22,8 @@ def __init__(self, device_name, main_ui_mode, miyoo_mini_specific_model_variable
 
     def startup_init(self, include_wifi=True):
         super().startup_init()
+        config_volume = self.system_config.get_volume()
+        self._set_volume(config_volume)
         self._set_screen_values_to_config()
 
     def on_sprig_config_change(self):

main-ui/display/display.py

@@ -91,7 +91,9 @@ class Display:
     _problematic_images = set()  # Class-level set to track images that won't load properly
     _problematic_image_keywords = [
         "No such file or directory",
-        "Text has zero width"
+        "Text has zero width",
+        "Texture dimensions are limited",
+        "Corrupt PNG"
     ]
 
     @classmethod
@@ -232,18 +234,15 @@ def deinit_display(cls):
         cls._text_texture_cache.clear_cache()
         cls._image_texture_cache.clear_cache()
         sdl2.SDL_QuitSubSystem(sdl2.SDL_INIT_VIDEO)
-        PyUiLogger.get_logger().debug("Display deinitialized")    
 
     @classmethod
     def clear_text_cache(cls):
-        PyUiLogger.get_logger().debug("Clearing text cache")    
         cls._text_texture_cache.clear_cache()
         cls.deinit_fonts()
         cls.init_fonts()
 
     @classmethod
     def clear_image_cache(cls):
-        PyUiLogger.get_logger().debug("Clearing image cache")    
         cls._image_texture_cache.clear_cache()
 
     @classmethod
@@ -259,7 +258,6 @@ def deinit_fonts(cls):
 
     @classmethod
     def reinitialize(cls, bg=None):
-        PyUiLogger.get_logger().info("reinitialize display")
         cls.deinit_display()
         cls._unload_bg_texture()
         cls._init_display()
@@ -274,7 +272,6 @@ def _unload_bg_texture(cls):
         if cls.background_texture:
             sdl2.SDL_DestroyTexture(cls.background_texture)
             cls.background_texture = None
-            PyUiLogger.get_logger().debug("Destroying bg texture")
 
     @classmethod
     def restore_bg(cls, bg=None):
@@ -635,8 +632,7 @@ def render_image(cls, image_path: str, x: int, y: int, render_mode=RenderMode.TO
             if(surface_width > Device.max_texture_width() or surface_height > Device.max_texture_height()):
                 sdl2.SDL_FreeSurface(surface)
                 PyUiLogger.get_logger().warning(
-                    f"Image is too large to render. Skipping {image_path}\n"
-                    f"Stack trace:\n{''.join(traceback.format_stack())}"
+                    f"Image is too large to render ({surface_width} x {surface_height} with max of {Device.max_texture_width()} x {Device.max_texture_height()}). Skipping {image_path}\n"
                 ) 
                 cls._problematic_images.add(image_path)
                 return 0, 0

main-ui/games/utils/box_art_resizer.py

@@ -142,7 +142,7 @@ def clear_interim_folders(cls, img_path):
 
     @classmethod
     def patch_boxart_list(cls, image_list):
-        cls.scan_count = 0
+        cls.scan_count = len(image_list)
         cls.patched_count = 0
         threading.Thread(target=cls.monitor_for_input, daemon=True).start()
 
@@ -163,6 +163,7 @@ def patch_boxart_list(cls, image_list):
     @classmethod
     def process_rom_folders(cls):
         """Search through ROM directories and scale images inside Imgs folders."""
+        Display.display_message(f"Starting boxart patching", 500)
         rom_paths = ["/mnt/SDCARD/Roms/", "/media/sdcard1/Roms/"]
         target_medium_width, target_medium_height = Device.get_boxart_medium_resize_dimensions()
         target_small_width, target_small_height = Device.get_boxart_small_resize_dimensions()

main-ui/mainui.py

@@ -198,13 +198,9 @@ def main():
     args = parse_arguments()
     PyUiLogger.init(args.logDir, "PyUI")
     PyUiLogger.get_logger().info(f"{args}")
-    #PyUiLogger.get_logger().info(f"logDir: {args.logDir}")
-    #PyUiLogger.get_logger().info(f"pyUiConfig: {args.pyUiConfig}")
-    #PyUiLogger.get_logger().info(f"device: {args.device}")
 
     #log_renderer_info()
 
-    PyUiLogger.get_logger().info(f"{args}")
     with log_timing("Entire Startup initialization", PyUiLogger.get_logger()):    
 
         with log_timing("Config initialization", PyUiLogger.get_logger()):    
@@ -242,9 +238,9 @@ def main():
         check_for_msg_display_socket_based(args)
         check_for_option_list_file(args)
 
-        main_menu = MainMenu()
+    main_menu = MainMenu()
 
-        start_background_threads()
+    start_background_threads()
     keep_running = True
     PyUiLogger.get_logger().info("Entering main loop")
     while(keep_running):

main-ui/menus/settings/extra_settings_menu.py

@@ -204,7 +204,6 @@ def build_options_list(self):
             menu_options = CfwSystemConfig.get_menu_options(category=category)
             contains_entry_for_device = False
             for name, option in menu_options.items():
-                PyUiLogger.get_logger().info(f"{option}")
                 devices = option.get('devices')
                 supported_device = not devices or Device.get_device_name() in devices
                 if(supported_device):