Merge pull request #382 from swetar-mecha/pre-r/settings-drawer

Fix(settings drawer): Wifi and Bluetooth status; Add swipe to open settings drawer

Author: akshayr-mecha

Cargo.toml

@@ -46,3 +46,4 @@ rust-embed = "8.8.0"
 networkmanager = { path = "dbus/freedesktop/networkmanager" }
 bluez = { path = "dbus/freedesktop/bluez" }
 upower = { path = "dbus/freedesktop/upower" }
+pulseaudio = { path = "dbus/freedesktop/pulseaudio" }

shell/crates/running_apps/src/ui/mod.rs

@@ -815,4 +815,4 @@ impl RunningApps {
                 btn
             }))
     }
-}
+}

shell/crates/settings_drawer/Cargo.toml

@@ -13,6 +13,7 @@ keywords.workspace = true
 [dependencies]
 networkmanager = { workspace = true }
 bluez = { workspace = true }
+pulseaudio = { workspace = true }
 commons = { path = "../commons" }
 gpui = { workspace = true }
 rust-embed = { workspace = true }

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

@@ -1,13 +1,26 @@
 use networkmanager::interfaces::wireless::WirelessNetworkInfo;
+use pulseaudio::service::DeviceInfo;
 
 #[derive(Debug)]
 pub enum AppEvents {
-    WirelessStatusChanged { enabled: bool },
-    WirelessStrength { strength: u8 },
-    ConnectedNetwork { network: Option<WirelessNetworkInfo> },
-    BluetoothEnabled { enabled: bool },
-    BluetoothDevices { count: u8 },
-
+    WirelessStatusChanged {
+        enabled: bool,
+    },
+    WirelessStrength {
+        strength: u8,
+    },
+    ConnectedNetwork {
+        network: Option<WirelessNetworkInfo>,
+    },
+    BluetoothEnabled {
+        enabled: bool,
+    },
+    BluetoothDevices {
+        count: u8,
+    },
+    OutputSoundDevice {
+        device_info: DeviceInfo,
+    },
 }
 
 #[derive(Debug)]
@@ -18,4 +31,4 @@ pub enum NmEvents {
 #[derive(Debug)]
 pub enum BtEvents {
     BluetoothToggle { enabled: bool },
-}
+}

shell/crates/settings_drawer/src/main.rs

@@ -5,7 +5,6 @@ use gpui::*;
 use settings_drawer::prelude::*;
 use settings_drawer::services::*;
 
-
 fn main() {
     let application = gpui::Application::new().with_assets(Assets {});
     application.run(|cx| {
@@ -30,21 +29,25 @@ fn main() {
                     .spawn(sync_network_strength(app_channel_tx.clone()))
                     .detach();
                 executor
-                    .spawn(sync_connected_network(app_channel_tx.clone()))
+                    .spawn(stream_network_device_events(app_channel_tx.clone()))
                     .detach();
-                 executor
-                    .spawn(handle_wireless_toggle(nm_rx))
+
+                executor
+                    .spawn(sync_connected_network(app_channel_tx.clone()))
                     .detach();
+                executor.spawn(handle_wireless_toggle(nm_rx)).detach();
 
                 executor
                     .spawn(sync_bluetooth_status(app_channel_tx.clone()))
                     .detach();
+                executor.spawn(stream_bluetooth_device_status(app_channel_tx.clone())).detach();
                 executor
                     .spawn(sync_bluetooth_connected_status(app_channel_tx.clone()))
                     .detach();
-                   executor
-                    .spawn(handle_bluetooth_toggle(bt_rx))
-                    .detach();
+                // executor
+                //     .spawn(get_sound_device(app_channel_tx.clone()))
+                //     .detach();
+                executor.spawn(handle_bluetooth_toggle(bt_rx)).detach();
 
                 cx.new(|cx| {
                     cx.spawn(async move |app, cx| {
@@ -80,6 +83,12 @@ fn main() {
                                         cx.notify();
                                     });
                                 }
+                                AppEvents::OutputSoundDevice { device_info } => {
+                                    let _ = app.update(cx, |this: &mut SettingsDrawer, cx| {
+                                        this.sound_device = Some(device_info);
+                                        cx.notify();
+                                    });
+                                }
                             }
                         }
                     })

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

@@ -18,6 +18,22 @@ pub async fn sync_bluetooth_status(mut tx: mpsc::Sender<AppEvents>) {
     }
 }
 
+pub async fn stream_bluetooth_device_status(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_device_status().await;
+
+    while let Ok(_) = status_receiver.recv() {
+        sync_bluetooth_connected_status(tx.clone()).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,

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

@@ -1,9 +1,12 @@
 pub mod bluetooth_sync;
 pub mod network_sync;
+pub mod sound;
 
 pub use bluetooth_sync::{
-    handle_bluetooth_toggle, sync_bluetooth_connected_status, sync_bluetooth_status,
+    handle_bluetooth_toggle, stream_bluetooth_device_status, sync_bluetooth_connected_status,
+    sync_bluetooth_status,
 };
 pub use network_sync::{
-    handle_wireless_toggle, sync_connected_network, sync_network_status, sync_network_strength,
+    handle_wireless_toggle, stream_network_device_events, sync_connected_network, sync_network_status,
+    sync_network_strength,
 };

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

@@ -1,6 +1,6 @@
 use crate::events::{AppEvents, NmEvents};
 use futures::{SinkExt, StreamExt, channel::mpsc, select};
-use networkmanager::service::NetworkManagerService;
+use networkmanager::{interfaces::wireless::NMState, service::NetworkManagerService};
 
 pub async fn sync_network_status(mut tx: mpsc::Sender<AppEvents>) {
     let network_manager = match NetworkManagerService::new().await {
@@ -20,6 +20,25 @@ pub async fn sync_network_status(mut tx: mpsc::Sender<AppEvents>) {
     }
 }
 
+pub async fn stream_network_device_events(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_device_events().await;
+    while let Ok(nm_state) = wireless_status_receiver.recv() {
+        match nm_state {
+            NMState::ConnectedGlobal => {
+                let _ = sync_connected_network(tx.clone()).await;
+            }
+            _ => {}
+        }
+    }
+}
+
 pub async fn sync_network_strength(mut tx: mpsc::Sender<AppEvents>) {
     let network_manager = match NetworkManagerService::new().await {
         Ok(nm) => nm,
@@ -62,7 +81,7 @@ pub async fn sync_connected_network(mut tx: mpsc::Sender<AppEvents>) {
 }
 
 pub async fn handle_wireless_toggle(mut nm_rx: mpsc::Receiver<NmEvents>) {
-     let network_manager = match NetworkManagerService::new().await {
+    let network_manager = match NetworkManagerService::new().await {
         Ok(nm) => nm,
         Err(e) => {
             eprintln!("Failed to create NetworkManagerService: {}", e);