feat: make Client::items optional behind feature flag (#18)

Flag is enabled by default

Author: ogios

Cargo.lock

@@ -9,7 +9,8 @@ categories = ["gui"]
 keywords = ["statusnotifieritem", "dbusmenu", "tokio", "tray"]
 
 [features]
-default = []
+default = ["data"]
+data = []
 dbusmenu-gtk3 = ["dep:gtk", "dep:dbusmenu-gtk3-sys"]
 
 [dependencies]
@@ -19,6 +20,7 @@ serde = { version = "1", features = ["derive"] }
 tokio = { version = "1", features = ["rt", "sync", "macros", "time"] }
 thiserror = "2.0"
 futures-lite = "2.6"
+cfg-if = "1.0.0"
 
 gtk = { version = "0.18.1", optional = true }
 dbusmenu-gtk3-sys = { version = "0.1.0", optional = true }

Cargo.toml

@@ -1,3 +1,4 @@
+use crate::data::TrayItemMap;
 use crate::dbus::dbus_menu_proxy::{DBusMenuProxy, PropertiesUpdate};
 use crate::dbus::notifier_item_proxy::StatusNotifierItemProxy;
 use crate::dbus::notifier_watcher_proxy::StatusNotifierWatcherProxy;
@@ -9,8 +10,6 @@ use crate::menu::{MenuDiff, TrayMenu};
 use crate::names;
 use dbus::DBusProps;
 use futures_lite::StreamExt;
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tokio::spawn;
 use tokio::sync::broadcast;
@@ -76,8 +75,6 @@ pub enum ActivateRequest {
     Secondary { address: String, x: i32, y: i32 },
 }
 
-type State = HashMap<String, (StatusNotifierItem, Option<TrayMenu>)>;
-
 const PROPERTIES_INTERFACE: &str = "org.kde.StatusNotifierItem";
 
 /// Client for watching the tray.
@@ -87,7 +84,8 @@ pub struct Client {
     _rx: broadcast::Receiver<Event>,
     connection: Connection,
 
-    items: Arc<Mutex<State>>,
+    #[cfg(feature = "data")]
+    items: TrayItemMap,
 }
 
 impl Client {
@@ -153,8 +151,7 @@ impl Client {
         watcher_proxy
             .register_status_notifier_host(&wellknown)
             .await?;
-
-        let items = Arc::new(Mutex::new(HashMap::new()));
+        let items = TrayItemMap::new();
 
         // handle new items
         {
@@ -229,11 +226,8 @@ impl Client {
                 while let Some(thing) = stream.next().await {
                     let body = thing.args()?;
                     if body.name == names::WATCHER_BUS {
-                        let mut items = items.lock().expect("mutex lock should succeed");
-                        let keys = items.keys().cloned().collect::<Vec<_>>();
-                        for address in keys {
-                            items.remove(&address);
-                            tx.send(Event::Remove(address))?;
+                        for dest in items.clear_items() {
+                            tx.send(Event::Remove(dest))?;
                         }
                     }
                 }
@@ -248,6 +242,7 @@ impl Client {
             connection,
             tx,
             _rx: rx,
+            #[cfg(feature = "data")]
             items,
         })
     }
@@ -258,7 +253,7 @@ impl Client {
         address: &str,
         connection: Connection,
         tx: broadcast::Sender<Event>,
-        items: Arc<Mutex<State>>,
+        items: TrayItemMap,
     ) -> crate::error::Result<()> {
         let (destination, path) = parse_address(address);
 
@@ -270,10 +265,7 @@ impl Client {
 
         let properties = Self::get_item_properties(destination, &path, &properties_proxy).await?;
 
-        items
-            .lock()
-            .expect("mutex lock should succeed")
-            .insert(destination.into(), (properties.clone(), None));
+        items.new_item(destination.into(), &properties);
 
         tx.send(Event::Add(
             destination.to_string(),
@@ -292,8 +284,8 @@ impl Client {
                     &path,
                     &connection,
                     properties_proxy,
-                    items,
                     tx,
+                    items,
                 )
                 .await?;
 
@@ -350,8 +342,8 @@ impl Client {
         path: &str,
         connection: &Connection,
         properties_proxy: PropertiesProxy<'_>,
-        items: Arc<Mutex<State>>,
         tx: broadcast::Sender<Event>,
+        items: TrayItemMap,
     ) -> crate::error::Result<()> {
         let notifier_item_proxy = StatusNotifierItemProxy::builder(connection)
             .destination(destination)?
@@ -395,7 +387,8 @@ impl Client {
                                 error!("{error:?}");
                             }
 
-                            items.lock().expect("mutex lock should succeed").remove(&destination.to_string());
+
+                            items.remove_item(destination);
 
                             tx.send(Event::Remove(destination.to_string()))?;
                             break Ok(());
@@ -469,7 +462,7 @@ impl Client {
         menu_path: &str,
         connection: &Connection,
         tx: broadcast::Sender<Event>,
-        items: Arc<Mutex<State>>,
+        items: TrayItemMap,
     ) -> crate::error::Result<()> {
         let dbus_menu_proxy = DBusMenuProxy::builder(connection)
             .destination(destination.as_str())?
@@ -480,15 +473,7 @@ impl Client {
         let menu = dbus_menu_proxy.get_layout(0, 10, &[]).await?;
         let menu = TrayMenu::try_from(menu)?;
 
-        if let Some((_, menu_cache)) = items
-            .lock()
-            .expect("mutex lock should succeed")
-            .get_mut(&destination)
-        {
-            menu_cache.replace(menu.clone());
-        } else {
-            error!("could not find item in state");
-        }
+        items.update_menu(&destination, &menu);
 
         tx.send(Event::Update(
             destination.to_string(),
@@ -522,15 +507,7 @@ impl Client {
 
                     let menu = TrayMenu::try_from(menu)?;
 
-                    if let Some((_, menu_cache)) = items
-                        .lock()
-                        .expect("mutex lock should succeed")
-                        .get_mut(&destination)
-                    {
-                        menu_cache.replace(menu.clone());
-                    } else {
-                        error!("could not find item in state");
-                    }
+                    items.update_menu(&destination, &menu);
 
                     debug!("sending new menu for '{destination}'");
                     trace!("new menu for '{destination}': {menu:?}");
@@ -592,9 +569,10 @@ impl Client {
     }
 
     /// Gets all current items, including their menus if present.
+    #[cfg(feature = "data")]
     #[must_use]
-    pub fn items(&self) -> Arc<Mutex<State>> {
-        self.items.clone()
+    pub fn items(&self) -> std::sync::Arc<std::sync::Mutex<crate::data::BaseMap>> {
+        self.items.get_map()
     }
 
     /// One should call this method with id=0 when opening the root menu.

src/client.rs

@@ -0,0 +1,71 @@
+use crate::{item::StatusNotifierItem, menu::TrayMenu};
+use std::sync::{Arc, Mutex};
+
+#[cfg(feature = "data")]
+pub type BaseMap = std::collections::HashMap<String, (StatusNotifierItem, Option<TrayMenu>)>;
+
+#[cfg(not(feature = "data"))]
+type BaseMap = std::collections::HashSet<String>;
+
+#[derive(Debug, Clone)]
+pub(crate) struct TrayItemMap {
+    inner: Arc<Mutex<BaseMap>>,
+}
+
+impl TrayItemMap {
+    pub(crate) fn new() -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(Default::default())),
+        }
+    }
+
+    #[cfg(feature = "data")]
+    pub(crate) fn get_map(&self) -> Arc<Mutex<BaseMap>> {
+        self.inner.clone()
+    }
+
+    pub(crate) fn new_item(&self, dest: String, item: &StatusNotifierItem) {
+        let mut lock = self.inner.lock().expect("mutex lock should succeed");
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "data")] {
+                lock.insert(dest, (item.clone(), None));
+            }else {
+                let _ = item;
+                lock.insert(dest);
+            }
+        }
+    }
+
+    pub(crate) fn remove_item(&self, dest: &str) {
+        self.inner
+            .lock()
+            .expect("mutex lock should succeed")
+            .remove(dest);
+    }
+
+    pub(crate) fn clear_items(&self) -> Vec<String> {
+        let mut lock = self.inner.lock().expect("mutex lock should succeed");
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "data")] {
+                lock.drain().map(|(k, _)| k).collect()
+            }else {
+                lock.drain().collect()
+            }
+        }
+    }
+
+    pub(crate) fn update_menu(&self, dest: &str, menu: &TrayMenu) {
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "data")] {
+                if let Some((_, menu_cache)) = self.inner.lock().unwrap().get_mut(dest) {
+                    menu_cache.replace(menu.clone());
+                } else {
+                    tracing::error!("could not find item in state");
+                }
+            }else {
+                let _ = menu;
+                let _ = dest;
+            }
+        }
+    }
+}

src/data.rs

@@ -25,6 +25,8 @@
 /// ```
 mod dbus;
 
+pub mod data;
+
 /// Client for listening to item and menu events,
 /// and associated types.
 pub mod client;