refactor: separate UI logic from business layer in recording management

Author: ihmily

app/app_manager.py

@@ -1,13 +1,11 @@
+import asyncio
 import os
 import time
 
 import flet as ft
 
 from . import execute_dir
-from .core.config.config_manager import ConfigManager
-from .core.config.language_manager import LanguageManager
-from .core.recording.record_manager import RecordingManager
-from .core.runtime.process_manager import AsyncProcessManager
+from .core.runtime.backend_services import BackendServices
 from .core.update.update_checker import UpdateChecker
 from .initialization.installation_manager import InstallationManager
 from .ui.components.business.recording_card import RecordingCardManager
@@ -18,18 +16,28 @@
 from .ui.views.recordings_view import RecordingsPage
 from .ui.views.settings_view import SettingsPage
 from .ui.views.storage_view import StoragePage
-from .utils import utils
 from .utils.logger import logger
 
 
 class App:
-    def __init__(self, page: ft.Page):
-        self.install_progress = None
+    def __init__(self, page: ft.Page, services: BackendServices | None = None):
         self.page = page
+        self.install_progress = None
+
+        if services is None:
+            services = BackendServices.get_or_none()
+            if services is None:
+                services = BackendServices.bootstrap(execute_dir)
+        self.services = services
+
         self.run_path = execute_dir
         self.assets_dir = os.path.join(execute_dir, "assets")
-        self.process_manager = AsyncProcessManager()
-        self.config_manager = ConfigManager(self.run_path)
+
+        self.config_manager = services.config_manager
+        self.process_manager = services.process_manager
+        self.language_manager = services.language_manager
+        self.record_manager = services.recording_manager
+
         self.is_web_mode = False
         self.auth_manager = None
         self.current_username = None
@@ -41,7 +49,10 @@ def __init__(self, page: ft.Page):
         )
 
         self.settings = SettingsPage(self)
-        self.language_manager = LanguageManager(self)
+        services.settings_config.adopt_user_config(self.settings.user_config)
+        services.settings_config.adopt_cookies_config(self.settings.cookies_config)
+        services.settings_config.adopt_accounts_config(self.settings.accounts_config)
+        services.settings_config.language_code = self.settings.language_code or services.settings_config.language_code
         self.language_code = self.settings.language_code
         self.about = AboutPage(self)
         self.recordings = RecordingsPage(self)
@@ -64,18 +75,82 @@ def __init__(self, page: ft.Page):
             ],
         )
         self.snack_bar = ShowSnackBar(self)
-        self.subprocess_start_up_info = utils.get_startup_info()
+        self.subprocess_start_up_info = services.subprocess_start_up_info
         self.record_card_manager = RecordingCardManager(self)
-        self.record_manager = RecordingManager(self)
         self.current_page = None
         self._loading_page = False
-        self.recording_enabled = True
         self.install_manager = InstallationManager(self)
         self.update_checker = UpdateChecker(self)
         self.page.run_task(self.install_manager.check_env)
-        self.page.run_task(self.record_manager.check_free_space)
+        if self.record_manager is not None:
+            self.page.run_task(self.record_manager.check_free_space)
         self.page.run_task(self._check_for_updates)
 
