PeriphialkIdentifier

Author: paroga

src/api/mod.rs

@@ -174,11 +174,16 @@ pub enum WriteType {
     WithoutResponse,
 }
 
+pub type PeripheralId = BDAddr;
+
 /// Peripheral is the device that you would like to communicate with (the "server" of BLE). This
 /// struct contains both the current state of the device (its properties, characteristics, etc.)
 /// as well as functions for communication.
 #[async_trait]
 pub trait Peripheral: Send + Sync + Clone + Debug {
+    /// Returns the MAC address of the peripheral.
+    fn id(&self) -> PeripheralId;
+
     /// Returns the MAC address of the peripheral.
     fn address(&self) -> BDAddr;
 
@@ -236,23 +241,23 @@ pub trait Peripheral: Send + Sync + Clone + Debug {
 )]
 #[derive(Debug, Clone)]
 pub enum CentralEvent {
-    DeviceDiscovered(BDAddr),
-    DeviceUpdated(BDAddr),
-    DeviceConnected(BDAddr),
-    DeviceDisconnected(BDAddr),
+    DeviceDiscovered(PeripheralId),
+    DeviceUpdated(PeripheralId),
+    DeviceConnected(PeripheralId),
+    DeviceDisconnected(PeripheralId),
     /// Emitted when a Manufacturer Data advertisement has been received from a device
     ManufacturerDataAdvertisement {
-        address: BDAddr,
+        address: PeripheralId,
         manufacturer_data: HashMap<u16, Vec<u8>>,
     },
     /// Emitted when a Service Data advertisement has been received from a device
     ServiceDataAdvertisement {
-        address: BDAddr,
+        address: PeripheralId,
         service_data: HashMap<Uuid, Vec<u8>>,
     },
     /// Emitted when the advertised services for a device has been updated
     ServicesAdvertisement {
-        address: BDAddr,
+        address: PeripheralId,
         services: Vec<Uuid>,
     },
 }
@@ -280,7 +285,7 @@ pub trait Central: Send + Sync + Clone {
     async fn peripherals(&self) -> Result<Vec<Self::Peripheral>>;
 
     /// Returns a particular [`Peripheral`] by its address if it has been discovered.
-    async fn peripheral(&self, address: BDAddr) -> Result<Self::Peripheral>;
+    async fn peripheral(&self, address: PeripheralId) -> Result<Self::Peripheral>;
 
     /// Add a [`Peripheral`] from a MAC address without a scan result. Not supported on all Bluetooth systems.
     async fn add_peripheral(&self, address: BDAddr) -> Result<Self::Peripheral>;

src/bluez/peripheral.rs

@@ -10,7 +10,7 @@ use std::pin::Pin;
 use std::sync::{Arc, Mutex};
 
 use crate::api::{
-    self, AddressType, BDAddr, CharPropFlags, Characteristic, PeripheralProperties,
+    self, AddressType, BDAddr, CharPropFlags, Characteristic, PeripheralId, PeripheralProperties,
     ValueNotification, WriteType,
 };
 use crate::{Error, Result};
@@ -58,6 +58,10 @@ impl Peripheral {
 
 #[async_trait]
 impl api::Peripheral for Peripheral {
+    fn id(&self) -> PeripheralId {
+        self.address()
+    }
+
     fn address(&self) -> BDAddr {
         self.mac_address
     }

src/common/adapter_manager.rs

@@ -12,7 +12,7 @@
 //
 // Copyright (c) 2014 The Rust Project Developers
 use crate::{
-    api::{BDAddr, CentralEvent, Peripheral},
+    api::{CentralEvent, Peripheral, PeripheralId},
     common::util::send_notification,
 };
 use dashmap::{mapref::one::RefMut, DashMap};
@@ -26,7 +26,7 @@ pub struct AdapterManager<PeripheralType>
 where
     PeripheralType: Peripheral,
 {
-    peripherals: Arc<DashMap<BDAddr, PeripheralType>>,
+    peripherals: Arc<DashMap<PeripheralId, PeripheralType>>,
     async_senders: Arc<Mutex<Vec<UnboundedSender<CentralEvent>>>>,
 }
 
@@ -61,12 +61,12 @@ where
         Box::pin(receiver)
     }
 
-    pub fn add_peripheral(&self, addr: BDAddr, peripheral: PeripheralType) {
+    pub fn add_peripheral(&self, addr: PeripheralId, peripheral: PeripheralType) {
         assert!(
             !self.peripherals.contains_key(&addr),
             "Adding a peripheral that's already in the map."
         );
-        assert_eq!(peripheral.address(), addr, "Device has unexpected address."); // TODO remove addr argument
+        assert_eq!(peripheral.id(), addr, "Device has unexpected address."); // TODO remove addr argument
         self.peripherals.insert(addr, peripheral);
     }
 
@@ -77,11 +77,14 @@ where
             .collect()
     }
 
-    pub fn peripheral_mut(&self, address: BDAddr) -> Option<RefMut<BDAddr, PeripheralType>> {
+    pub fn peripheral_mut(
+        &self,
+        address: PeripheralId,
+    ) -> Option<RefMut<PeripheralId, PeripheralType>> {
         self.peripherals.get_mut(&address)
     }
 
-    pub fn peripheral(&self, address: BDAddr) -> Option<PeripheralType> {
+    pub fn peripheral(&self, address: PeripheralId) -> Option<PeripheralType> {
         self.peripherals
             .get(&address)
             .map(|val| val.value().clone())

src/corebluetooth/peripheral.rs

@@ -14,8 +14,8 @@ use super::{
 };
 use crate::{
     api::{
-        self, BDAddr, CentralEvent, CharPropFlags, Characteristic, PeripheralProperties,
-        ValueNotification, WriteType,
+        self, BDAddr, CentralEvent, CharPropFlags, Characteristic, PeripheralId,
+        PeripheralProperties, ValueNotification, WriteType,
     },
     common::adapter_manager::AdapterManager,
     Error, Result,
@@ -170,6 +170,10 @@ impl Debug for Peripheral {
 
 #[async_trait]
 impl api::Peripheral for Peripheral {
+    fn id(&self) -> PeripheralId {
+        self.address()
+    }
+
     fn address(&self) -> BDAddr {
         // TODO: look at moving/copying address out of properties so we don't have to
         // take a lock here! (the address for the peripheral won't ever change)

src/winrtble/peripheral.rs

@@ -19,7 +19,7 @@ use crate::{
     api::{
         bleuuid::{uuid_from_u16, uuid_from_u32},
         AddressType, BDAddr, CentralEvent, Characteristic, Peripheral as ApiPeripheral,
-        PeripheralProperties, ValueNotification, WriteType,
+        PeripheralId, PeripheralProperties, ValueNotification, WriteType,
     },
     common::adapter_manager::AdapterManager,
     Error, Result,
@@ -224,6 +224,10 @@ impl Debug for Peripheral {
 
 #[async_trait]
 impl ApiPeripheral for Peripheral {
+    fn id(&self) -> PeripheralId {
+        self.address()
+    }
+
     /// Returns the address of the peripheral.
     fn address(&self) -> BDAddr {
         self.shared.address