Streams 🌊

- Switched notify implementation to use streams.

Author: edfloreshz

Cargo.toml

@@ -10,8 +10,8 @@ readme = "README.md"
 build = "build.rs"
 
 [dependencies]
-anyhow = "1.0.52"
-tokio = "1.23.0"
+futures = "0.3.30"
+anyhow = "1.0.79"
 
 [dev-dependencies]
 tokio = { version = "1.23.0", features = ["full"] }

examples/notify.rs

@@ -1,10 +1,15 @@
-use dark_light::ThemeWatcher;
+use dark_light::{subscribe, Event};
+use futures::StreamExt;
 
 #[tokio::main]
-async fn main() {
-    let mut receiver = ThemeWatcher::new().lock().await.subscribe();
+async fn main() -> anyhow::Result<()> {
+    let mut stream = subscribe().await?;
 
-    while let Ok(mode) = receiver.recv().await {
-        println!("New mode: {:?}", mode);
+    while let Some(event) = stream.next().await {
+        if let Event::ThemeChanged(mode) = event {
+            println!("System theme changed: {:?}", mode);
+        }
     }
+
+    Ok(())
 }

src/lib.rs

@@ -1,75 +1,73 @@
-//! Detect if dark mode or light mode is enabled.
-//!
-//! # Examples
-//!
-//! ```
-//! let mode = dark_light::detect();
-//!
-//! match mode {
-//!     // Dark mode
-//!     dark_light::Mode::Dark => {},
-//!     // Light mode
-//!     dark_light::Mode::Light => {},
-//!     // Unspecified
-//!     dark_light::Mode::Default => {},
-//! }
-//! ```
-
-mod platforms;
-use platforms::platform;
-
-mod utils;
-#[cfg(any(
-    target_os = "linux",
-    target_os = "freebsd",
-    target_os = "dragonfly",
-    target_os = "netbsd",
-    target_os = "openbsd"
-))]
-use utils::rgb::Rgb;
-
-/// Enum representing dark mode, light mode, or unspecified.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum Mode {
-    /// Dark mode
-    Dark,
-    /// Light mode
-    Light,
-    /// Unspecified
-    Default,
-}
-
-impl Mode {
-    /// Convert a boolean to [`Mode`]. `true` is [`Mode::Dark`], `false` is [`Mode::Light`].
-    fn from(mode: bool) -> Self {
-        if mode {
-            Mode::Dark
-        } else {
-            Mode::Light
-        }
-    }
-
-    #[cfg(any(
-        target_os = "linux",
-        target_os = "freebsd",
-        target_os = "dragonfly",
-        target_os = "netbsd",
-        target_os = "openbsd"
-    ))]
-    /// Convert an RGB color to [`Mode`]. The color is converted to grayscale, and if the grayscale value is less than 192, [`Mode::Dark`] is returned. Otherwise, [`Mode::Light`] is returned.
-    fn from_rgb(rgb: Rgb) -> Self {
-        let window_background_gray = (rgb.0 * 11 + rgb.1 * 16 + rgb.2 * 5) / 32;
-        if window_background_gray < 192 {
-            Self::Dark
-        } else {
-            Self::Light
-        }
-    }
-}
-
-pub use platform::notify::ThemeWatcher;
-
-/// Detect if light mode or dark mode is enabled. If the mode can’t be detected, fall back to [`Mode::Default`].
-pub fn detect() -> Mode {
-    platform::detect::detect()
-}
+//! Detect if dark mode or light mode is enabled.
+//!
+//! # Examples
+//!
+//! ```
+//! let mode = dark_light::detect();
+//!
+//! match mode {
+//!     // Dark mode
+//!     dark_light::Mode::Dark => {},
+//!     // Light mode
+//!     dark_light::Mode::Light => {},
+//!     // Unspecified
+//!     dark_light::Mode::Default => {},
+//! }
+//! ```
+
+mod platforms;
+use platforms::platform;
+
+mod utils;
+#[cfg(any(
+    target_os = "linux",
+    target_os = "freebsd",
+    target_os = "dragonfly",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+use utils::rgb::Rgb;
+
+/// Enum representing dark mode, light mode, or unspecified.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum Mode {
+    /// Dark mode
+    Dark,
+    /// Light mode
+    Light,
+    /// Unspecified
+    Default,
+}
+
+impl Mode {
+    fn from_bool(b: bool) -> Self {
+        if b {
+            Mode::Dark
+        } else {
+            Mode::Light
+        }
+    }
+
+    #[cfg(any(
+        target_os = "linux",
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    /// Convert an RGB color to [`Mode`]. The color is converted to grayscale, and if the grayscale value is less than 192, [`Mode::Dark`] is returned. Otherwise, [`Mode::Light`] is returned.
+    fn from_rgb(rgb: Rgb) -> Self {
+        let window_background_gray = (rgb.0 * 11 + rgb.1 * 16 + rgb.2 * 5) / 32;
+        if window_background_gray < 192 {
+            Self::Dark
+        } else {
+            Self::Light
+        }
+    }
+}
+
+/// Detect if light mode or dark mode is enabled. If the mode can’t be detected, fall back to [`Mode::Default`].
+pub use platform::detect::detect;
+/// Notifies the user if the system theme has been changed.
+pub use platform::notify::subscribe;
+pub use platforms::Event;

