linux-rust: add listening mode picker for airpods

Author: kavishdevar

linux-rust/src/devices/airpods.rs

@@ -1,6 +1,6 @@
 use crate::bluetooth::aacp::{AACPManager, ProximityKeyType, AACPEvent, AirPodsLEKeys};
 use crate::bluetooth::aacp::ControlCommandIdentifiers;
-// use crate::bluetooth::att::ATTManager;
+use crate::bluetooth::att::ATTManager;
 use crate::media_controller::MediaController;
 use bluer::Address;
 use log::{debug, info, error};

linux-rust/src/devices/enums.rs

@@ -1,4 +1,5 @@
 use std::fmt::Display;
+use iced::widget::{combo_box, ComboBox};
 use serde::{Deserialize, Serialize};
 use crate::devices::airpods::AirPodsInformation;
 use crate::devices::nothing::NothingInformation;
@@ -53,8 +54,50 @@ impl Display for DeviceState {
 #[derive(Clone, Debug)]
 pub struct AirPodsState {
     pub device_name: String,
+    pub noise_control_mode: AirPodsNoiseControlMode,
+    pub noise_control_state: combo_box::State<AirPodsNoiseControlMode>,
     pub conversation_awareness_enabled: bool,
     pub personalized_volume_enabled: bool,
+    pub allow_off_mode: bool
+}
+
+#[derive(Clone, Debug)]
+pub enum AirPodsNoiseControlMode {
+    Off,
+    NoiseCancellation,
+    Transparency,
+    Adaptive
+}
+
+impl Display for AirPodsNoiseControlMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AirPodsNoiseControlMode::Off => write!(f, "Off"),
+            AirPodsNoiseControlMode::NoiseCancellation => write!(f, "Noise Cancellation"),
+            AirPodsNoiseControlMode::Transparency => write!(f, "Transparency"),
+            AirPodsNoiseControlMode::Adaptive => write!(f, "Adaptive"),
+        }
+    }
+}
+
+impl AirPodsNoiseControlMode {
+    pub fn from_byte(value: &u8) -> Self {
+        match value {
+            0x01 => AirPodsNoiseControlMode::Off,
+            0x02 => AirPodsNoiseControlMode::NoiseCancellation,
+            0x03 => AirPodsNoiseControlMode::Transparency,
+            0x04 => AirPodsNoiseControlMode::Adaptive,
+            _ => AirPodsNoiseControlMode::Off,
+        }
+    }
+    pub fn to_byte(&self) -> u8 {
+        match self {
+            AirPodsNoiseControlMode::Off => 0x01,
+            AirPodsNoiseControlMode::NoiseCancellation => 0x02,
+            AirPodsNoiseControlMode::Transparency => 0x03,
+            AirPodsNoiseControlMode::Adaptive => 0x04,
+        }
+    }
 }
 
 #[derive(Clone, Debug)]

linux-rust/src/main.rs

@@ -123,18 +123,17 @@ async fn async_main(
         Ok(device) => {
             let name = device.name().await?.unwrap_or_else(|| "Unknown".to_string());
             info!("Found connected AirPods: {}, initializing.", name);
-            let ui_tx_clone = ui_tx.clone();
-            ui_tx_clone.send(BluetoothUIMessage::DeviceConnected(device.address().to_string())).unwrap();
-            let airpods_device = AirPodsDevice::new(device.address(), tray_handle.clone(), ui_tx_clone).await;
+            let airpods_device = AirPodsDevice::new(device.address(), tray_handle.clone(), ui_tx.clone()).await;
 
             let mut managers = device_managers.write().await;
+            // let dev_managers = DeviceManagers::with_both(airpods_device.aacp_manager.clone(), airpods_device.att_manager.clone());
             let dev_managers = DeviceManagers::with_aacp(airpods_device.aacp_manager.clone());
             managers
                 .entry(device.address().to_string())
                 .or_insert(dev_managers)
-                .set_aacp(airpods_device.aacp_manager)
-            ;
-            drop(managers)
+                .set_aacp(airpods_device.aacp_manager);
+            drop(managers);
+            ui_tx.send(BluetoothUIMessage::DeviceConnected(device.address().to_string())).unwrap();
         }
         Err(_) => {
             info!("No connected AirPods found.");
@@ -150,16 +149,16 @@ async fn async_main(
                 let ui_tx_clone = ui_tx.clone();
                 let device_managers = device_managers.clone();
                 tokio::spawn(async move {
-                    ui_tx_clone.send(BluetoothUIMessage::DeviceConnected(addr_str.clone())).unwrap();
                     let mut managers = device_managers.write().await;
                     match type_ {
                         devices::enums::DeviceType::Nothing => {
-                            let dev = devices::nothing::NothingDevice::new(device.address(), ui_tx_clone).await;
+                            let dev = devices::nothing::NothingDevice::new(device.address(), ui_tx_clone.clone()).await;
                             let dev_managers = DeviceManagers::with_att(dev.att_manager.clone());
                             managers
-                                .entry(addr_str)
+                                .entry(addr_str.clone())
                                 .or_insert(dev_managers)
                                 .set_att(dev.att_manager);
+                            ui_tx_clone.send(BluetoothUIMessage::DeviceConnected(addr_str)).unwrap();
                         }
                         _ => {}
                     }
@@ -212,14 +211,14 @@ async fn async_main(
                     let device_managers = device_managers.clone();
                     tokio::spawn(async move {
                         let mut managers = device_managers.write().await;
-                        ui_tx_clone.send(BluetoothUIMessage::DeviceConnected(addr_str.clone())).unwrap();
-                        let dev = devices::nothing::NothingDevice::new(addr, ui_tx_clone).await;
+                        let dev = devices::nothing::NothingDevice::new(addr, ui_tx_clone.clone()).await;
                         let dev_managers = DeviceManagers::with_att(dev.att_manager.clone());
                         managers
-                            .entry(addr_str)
+                            .entry(addr_str.clone())
                             .or_insert(dev_managers)
                             .set_att(dev.att_manager);
                         drop(managers);
+                        ui_tx_clone.send(BluetoothUIMessage::DeviceConnected(addr_str.clone())).unwrap();
                     });
                 }
                 _ => {}
@@ -236,15 +235,16 @@ async fn async_main(
         let ui_tx_clone = ui_tx.clone();
         let device_managers = device_managers.clone();
         tokio::spawn(async move {
-            ui_tx_clone.send(BluetoothUIMessage::DeviceConnected(addr_str.clone())).unwrap();
-            let airpods_device = AirPodsDevice::new(addr, handle_clone, ui_tx_clone).await;
+            let airpods_device = AirPodsDevice::new(addr, handle_clone, ui_tx_clone.clone()).await;
             let mut managers = device_managers.write().await;
+            // let dev_managers = DeviceManagers::with_both(airpods_device.aacp_manager.clone(), airpods_device.att_manager.clone());
             let dev_managers = DeviceManagers::with_aacp(airpods_device.aacp_manager.clone());
             managers
-                .entry(addr_str)
+                .entry(addr_str.clone())
                 .or_insert(dev_managers)
                 .set_aacp(airpods_device.aacp_manager);
             drop(managers);
+            ui_tx_clone.send(BluetoothUIMessage::DeviceConnected(addr_str.clone())).unwrap();
         });
         true
     })?;