+        services.register_ui_bridge(self)
+
+    @property
+    def recording_enabled(self):
+        return self.services.recording_enabled
+
+    @recording_enabled.setter
+    def recording_enabled(self, value: bool):
+        self.services.recording_enabled = value
+
+    @property
+    def tray_manager(self):
+        return self.services.tray_manager
+
+    @tray_manager.setter
+    def tray_manager(self, value):
+        self.services.tray_manager = value
+
+    def _get_session_loop(self) -> asyncio.AbstractEventLoop | None:
+        """Return the asyncio event loop bound to the current Flet session,
+        or ``None`` if the session/connection is dead."""
+        try:
+            session = self.page.session
+            if session is None:
+                return None
+            connection = getattr(session, "connection", None)
+            if connection is None:
+                return None
+            return getattr(connection, "loop", None)
+        except Exception:
+            return None
+
+    def schedule_card_update(self, recording) -> None:
+        loop = self._get_session_loop()
+        if loop is None:
+            return
+        try:
+            asyncio.run_coroutine_threadsafe(self.record_card_manager.update_card(recording), loop)
+        except Exception as exc:
+            logger.debug(f"schedule_card_update dropped: {exc}")
+
+    def schedule_card_remove(self, recordings) -> None:
+        loop = self._get_session_loop()
+        if loop is None:
+            return
+        try:
+            asyncio.run_coroutine_threadsafe(self.record_card_manager.remove_recording_card(recordings), loop)
+        except Exception as exc:
+            logger.debug(f"schedule_card_remove dropped: {exc}")
+
+    def schedule_snack(self, text: str, **kw) -> None:
+        loop = self._get_session_loop()
+        if loop is None:
+            return
+        try:
+            asyncio.run_coroutine_threadsafe(self.snack_bar.show_snack_bar(text, **kw), loop)
+        except Exception as exc:
+            logger.debug(f"schedule_snack dropped: {exc}")
+
+    def schedule_pubsub(self, topic: str, payload) -> None:
+        try:
+            self.page.pubsub.send_others_on_topic(topic, payload)
+        except Exception as exc:
+            logger.debug(f"schedule_pubsub dropped: {exc}")
+
     def initialize_pages(self):
         return {
             "settings": self.settings,
@@ -104,12 +179,15 @@ async def clear_content_area(self):
         self.content_area.update()
 
     async def cleanup(self):
-        try:
-            await self.process_manager.cleanup()
-        except ConnectionError:
-            logger.warning("Connection lost, process may have terminated")
-        except Exception as e:
-            logger.error(f"Error during cleanup: {e}")
+        self.services.unregister_ui_bridge(self)
+
+        if not self.is_web_mode:
+            try:
+                await self.process_manager.cleanup()
+            except ConnectionError:
+                logger.warning("Connection lost, process may have terminated")
+            except Exception as e:
+                logger.error(f"Error during cleanup: {e}")
 
     def add_ffmpeg_process(self, process):
         self.process_manager.add_process(process)
@@ -130,10 +208,13 @@ async def _check_for_updates(self):
                 await self.config_manager.save_user_config(self.settings.user_config)
 
                 if update_info.get("has_update", False):
-                    await self.update_checker.show_update_dialog(update_info)
+                    await self.update_checker.show_update_dialog(dict(update_info))
         except Exception as e:
             logger.error(f"Update check failed: {e}")
 
     async def start_periodic_tasks(self):
-        """Start all periodic tasks"""
-        await self.record_manager.setup_periodic_live_check(int(self.record_manager.loop_time_seconds or 180))
+        rm = self.record_manager
+        if rm is None:
+            return
+        interval = int(rm.loop_time_seconds or 180)
+        await rm.setup_periodic_live_check(interval)

app/core/config/config_manager.py

@@ -1,10 +1,11 @@
+import asyncio
 import json
 import os
 import shutil
+import tempfile
+import threading
 from typing import TypeVar
 
-import aiofiles
-
 from ...utils.logger import logger
 
 T = TypeVar("T")
@@ -115,12 +116,31 @@ def load_i18n_config(self, path):
     def load_web_auth_config(self):
         return self._load_config(self.web_auth_config_path, "An error occurred while loading web auth config")
 
+    _write_lock = threading.Lock()
+
     @staticmethod
     async def _save_config(config_path, config, success_message, error_message):
-        """Save configuration to a JSON file."""
+        """Save configuration to a JSON file (thread-safe, atomic write)."""
         try:
-            async with aiofiles.open(config_path, "w", encoding="utf-8") as file:
-                await file.write(json.dumps(config, ensure_ascii=False, indent=4))
+            content = json.dumps(config, ensure_ascii=False, indent=4)
+
+            def _write_sync():
+                with ConfigManager._write_lock:
+                    dir_name = os.path.dirname(config_path)
+                    fd, tmp_path = tempfile.mkstemp(suffix=".tmp", prefix=".cfg_", dir=str(dir_name))
+                    try:
+                        with os.fdopen(fd, "w", encoding="utf-8") as f:
+                            f.write(content)
+                        os.replace(tmp_path, config_path)
+                    except BaseException:
+                        # Clean up temp file on failure.
+                        try:
+                            os.unlink(tmp_path)
+                        except OSError:
+                            pass
+                        raise
+
+            await asyncio.to_thread(_write_sync)
             logger.info(success_message)
         except Exception as e:
             logger.error(f"{error_message}: {e}")

app/core/config/language_manager.py

@@ -13,16 +13,44 @@ def __init__(self, app):
         self._observers = []
         self.language = {}
         self.app = app
+        self.services = getattr(app, "services", None) if app is not None else None
+        self.run_path = app.run_path if app is not None else None
         self.load()
 
+    @classmethod
+    def create_headless(cls, services) -> "LanguageManager":
+        instance = cls.__new__(cls)
+        instance._observers = []
+        instance.language = {}
+        instance.app = None
+        instance.services = services
+        instance.run_path = services.run_path
+        instance.load()
+        return instance
+
+    def _resolve_language_code(self) -> str:
+        services = self.services
+        if services is not None and hasattr(services, "settings_config"):
+            sc = services.settings_config
+            if sc is not None and hasattr(sc, "language_code"):
+                return sc.language_code
+        app = self.app
+        if app is not None and hasattr(app, "settings"):
+            settings = app.settings
+            if settings is not None and hasattr(settings, "language_code"):
+                return settings.language_code
+        return "zh_CN"
+
     def load(self):
         """
         Initialize the LanguageManager with settings and load the language configuration.
         """
-        config_manager = ConfigManager(self.app.run_path)
-        logger.info(f"Language Code: {self.app.settings.language_code}")
-        i18n_filename = f"{self.app.settings.language_code}.json"
-        i18n_file_path = os.path.join(self.app.run_path, "locales", i18n_filename)
+        run_path = self.run_path or (self.app.run_path if self.app is not None else None) or ""
+        config_manager = ConfigManager(run_path)
+        language_code = self._resolve_language_code() or "zh_CN"
+        logger.info(f"Language Code: {language_code}")
+        i18n_filename = f"{language_code}.json"
+        i18n_file_path = os.path.join(run_path, "locales", i18n_filename)
         self.language = config_manager.load_i18n_config(i18n_file_path)
         return self.language
 

app/core/config/settings_config.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+
+class SettingsConfig:
+    def __init__(self, services):
+        self.services = services
+        cm = services.config_manager
+        self.user_config: dict = cm.load_user_config() or {}
+        self.default_config: dict = cm.load_default_config() or {}
+        self.cookies_config: dict = cm.load_cookies_config() or {}
+        self.accounts_config: dict = cm.load_accounts_config() or {}
+        self.language_option: dict = cm.load_language_config() or {}
+
+        select_language = self.user_config.get("language")
+        if select_language and select_language in self.language_option:
+            self.language_code: str = self.language_option[select_language]
+        elif self.language_option:
+            self.language_code = next(iter(self.language_option.values()))
+        else:
+            self.language_code = "zh_CN"
+
+    def get_config_value(self, key: str, default: Any = None) -> Any:
+        return self.user_config.get(key, self.default_config.get(key, default))
+
+    def get_cookies_value(self, key: str, default: str = "") -> str:
+        return self.cookies_config.get(key, default)
+
+    def get_accounts_value(self, key: str, default: Any = None) -> Any:
+        try:
+            k1, k2 = key.split("_", maxsplit=1)
+        except ValueError:
+            return default
+        return self.accounts_config.get(k1, {}).get(k2, default)
+
+    def get_video_save_path(self) -> str:
+        live_save_path = self.get_config_value("live_save_path")
+        if not live_save_path:
+            live_save_path = os.path.join(self.services.run_path, "downloads")
+        return live_save_path
+
+    def adopt_user_config(self, user_config: dict) -> None:
+        """Replace ``user_config`` reference (used when the UI rebuilds it)."""
+        self.user_config = user_config
+
+    def adopt_cookies_config(self, cookies_config: dict) -> None:
+        self.cookies_config = cookies_config
+
+    def adopt_accounts_config(self, accounts_config: dict) -> None:
+        self.accounts_config = accounts_config