src/platforms/freedesktop/mod.rs

@@ -1,36 +1,52 @@
-use std::str::FromStr;
-
-use anyhow::Context;
-use ini::Ini;
-
-use crate::{utils::rgb::Rgb, Mode};
-
-pub mod detect;
-pub mod notify;
-
-const MATE: &str = "/org/mate/desktop/interface/gtk-theme";
-const GNOME: &str = "/org/gnome/desktop/interface/gtk-theme";
-const CINNAMON: &str = "/org/cinnamon/desktop/interface/gtk-theme";
-
-fn dconf_detect(path: &str) -> Mode {
-    match dconf_rs::get_string(path) {
-        Ok(theme) => Mode::from(theme.to_lowercase().contains("dark")),
-        Err(_) => Mode::Default,
-    }
-}
-
-fn kde_detect() -> anyhow::Result<Mode> {
-    let xdg = xdg::BaseDirectories::new()?;
-    let path = xdg
-        .find_config_file("kdeglobals")
-        .context("Path not found")?;
-    let cfg = Ini::load_from_file(path)?;
-    let properties = cfg
-        .section(Some("Colors:Window"))
-        .context("Failed to get section Colors:Window")?;
-    let background = properties
-        .get("BackgroundNormal")
-        .context("Failed to get BackgroundNormal inside Colors:Window")?;
-    let rgb = Rgb::from_str(background)?;
-    Ok(Mode::from_rgb(rgb))
-}
+use std::str::FromStr;
+
+use anyhow::Context;
+use ini::Ini;
+
+use crate::{utils::rgb::Rgb, Mode};
+
+pub mod detect;
+pub mod notify;
+
+const MATE: &str = "/org/mate/desktop/interface/gtk-theme";
+const GNOME: &str = "/org/gnome/desktop/interface/gtk-theme";
+const CINNAMON: &str = "/org/cinnamon/desktop/interface/gtk-theme";
+
+fn dconf_detect(path: &str) -> Mode {
+    match dconf_rs::get_string(path) {
+        Ok(theme) => {
+            if theme.to_lowercase().contains("dark") {
+                Mode::Dark
+            } else {
+                Mode::Light
+            }
+        }
+        Err(_) => Mode::Default,
+    }
+}
+
+fn kde_detect() -> anyhow::Result<Mode> {
+    let xdg = xdg::BaseDirectories::new()?;
+    let path = xdg
+        .find_config_file("kdeglobals")
+        .context("Path not found")?;
+    let cfg = Ini::load_from_file(path)?;
+    let properties = cfg
+        .section(Some("Colors:Window"))
+        .context("Failed to get section Colors:Window")?;
+    let background = properties
+        .get("BackgroundNormal")
+        .context("Failed to get BackgroundNormal inside Colors:Window")?;
+    let rgb = Rgb::from_str(background).unwrap();
+    Ok(Mode::from_rgb(rgb))
+}
+
+impl From<ashpd::desktop::settings::ColorScheme> for Mode {
+    fn from(value: ashpd::desktop::settings::ColorScheme) -> Self {
+        match value {
+            ashpd::desktop::settings::ColorScheme::NoPreference => Mode::Default,
+            ashpd::desktop::settings::ColorScheme::PreferDark => Mode::Dark,
+            ashpd::desktop::settings::ColorScheme::PreferLight => Mode::Light,
+        }
+    }
+}

