Merge pull request #375 from swetar-mecha/pre/status-bar

feat(status bar): service integration in UI

Author: akshayr-mecha

Cargo.toml

@@ -43,3 +43,6 @@ gpui = { git = "https://github.com/namana-mecha/zed.git", rev = "7a0d37756b35e60
     "linux-impeller",
 ] }
 rust-embed = "8.8.0"
+networkmanager = { path = "dbus/freedesktop/networkmanager" }
+bluez = { path = "dbus/freedesktop/bluez" }
+upower = { path = "dbus/freedesktop/upower" }

shell/crates/status_bar/Cargo.toml

@@ -11,8 +11,12 @@ categories.workspace = true
 keywords.workspace = true
 
 [dependencies]
+networkmanager = { workspace = true }
+bluez = { workspace = true }
+upower = { workspace = true }
+commons = { path = "../commons" }
 gpui = { workspace = true }
 rust-embed = { workspace = true }
 anyhow = { workspace = true }
-commons = { path = "../commons" }
-chrono = { version = "0.4", features = ["clock"] }
+chrono = { version = "0.4", features = ["clock"] }
+futures = "0.3.31"

shell/crates/status_bar/src/events/mod.rs

@@ -0,0 +1,12 @@
+use upower::interfaces::device::BatteryState;
+
+#[derive(Debug)]
+pub enum AppEvents {
+    WirelessStatusChanged { enabled: bool },
+    WirelessStrength { strength: u8 },
+    BluetoothEnabled { enabled: bool },
+    BluetoothConnectionStatus { connected: bool },
+    BatteryStateChanged { state: BatteryState },
+    BatteryLevelChanged { level: u8 },
+    TimeUpdated 
+}

shell/crates/status_bar/src/lib.rs

@@ -1,5 +1,8 @@
 mod ui;
+mod events;
+pub mod services;
 
 pub mod prelude {
-    pub use crate::ui::StatusBar;
-}
+    pub use crate::ui::{StatusBar, Icon, IconName};
+    pub use crate::events::AppEvents;
+}

shell/crates/status_bar/src/main.rs

@@ -1,6 +1,10 @@
 use commons::prelude::*;
+use futures::{StreamExt, channel::mpsc};
 use gpui::*;
 use status_bar::prelude::*;
+use status_bar::services::*;
+use std::time::Duration;
+use upower::interfaces::device::BatteryState;
 
 fn main() {
     let application = gpui::Application::new().with_assets(Assets {});
@@ -13,7 +17,98 @@ fn main() {
                 window_bounds: Some(window_bounds),
                 ..Default::default()
             },
-            |_window, cx| cx.new(|_cx| StatusBar::new()),
+            |_window, cx| {
+                let (app_channel_tx, mut app_channel_rx) = mpsc::channel::<AppEvents>(120);
+                let executor = cx.background_executor();
+
+                executor
+                    .spawn(sync_network_status(app_channel_tx.clone()))
+                    .detach();
+                executor
+                    .spawn(sync_network_strength(app_channel_tx.clone()))
+                    .detach();
+
+                executor
+                    .spawn(sync_bluetooth_status(app_channel_tx.clone()))
+                    .detach();
+                executor
+                    .spawn(sync_bluetooth_connected_status(app_channel_tx.clone()))
+                    .detach();
+
+                executor
+                    .spawn(sync_battery_state(app_channel_tx.clone()))
+                    .detach();
+                executor
+                    .spawn(sync_battery_level(app_channel_tx.clone()))
+                    .detach();
+
+                cx.new(|cx| {
+                    cx.spawn(async move |app, cx| {
+                        while let Some(event) = app_channel_rx.next().await {
+                            match event {
+                                AppEvents::WirelessStatusChanged { enabled } => {
+                                    let _ = app.update(cx, |this: &mut StatusBar, cx| {
+                                        this.wireless_enabled = enabled;
+                                        cx.notify();
+                                    });
+                                }
+                                AppEvents::WirelessStrength { strength } => {
+                                    let _ = app.update(cx, |this: &mut StatusBar, cx| {
+                                        this.wireless_strength = strength;
+                                        cx.notify();
+                                    });
+                                }
+                                AppEvents::BluetoothEnabled { enabled } => {
+                                    let _ = app.update(cx, |this: &mut StatusBar, cx| {
+                                        this.bluetooth_enabled = enabled;
+                                        cx.notify();
+                                    });
+                                }
+                                AppEvents::BluetoothConnectionStatus { connected } => {
+                                    let _ = app.update(cx, |this: &mut StatusBar, cx| {
+                                        this.bluetooth_connected = connected;
+                                        cx.notify();
+                                    });
+                                }
+                                AppEvents::BatteryStateChanged { state } => {
+                                    let _ = app.update(cx, |this: &mut StatusBar, cx| {
+                                        this.battery_state = match state {
+                                            BatteryState::Charging => BatteryState::Charging,
+                                            BatteryState::Discharging => BatteryState::Discharging,
+                                            _ => BatteryState::Unknown,
+                                        };
+                                        cx.notify();
+                                    });
+                                }
+                                AppEvents::BatteryLevelChanged { level } => {
+                                    let _ = app.update(cx, |this: &mut StatusBar, cx| {
+                                        this.battery_level = level;
+                                        cx.notify();
+                                    });
+                                }
+                                AppEvents::TimeUpdated => {
+                                    let _ = app.update(cx, |this: &mut StatusBar, cx| {
+                                        this.update_time(cx);
+                                    });
+                                }
+                            }
+                        }
+                    })
+                    .detach();
+
+                    cx.spawn(async move |app, cx| {
+                        loop {
+                            cx.background_executor().timer(Duration::from_secs(1)).await;
+                            let _ = app.update(cx, |this: &mut StatusBar, cx| {
+                                this.update_time(cx);
+                            });
+                        }
+                    })
+                    .detach();
+
+                    StatusBar::new()
+                })
+            },
         )
         .unwrap();
         cx.activate(true);

