fix: Duplicate Characteristic UUID overwrite each other

This meant that if a device (like the LOOB) declares multiple characteristics
on a service with the same UUID, the later is used not the first. Ideally we'd
have access to them all, but since we can't tell them apart at the higher levels
first wins seems better than last wins.

Author: blackspherefollower

src/bluez/peripheral.rs

@@ -182,19 +182,35 @@ impl api::Peripheral for Peripheral {
         let services = self.session.get_services(&self.device).await?;
         for service in services {
             let characteristics = self.session.get_characteristics(&service.id).await?;
-            let characteristics =
-                join_all(characteristics.into_iter().map(|characteristic| async {
-                    let descriptors = self
-                        .session
-                        .get_descriptors(&characteristic.id)
-                        .await
-                        .unwrap_or(Vec::new())
-                        .into_iter()
-                        .map(|descriptor| (descriptor.uuid, descriptor))
-                        .collect();
-                    CharacteristicInternal::new(characteristic, descriptors)
-                }))
-                .await;
+            let characteristics = join_all(
+                characteristics
+                    .into_iter()
+                    .fold(
+                        // Only consider the first characteristic of each UUID
+                        // This "should" be unique, but of course it's not enforced
+                        HashMap::<Uuid, CharacteristicInfo>::new(),
+                        |mut map, characteristic| {
+                            if !map.contains_key(&characteristic.uuid) {
+                                map.insert(characteristic.uuid, characteristic);
+                            }
+                            map
+                        },
+                    )
+                    .into_iter()
+                    .map(|mapped_characteristic| async {
+                        let characteristic = mapped_characteristic.1;
+                        let descriptors = self
+                            .session
+                            .get_descriptors(&characteristic.id)
+                            .await
+                            .unwrap_or(Vec::new())
+                            .into_iter()
+                            .map(|descriptor| (descriptor.uuid, descriptor))
+                            .collect();
+                        CharacteristicInternal::new(characteristic, descriptors)
+                    }),
+            )
+            .await;
             services_internal.insert(
                 service.uuid,
                 ServiceInternal {

src/corebluetooth/central_delegate.rs

@@ -29,7 +29,7 @@ use cocoa::base::{id, nil};
 use futures::channel::mpsc::{self, Receiver, Sender};
 use futures::sink::SinkExt;
 use libc::c_void;
-use log::{error, trace};
+use log::{error, trace, warn};
 use objc::{
     class,
     declare::ClassDecl,
@@ -690,7 +690,15 @@ pub mod CentralDelegate {
                 // Create the map entry we'll need to export.
                 let uuid = cbuuid_to_uuid(cb::attribute_uuid(c));
                 let held_char = unsafe { StrongPtr::retain(c) };
-                characteristics.insert(uuid, held_char);
+
+                // Only consider the first characteristic of each UUID
+                // This "should" be unique, but of course it's not enforced
+
+                if !characteristics.contains_key(&uuid) {
+                    characteristics.insert(uuid, held_char);
+                } else {
+                    warn!("Duplicate characteristic UUID discovered: {:?}", uuid)
+                }
             }
             let peripheral_uuid = nsuuid_to_uuid(cb::peer_identifier(peripheral));
             let service_uuid = cbuuid_to_uuid(cb::attribute_uuid(service));

src/droidplug/peripheral.rs

@@ -280,18 +280,18 @@ impl api::Peripheral for Peripheral {
                             characteristic_uuid: characteristic.get_uuid()?,
                         });
                     }
-                    characteristics.insert(Characteristic {
+                    let char = Characteristic {
                         service_uuid: service.get_uuid()?,
                         uuid: characteristic.get_uuid()?,
                         properties: characteristic.get_properties()?,
                         descriptors: descriptors.clone(),
-                    });
-                    peripheral_characteristics.push(Characteristic {
-                        service_uuid: service.get_uuid()?,
-                        uuid: characteristic.get_uuid()?,
-                        properties: characteristic.get_properties()?,
-                        descriptors: descriptors,
-                    });
+                    };
+                    // Only consider the first characteristic of each UUID
+                    // This "should" be unique, but of course it's not enforced
+                    if !characteristics.contains(&char) {
+                        characteristics.insert(char.clone());
+                        peripheral_characteristics.push(char.clone());
+                    }
                 }
                 peripheral_services.push(Service {
                     uuid: service.get_uuid()?,

src/winrtble/peripheral.rs

@@ -44,6 +44,8 @@ use tokio::sync::broadcast;
 use uuid::Uuid;
 
 use std::sync::Weak;
+use windows::core::GUID;
+use windows::Devices::Bluetooth::GenericAttributeProfile::GattCharacteristic;
 use windows::Devices::Bluetooth::{Advertisement::*, BluetoothAddressType};
 
 #[cfg_attr(
@@ -413,8 +415,23 @@ impl ApiPeripheral for Peripheral {
                 if !self.shared.ble_services.contains_key(&uuid) {
                     match BLEDevice::get_characteristics(service).await {
                         Ok(characteristics) => {
-                            let characteristics =
-                                characteristics.into_iter().map(|characteristic| async {
+                            let characteristics = characteristics
+                                .into_iter()
+                                .fold(
+                                    // Only consider the first characteristic of each UUID
+                                    // This "should" be unique, but of course it's not enforced
+                                    HashMap::<GUID, GattCharacteristic>::new(),
+                                    |mut map, gatt_characteristic| {
+                                        let uuid = gatt_characteristic.Uuid().unwrap_or_default();
+                                        if !map.contains_key(&uuid) {
+                                            map.insert(uuid, gatt_characteristic);
+                                        }
+                                        map
+                                    },
+                                )
+                                .into_iter()
+                                .map(|mapped_characteristic| async {
+                                    let characteristic = mapped_characteristic.1;
                                     let c = characteristic.clone();
                                     (
                                         characteristic,