perf: optimize recordings load

app/app_manager.py

@@ -134,3 +134,7 @@ class App:
                     await self.update_checker.show_update_dialog(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()

app/core/recording/record_manager.py

@@ -192,19 +192,34 @@ class RecordingManager:
                 if not recording.detection_time or is_exceeded:
                     self.app.page.run_task(self.check_if_live, recording)
 
+    _periodic_task_running = False
+    
+    @classmethod
+    def is_periodic_task_running(cls):
+        return cls._periodic_task_running
+    
+    @classmethod
+    def set_periodic_task_running(cls, value=True):
+        cls._periodic_task_running = value
+    
     async def setup_periodic_live_check(self, interval: int = 180):
         """Set up a periodic task to check live status."""
-
         async def periodic_check():
+            logger.info("Starting periodic live check background task")
             while True:
-                await asyncio.sleep(interval)
+                logger.debug(f"Running periodic check (interval: {interval}s)")
                 await self.check_free_space()
                 if self.app.recording_enabled:
                     await self.check_all_live_status()
+                await asyncio.sleep(interval)
 
-        if not self.periodic_task_started:
+        if not RecordingManager.is_periodic_task_running():
+            RecordingManager.set_periodic_task_running(True)
             self.periodic_task_started = True
-            await periodic_check()
+            logger.info(f"Initializing periodic live check task with interval: {interval}s")
+            asyncio.create_task(periodic_check())
+        else:
+            logger.info("Periodic live check task already running globally, skipping initialization")
 
     async def check_if_live(self, recording: Recording):
         """Check if the live stream is available, fetch stream data and update is_live status."""

app/ui/components/business/recording_card.py

@@ -37,11 +37,7 @@ class RecordingCardManager:
     async def create_card(self, recording: Recording):
         """Create a card for a given recording."""
         rec_id = recording.rec_id
-        if not self.cards_obj.get(rec_id):
-            if self.app.recording_enabled:
-                self.app.page.run_task(self.app.record_manager.check_if_live, recording)
-            else:
-                recording.status_info = RecordingStatus.NOT_RECORDING_SPACE
+
         card_data = self._create_card_components(recording)
         self.cards_obj[rec_id] = card_data
         self.start_update_task(recording)

app/ui/views/recordings_view.py

@@ -4,6 +4,7 @@ import uuid
 import flet as ft
 
 from ...core.platforms.platform_handlers import get_platform_info
+from ...core.recording.record_manager import RecordingManager
 from ...models.recording.recording_model import Recording
 from ...utils.logger import logger
 from ..base_page import PageBase
@@ -471,7 +472,7 @@ class RecordingsPage(PageBase):
         self.loading_indicator.update()
         self.recording_card_area.update()
         
-        if not self.app.record_manager.periodic_task_started:
+        if not RecordingManager.is_periodic_task_running():
             self.page.run_task(
                 self.app.record_manager.setup_periodic_live_check,
                 self.app.record_manager.loop_time_seconds

main.py

@@ -22,6 +22,13 @@ MIN_WIDTH = 950
 ASSETS_DIR = "assets"
 
 
+class GlobalState:
+    periodic_tasks_started = False
+
+
+global_state = GlobalState()
+
+
 def setup_window(page: ft.Page, is_web: bool) -> None:
     page.window.icon = os.path.join(execute_dir, ASSETS_DIR, "icon.ico")
     page.window.center()
@@ -66,7 +73,6 @@ def handle_route_change(page: ft.Page, app: App) -> callable:
 
 
 def handle_window_event(page: ft.Page, app: App, save_progress_overlay: 'SaveProgressOverlay') -> callable:
-
     async def on_window_event(e: ft.ControlEvent) -> None:
         if e.data == "close":
             await handle_app_close(page, app, save_progress_overlay)
@@ -82,21 +88,21 @@ def handle_disconnect(page: ft.Page, app: App) -> callable:
         app.settings.user_config["last_route"] = page.route
         await app.config_manager.save_user_config(app.settings.user_config)
         logger.info(f"Saved last route: {page.route}")
+
     return disconnect
 
 
 def handle_page_resize(page: ft.Page, app: App) -> callable:
     """handle page resize"""
-    
+
     def on_resize(_: ft.ControlEvent) -> None:
         setup_responsive_layout(page, app)
         page.update()
-    
-    return on_resize 
+
+    return on_resize
 
 
 async def main(page: ft.Page) -> None:
-
     page.title = "StreamCap"
     page.window.min_width = MIN_WIDTH
     page.window.min_height = MIN_WIDTH * WINDOW_SCALE
@@ -129,6 +135,7 @@ async def main(page: ft.Page) -> None:
         if is_web:
             setup_responsive_layout(page, app)
             page.on_resize = handle_page_resize(page, app)
+            page.on_disconnect = handle_disconnect(page, app)
 
         page.add(app.complete_page)
         
@@ -136,13 +143,23 @@ async def main(page: ft.Page) -> None:
         page.window.prevent_close = True
         page.window.on_event = handle_window_event(page, app, save_progress_overlay)
         if is_web:
-            page.on_disconnect = handle_disconnect(page, app)
-        elif page.platform.value == "windows":
-            if hasattr(app, "tray_manager"):
-                try:
-                    app.tray_manager.start(page)
-                except Exception as err:
-                    logger.error(f"Failed to start tray manager: {err}")
+            global global_state
+            if not global_state.periodic_tasks_started:
+                global_state.periodic_tasks_started = True
+                logger.info("Starting periodic tasks for the first time in web mode")
+                page.run_task(app.start_periodic_tasks)
+            else:
+                logger.info("Periodic tasks already running in web mode, skipping initialization")
+        else:
+            logger.info("Starting periodic tasks in desktop mode")
+            page.run_task(app.start_periodic_tasks)
+
+            if page.platform.value == "windows":
+                if hasattr(app, "tray_manager"):
+                    try:
+                        app.tray_manager.start(page)
+                    except Exception as err:
+                        logger.error(f"Failed to start tray manager: {err}")
 
         page.update()