src/platforms/freedesktop/notify.rs

@@ -1,83 +1,35 @@
-use std::sync::Arc;
-
-use tokio::sync::{broadcast, Mutex};
-
 use ashpd::desktop::settings::{ColorScheme, Settings};
-use zbus::export::futures_util::StreamExt;
-
-use crate::{detect, Mode};
-
-pub struct ThemeWatcher {
-    sender: broadcast::Sender<Mode>,
-    current_mode: Mutex<Mode>,
-}
-
-/// Theme watcher implementation for subscriptions.
-impl ThemeWatcher {
-    pub fn new() -> Arc<Mutex<Self>> {
-        let (sender, _) = broadcast::channel::<Mode>(256);
-
-        let theme_watcher = ThemeWatcher {
-            sender,
-            current_mode: Mutex::new(detect()),
-        };
-
-        let arc_watcher = Arc::new(Mutex::new(theme_watcher));
-
-        tokio::spawn({
-            let arc_watcher = Arc::clone(&arc_watcher);
-            async move {
-                arc_watcher.lock().await.monitor_theme_changes().await;
+use futures::{stream, Stream, StreamExt};
+use std::task::Poll;
+
+use crate::{detect, platforms::Event, Mode};
+
+pub async fn subscribe() -> anyhow::Result<impl Stream<Item = Event<Mode>> + Send> {
+    let mut last_mode = detect();
+
+    let stream = if get_freedesktop_color_scheme().await.is_ok() {
+        let proxy = Settings::new().await?;
+        proxy
+            .receive_color_scheme_changed()
+            .await?
+            .map(Mode::from)
+            .map(|mode| Event::ThemeChanged(mode))
+            .boxed()
+    } else {
+        stream::poll_fn(move |_| -> Poll<Option<Event<Mode>>> {
+            let current_mode = detect();
+
+            if current_mode != last_mode {
+                last_mode = current_mode;
+                Poll::Ready(Some(Event::ThemeChanged(current_mode)))
+            } else {
+                Poll::Ready(Some(Event::Waiting))
             }
-        });
-
-        arc_watcher
-    }
-
-    /// Method to get the current theme mode
-    pub async fn get_current_mode(&self) -> Mode {
-        let current_mode = self.current_mode.lock().await;
-        current_mode.clone()
-    }
-
-    /// Method to subscribe to theme change events
-    pub fn subscribe(&self) -> broadcast::Receiver<Mode> {
-        self.sender.subscribe()
-    }
-
-    /// The asynchronous method to monitor theme changes
-    async fn monitor_theme_changes(&self) {
-        if get_freedesktop_color_scheme().await.is_ok() {
-            let proxy = Settings::new().await.unwrap();
-            if let Ok(mut color_scheme) = proxy.receive_color_scheme_changed().await {
-                while let Some(color_scheme) = color_scheme.next().await {
-                    // Compare the current value with the stored value
-                    let mut current_mode = self.current_mode.lock().await;
-
-                    let mode = match color_scheme {
-                        ColorScheme::NoPreference => Mode::Default,
-                        ColorScheme::PreferDark => Mode::Dark,
-                        ColorScheme::PreferLight => Mode::Light,
-                    };
+        })
+        .boxed()
+    };
 
-                    if *current_mode != mode {
-                        *current_mode = mode;
-                        let _ = self.sender.send(current_mode.clone());
-                    }
-                }
-            }
-        } else {
-            eprintln!("Unable to start freedesktop proxy, falling back to legacy...");
-            loop {
-                let mut current_mode = self.current_mode.lock().await;
-                let new_mode = detect();
-                if *current_mode != new_mode {
-                    *current_mode = new_mode;
-                    let _ = self.sender.send(current_mode.clone());
-                }
-            }
-        }
-    }
+    Ok(stream)
 }
 
 async fn get_freedesktop_color_scheme() -> anyhow::Result<Mode> {

src/platforms/macos/detect.rs

@@ -52,5 +52,5 @@ fn is_dark_mode_enabled() -> bool {
 }
 
 pub fn detect() -> crate::Mode {
-    Mode::from(is_dark_mode_enabled())
+    Mode::from_bool(is_dark_mode_enabled())
 }