linux-rust: add skeleton for other devices

Author: kavishdevar

linux-rust/Cargo.lock

@@ -11,7 +11,7 @@ uuid = "1.18.1"
 log = "0.4.28"
 dbus = "0.9.9"
 hex = "0.4.3"
-iced = {version = "0.13.1", features = ["tokio"]}
+iced = { version = "0.13.1", features = ["tokio", "image"] }
 libpulse-binding = "2.30.1"
 ksni = "0.3.1"
 image = "0.25.8"

linux-rust/Cargo.toml

@@ -8,6 +8,8 @@ use tokio::time::{sleep, Instant};
 use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 use serde_json;
+use crate::devices::airpods::AirPodsInformation;
+use crate::devices::enums::{DeviceData, DeviceInformation, DeviceType};
 use crate::utils::get_devices_path;
 
 const PSM: u16 = 0x1001;
@@ -280,45 +282,11 @@ pub enum AACPEvent {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum DeviceType {
-    AirPods,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LEData {
+pub struct AirPodsLEKeys {
     pub irk: String,
     pub enc_key: String,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AirPodsInformation {
-    pub name: String,
-    pub model_number: String,
-    pub manufacturer: String,
-    pub serial_number: String,
-    pub version1: String,
-    pub version2: String,
-    pub hardware_revision: String,
-    pub updater_identifier: String,
-    pub left_serial_number: String,
-    pub right_serial_number: String,
-    pub version3: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "kind", content = "data")]
-pub enum DeviceInformation {
-    AirPods(AirPodsInformation),
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DeviceData {
-    pub name: String,
-    pub type_: DeviceType,
-    pub le: LEData,
-    pub information: Option<DeviceInformation>,
-}
-
 pub struct AACPManagerState {
     pub sender: Option<mpsc::Sender<Vec<u8>>>,
     pub control_command_status_list: Vec<ControlCommandStatus>,
@@ -647,7 +615,7 @@ impl AACPManager {
                         strings.push(s.to_string());
                     }
                 }
-                strings.remove(0); // Remove the first empty string as per comment
+                strings.remove(0);
                 let info = AirPodsInformation {
                     name: strings.get(0).cloned().unwrap_or_default(),
                     model_number: strings.get(1).cloned().unwrap_or_default(),
@@ -660,6 +628,10 @@ impl AACPManager {
                     left_serial_number: strings.get(8).cloned().unwrap_or_default(),
                     right_serial_number: strings.get(9).cloned().unwrap_or_default(),
                     version3: strings.get(10).cloned().unwrap_or_default(),
+                    le_keys: AirPodsLEKeys {
+                        irk: "".to_string(),
+                        enc_key: "".to_string(),
+                    },
                 };
                 let mut state = self.state.lock().await;
                 if let Some(mac) = state.airpods_mac {
@@ -715,12 +687,29 @@ impl AACPManager {
                             let device_data = state.devices.entry(mac_str.clone()).or_insert(DeviceData {
                                 name: mac_str.clone(),
                                 type_: DeviceType::AirPods,
-                                le: LEData { irk: "".to_string(), enc_key: "".to_string() },
                                 information: None,
                             });
                             match kt {
-                                ProximityKeyType::Irk => device_data.le.irk = hex::encode(key_data),
-                                ProximityKeyType::EncKey => device_data.le.enc_key = hex::encode(key_data),
+                                ProximityKeyType::Irk => {
+                                    match device_data.information.as_mut() {
+                                        Some(DeviceInformation::AirPods(info)) => {
+                                            info.le_keys.irk = hex::encode(key_data);
+                                        }
+                                        _ => {
+                                            error!("Device information is not AirPods for adding LE IRK.");
+                                        }
+                                    }
+                                }
+                                ProximityKeyType::EncKey => {
+                                    match device_data.information.as_mut() {
+                                        Some(DeviceInformation::AirPods(info)) => {
+                                            info.le_keys.enc_key = hex::encode(key_data);
+                                        }
+                                        _ => {
+                                            error!("Device information is not AirPods for adding LE encryption key.");
+                                        }
+                                    }
+                                }
                             }
                         }
                     }

linux-rust/assets/icon.png

@@ -16,62 +16,67 @@ const OPCODE_READ_REQUEST: u8 = 0x0A;
 const OPCODE_WRITE_REQUEST: u8 = 0x12;
 const OPCODE_HANDLE_VALUE_NTF: u8 = 0x1B;
 const OPCODE_WRITE_RESPONSE: u8 = 0x13;
+const RESPONSE_TIMEOUT: u64 = 5000;
 
 #[repr(u16)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum ATTHandles {
-    Transparency = 0x18,
-    LoudSoundReduction = 0x1B,
-    HearingAid = 0x2A,
+    AirPodsTransparency = 0x18,
+    AirPodsLoudSoundReduction = 0x1B,
+    AirPodsHearingAid = 0x2A,
+    NothingEverything = 0x8002,
+    NothingEverythingRead = 0x8005 // for some reason, and not the same as the write handle
 }
 
 #[repr(u16)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum ATTCCCDHandles {
-    Transparency = ATTHandles::Transparency as u16 + 1,
-    LoudSoundReduction = ATTHandles::LoudSoundReduction as u16 + 1,
-    HearingAid = ATTHandles::HearingAid as u16 + 1,
+    Transparency = ATTHandles::AirPodsTransparency as u16 + 1,
+    LoudSoundReduction = ATTHandles::AirPodsLoudSoundReduction as u16 + 1,
+    HearingAid = ATTHandles::AirPodsHearingAid as u16 + 1,
 }
 
 impl From<ATTHandles> for ATTCCCDHandles {
     fn from(handle: ATTHandles) -> Self {
         match handle {
-            ATTHandles::Transparency => ATTCCCDHandles::Transparency,
-            ATTHandles::LoudSoundReduction => ATTCCCDHandles::LoudSoundReduction,
-            ATTHandles::HearingAid => ATTCCCDHandles::HearingAid,
+            ATTHandles::AirPodsTransparency => ATTCCCDHandles::Transparency,
+            ATTHandles::AirPodsLoudSoundReduction => ATTCCCDHandles::LoudSoundReduction,
+            ATTHandles::AirPodsHearingAid => ATTCCCDHandles::HearingAid,
+            ATTHandles::NothingEverything => panic!("No CCCD for NothingEverything handle"), // we don't request it
+            ATTHandles::NothingEverythingRead => panic!("No CCD for NothingEverythingRead handle") // it sends notifications without CCCD
         }
     }
 }
 
 struct ATTManagerState {
     sender: Option<mpsc::Sender<Vec<u8>>>,
     listeners: HashMap<u16, Vec<mpsc::UnboundedSender<Vec<u8>>>>,
-    responses: mpsc::UnboundedReceiver<Vec<u8>>,
-    response_tx: mpsc::UnboundedSender<Vec<u8>>,
 }
 
 impl ATTManagerState {
     fn new() -> Self {
-        let (tx, rx) = mpsc::unbounded_channel();
         ATTManagerState {
             sender: None,
-            listeners: HashMap::new(),
-            responses: rx,
-            response_tx: tx,
+            listeners: HashMap::new()
         }
     }
 }
 
 #[derive(Clone)]
 pub struct ATTManager {
     state: Arc<Mutex<ATTManagerState>>,
+    response_rx: Arc<Mutex<mpsc::UnboundedReceiver<Vec<u8>>>>,
+    response_tx: mpsc::UnboundedSender<Vec<u8>>,
     tasks: Arc<Mutex<JoinSet<()>>>,
 }
 
 impl ATTManager {
     pub fn new() -> Self {
+        let (tx, rx) = mpsc::unbounded_channel();
         ATTManager {
             state: Arc::new(Mutex::new(ATTManagerState::new())),
+            response_rx: Arc::new(Mutex::new(rx)),
+            response_tx: tx,
             tasks: Arc::new(Mutex::new(JoinSet::new())),
         }
     }
@@ -184,11 +189,18 @@ impl ATTManager {
     }
 
     async fn read_response(&self) -> Result<Vec<u8>> {
-        let mut state = self.state.lock().await;
-        match tokio::time::timeout(Duration::from_millis(2000), state.responses.recv()).await {
+        debug!("Waiting for response...");
+        let mut rx = self.response_rx.lock().await;
+        match tokio::time::timeout(Duration::from_millis(RESPONSE_TIMEOUT), rx.recv()).await {
             Ok(Some(resp)) => Ok(resp),
-            Ok(None) => Err(Error::from(std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "Response channel closed"))),
-            Err(_) => Err(Error::from(std::io::Error::new(std::io::ErrorKind::TimedOut, "Response timeout"))),
+            Ok(None) => Err(Error::from(std::io::Error::new(
+                std::io::ErrorKind::UnexpectedEof,
+                "Response channel closed"
+            ))),
+            Err(_) => Err(Error::from(std::io::Error::new(
+                std::io::ErrorKind::TimedOut,
+                "Response timeout"
+            ))),
         }
     }
 }
@@ -217,10 +229,11 @@ async fn recv_thread(manager: ATTManager, sp: Arc<SeqPacket>) {
                             let _ = listener.send(value.clone());
                         }
                     }
+                } else if data[0] == OPCODE_WRITE_RESPONSE {
+                    let _ = manager.response_tx.send(vec![]);
                 } else {
                     // Response
-                    let state = manager.state.lock().await;
-                    let _ = state.response_tx.send(data[1..].to_vec());
+                    let _ = manager.response_tx.send(data[1..].to_vec());
                 }
             }
             Err(e) => {