shell/crates/status_bar/src/services/battery_sync.rs

@@ -0,0 +1,37 @@
+use crate::events::AppEvents;
+use futures::{SinkExt, channel::mpsc};
+use upower::service::UPowerService;
+
+pub async fn sync_battery_level(mut tx: mpsc::Sender<AppEvents>) {
+    let upower_manager = match UPowerService::new().await {
+        Ok(upower_manager) => upower_manager,
+        Err(e) => {
+            eprintln!("Failed to create UpowerService: {}", e);
+            return;
+        }
+    };
+
+    let status_receiver = upower_manager.stream_device_percentage().await;
+
+    while let Ok(percentage) = status_receiver.recv() {
+          let level = percentage as u8;
+        let _ = tx.send(AppEvents::BatteryLevelChanged { level }).await;
+    }
+}
+
+pub async fn sync_battery_state(mut tx: mpsc::Sender<AppEvents>) {
+    let upower_manager = match UPowerService::new().await {
+        Ok(upower_manager) => upower_manager,
+        Err(e) => {
+            eprintln!("Failed to create UpowerService: {}", e);
+            return;
+        }
+    };
+
+    let status_receiver = upower_manager.stream_device_state().await;
+
+    while let Ok(state) = status_receiver.recv() {
+        let _ = tx.send(AppEvents::BatteryStateChanged { state }).await;
+    }
+
+}

shell/crates/status_bar/src/services/bluetooth_sync.rs

@@ -0,0 +1,42 @@
+use crate::events::AppEvents;
+use bluez::service::BluetoothService;
+use futures::{SinkExt, channel::mpsc};
+
+pub async fn sync_bluetooth_status(mut tx: mpsc::Sender<AppEvents>) {
+    let bluetooth_manager = match BluetoothService::new().await {
+        Ok(bluetooth_manager) => bluetooth_manager,
+        Err(e) => {
+            eprintln!("Failed to create BluetoothService: {}", e);
+            return;
+        }
+    };
+
+    let status_receiver = bluetooth_manager.stream_bluetooth_enabled_status().await;
+
+    while let Ok(enabled) = status_receiver.recv() {
+        let _ = tx.send(AppEvents::BluetoothEnabled { enabled }).await;
+    }
+}
+
+pub async fn sync_bluetooth_connected_status(mut tx: mpsc::Sender<AppEvents>) {
+    let bluetooth_manager = match BluetoothService::new().await {
+        Ok(bluetooth_manager) => bluetooth_manager,
+        Err(e) => {
+            eprintln!("Failed to create BluetoothService: {}", e);
+            return;
+        }
+    };
+
+    let connected_devices_count = match bluetooth_manager.get_connected_devices().await {
+        Ok(r) => r.len(),
+        Err(e) => {
+            eprintln!("Failed to get connected devices: {}", e);
+            return;
+        }
+    };
+    let connected = connected_devices_count > 0;
+
+    let _ = tx
+        .send(AppEvents::BluetoothConnectionStatus { connected })
+        .await;
+}

shell/crates/status_bar/src/services/mod.rs

@@ -0,0 +1,7 @@
+pub mod network_sync;
+pub mod bluetooth_sync;
+pub mod battery_sync;
+
+pub use network_sync::{sync_network_status, sync_network_strength};
+pub use bluetooth_sync::{sync_bluetooth_status, sync_bluetooth_connected_status};
+pub use battery_sync::{sync_battery_level, sync_battery_state};

shell/crates/status_bar/src/services/network_sync.rs

@@ -0,0 +1,37 @@
+use crate::events::AppEvents;
+use futures::{SinkExt, channel::mpsc};
+use networkmanager::service::NetworkManagerService;
+
+pub async fn sync_network_status(mut tx: mpsc::Sender<AppEvents>) {
+    let network_manager = match NetworkManagerService::new().await {
+        Ok(nm) => nm,
+        Err(e) => {
+            eprintln!("Failed to create NetworkManagerService: {}", e);
+            return;
+        }
+    };
+    let wireless_status_receiver = network_manager.stream_wireless_enabled_status().await;
+    while let Ok(is_wireless_enabled) = wireless_status_receiver.recv() {
+        let _ = tx
+            .send(AppEvents::WirelessStatusChanged {
+                enabled: is_wireless_enabled,
+            })
+            .await;
+    }
+}
+
+pub async fn sync_network_strength(mut tx: mpsc::Sender<AppEvents>) {
+    let network_manager = match NetworkManagerService::new().await {
+        Ok(nm) => nm,
+        Err(e) => {
+            eprintln!("Failed to create NetworkManagerService: {}", e);
+            return;
+        }
+    };
+
+    let strength_receiver = network_manager.stream_active_network_strength().await;
+
+    while let Ok(strength) = strength_receiver.recv() {
+        let _ = tx.send(AppEvents::WirelessStrength { strength }).await;
+    }
+}

shell/crates/status_bar/src/ui/icon.rs

@@ -1,7 +1,7 @@
 use gpui::{prelude::FluentBuilder, *};
 pub const STATUS_BAR_ICONS_DIR: &str = "icons/status-bar/";
 
-#[derive(IntoElement, Clone)]
+#[derive(IntoElement, Clone, Debug)]
 pub enum IconName {
     WirelessOn,
     WirelessOff,