Better notification caching system

modules/notification/notification_center.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+import time
 
 from fabric.widgets.box import Box
 from fabric.widgets.button import Button
@@ -13,6 +14,11 @@ from loguru import logger
 from modules.notification.notification import (
     NotificationWidget,
     cache_notification_icon,
+    cache_notification_image,
+    get_cached_notification_image,
+    get_notification_image_cache_key,
+    find_existing_cached_image,
+    preload_notification_assets,
     cleanup_all_notification_caches,
     cleanup_notification_specific_caches,
     get_fallback_notification_icon,
@@ -302,24 +308,61 @@ class ExpandableNotificationGroup(Box):
         self.expanded_container.set_visible(False)
 
     def _get_notification_pixbuf(self, notification):
-        # Use the same logic as NotificationWidget
+        """Use cached-first approach prioritizing existing cache over pixbuf processing"""
+        notification_id = getattr(notification, "id", None)
+        
+        # Priority 1: ALWAYS check for existing cached image first (critical for restart scenarios)
+        if notification_id:
+            existing_cached_image = find_existing_cached_image(notification_id)
+            if existing_cached_image:
+                logger.debug(f"Using existing cached image in center for notification: {notification_id}")
+                return existing_cached_image
+        
         try:
-            if hasattr(notification, "image_pixbuf") and notification.image_pixbuf:
-                return notification.image_pixbuf.scale_simple(
-                    35, 35, 2
-                )  # GdkPixbuf.InterpType.BILINEAR = 2
-        except Exception:
-            pass
+            # Priority 2: Try to process current pixbuf only if we have no cached version
+            if hasattr(notification, "image_pixbuf") and notification.image_pixbuf and notification_id:
+                try:
+                    cache_key = get_notification_image_cache_key(notification_id, notification.image_pixbuf)
+                    cached_image = get_cached_notification_image(cache_key)
+                    if cached_image:
+                        logger.debug(f"Using cached notification image in center: {cache_key}")
+                        return cached_image
+                    
+                    # Try to cache the image now
+                    cache_path, cache_key = cache_notification_image(
+                        notification_id, notification.image_pixbuf, (35, 35)
+                    )
+                    if cache_path and cache_key:
+                        cached_image = get_cached_notification_image(cache_key)
+                        if cached_image:
+                            logger.debug(f"Cached and using notification image in center: {cache_key}")
+                            return cached_image
 
-        # Fallback to app icon
+                    # Direct scaling fallback if caching works but loading fails
+                    logger.debug("Using direct scaling for notification image in center")
+                    return notification.image_pixbuf.scale_simple(35, 35, 2)  # GdkPixbuf.InterpType.BILINEAR = 2
+                    
+                except Exception as image_error:
+                    logger.debug(f"Notification image processing failed in center (temp file likely gone): {image_error}")
+                    # Continue to app icon fallback
+                    
+        except Exception as e:
+            logger.debug(f"Failed to process notification image in center: {e}")
+
+        # Priority 3: Use cached app icon with optimized cache-first approach
         try:
-            cached_app_icon = cache_notification_icon(notification.app_icon, (35, 35))
-            if cached_app_icon:
-                return cached_app_icon
-        except Exception:
-            pass
+            # Use optimized caching for app icon
+            app_icon_source = getattr(notification, "app_icon", None)
+            if app_icon_source:
+                cached_app_icon = cache_notification_icon(app_icon_source, (35, 35))
+                if cached_app_icon:
+                    logger.debug(f"Using cached app icon in center for: {app_icon_source}")
+                    return cached_app_icon
+        except Exception as e:
+            logger.debug(f"Failed to get cached app icon in center: {e}")
 
-        # Ultimate fallback
+        # Priority 4: Ultimate fallback with caching
+        logger.debug("Using fallback notification icon in center")
         return get_fallback_notification_icon((35, 35))
 
     def on_clicked(self, widget, event):
@@ -635,7 +678,7 @@ class NotificationCenter(Window):
         self.connect("destroy", self._on_destroy)
 
     def _rebuild_notification_groups(self):
-        """Rebuild notification groups from scratch"""
+        """Rebuild notification groups from scratch with enhanced asset preloading and debugging"""
         # Clear existing groups
         self.notification_groups.clear()
         self.group_widgets.clear()
@@ -644,10 +687,29 @@ class NotificationCenter(Window):
         for child in self.notifications_box.get_children():
             child.destroy()
 
-        # Group notifications by app name
+        # Group notifications by app name and preload assets with debugging
+        rebuild_count = 0
         for cached_notification in notification_service.cached_notifications:
             app_name = cached_notification._notification.app_name
+            notification_id = getattr(cached_notification._notification, "id", None)
+            
+            logger.debug(f"Rebuilding notification for {app_name} with ID: {notification_id}")
+            
+            # Preload assets for each cached notification to ensure display consistency
+            preload_notification_assets(cached_notification._notification)
+            
+            # Check if we can find cached images for this notification
+            if notification_id:
+                existing_image = find_existing_cached_image(notification_id)
+                if existing_image:
+                    logger.debug(f"✓ Found cached image for notification {notification_id} during rebuild")
+                else:
+                    logger.debug(f"✗ No cached image found for notification {notification_id} during rebuild")
+            
             self.notification_groups[app_name].append(cached_notification)
+            rebuild_count += 1
+
+        logger.info(f"Rebuilt {rebuild_count} notifications into {len(self.notification_groups)} groups")
 
         # Create group widgets
         for app_name, notifications in self.notification_groups.items():
@@ -662,6 +724,9 @@ class NotificationCenter(Window):
         try:
             app_name = cached_notification._notification.app_name
 
+            # Preload assets for notification center display (ensure caching consistency)
+            preload_notification_assets(cached_notification._notification)
+
             # Add to groups
             self.notification_groups[app_name].insert(
                 0, cached_notification