perf: detect system theme off UI thread

Author: thepastaclaw

src/app.rs

@@ -70,32 +70,78 @@ struct ThemeState {
     preference: ThemeMode,
     resolved: ThemeMode,
     last_applied: Option<ThemeMode>,
-    last_checked: Instant,
+    last_checked: Option<Instant>,
+    detection_in_flight: bool,
+    detection_generation: u64,
+    detection_sender: mpsc::Sender<(u64, Option<ThemeMode>)>,
+    detection_receiver: mpsc::Receiver<(u64, Option<ThemeMode>)>,
 }
 
 impl ThemeState {
     fn new(preference: ThemeMode) -> Self {
+        let (detection_sender, detection_receiver) = mpsc::channel();
         Self {
             resolved: crate::ui::theme::resolve_theme_mode(preference),
             last_applied: None,
-            last_checked: Instant::now(),
+            last_checked: Some(Instant::now()),
+            detection_in_flight: false,
+            detection_generation: 0,
+            detection_sender,
+            detection_receiver,
             preference,
         }
     }
 
-    /// Polls the OS for system theme changes (throttled to every 2s) and
-    /// applies the theme if it changed. Returns `true` if the theme was applied.
+    fn drain_detection_results(&mut self) {
+        while let Ok((generation, detected)) = self.detection_receiver.try_recv() {
+            if generation != self.detection_generation {
+                continue;
+            }
+
+            self.detection_in_flight = false;
+            if self.preference != ThemeMode::System {
+                continue;
+            }
+            if let Some(detected) = detected
+                && detected != self.resolved
+            {
+                self.resolved = detected;
+            }
+        }
+    }
+
+    fn request_system_detection(&mut self, ctx: &egui::Context, now: Instant) {
+        if self.detection_in_flight {
+            return;
+        }
+        if self
+            .last_checked
+            .is_some_and(|last_checked| now.duration_since(last_checked) < Duration::from_secs(2))
+        {
+            return;
+        }
+
+        self.last_checked = Some(now);
+        self.detection_in_flight = true;
+        let sender = self.detection_sender.clone();
+        let generation = self.detection_generation;
+        let ctx = ctx.clone();
+        tokio::task::spawn_blocking(move || {
+            let detected = crate::ui::theme::try_detect_system_theme();
+            if sender.send((generation, detected)).is_err() {
+                tracing::debug!("Dropping OS theme detection result because receiver closed");
+            }
+            ctx.request_repaint();
+        });
+    }
+
+    /// Polls asynchronously for OS theme changes (throttled to every 2s) and
+    /// applies the latest detected theme if it changed. Returns `true` if the
+    /// theme was applied.
     fn poll_and_apply(&mut self, ctx: &egui::Context) -> bool {
+        self.drain_detection_results();
         if self.preference == ThemeMode::System {
-            let now = Instant::now();
-            if now.duration_since(self.last_checked) >= Duration::from_secs(2) {
-                self.last_checked = now;
-                if let Some(detected) = crate::ui::theme::try_detect_system_theme()
-                    && detected != self.resolved
-                {
-                    self.resolved = detected;
-                }
-            }
+            self.request_system_detection(ctx, Instant::now());
         }
         if self.last_applied != Some(self.resolved) {
             crate::ui::theme::apply_theme(ctx, self.resolved);
@@ -108,6 +154,9 @@ impl ThemeState {
 
     fn apply_new_preference(&mut self, ctx: &egui::Context, new_theme: ThemeMode) -> bool {
         self.preference = new_theme;
+        self.detection_generation = self.detection_generation.wrapping_add(1);
+        self.detection_in_flight = false;
+        let now = Instant::now();
         let mut detection_failed = false;
         self.resolved = if new_theme == ThemeMode::System {
             match crate::ui::theme::try_detect_system_theme() {
@@ -120,7 +169,7 @@ impl ThemeState {
         } else {
             new_theme
         };
-        self.last_checked = Instant::now();
+        self.last_checked = Some(now);
         crate::ui::theme::apply_theme(ctx, self.resolved);
         self.last_applied = Some(self.resolved);
         detection_failed