Method discover_services

src/bluez/peripheral.rs:192–239

(&self)

    }

    async fn discover_services(&self) -> Result<()> {
        let mut services_internal = HashMap::new();
        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()
                    .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 {
                    info: service,
                    characteristics: characteristics
                        .into_iter()
                        .map(|characteristic| (characteristic.info.uuid, characteristic))
                        .collect(),
                },
            );
        }
        *(self.services.lock().map_err(Into::<Error>::into)?) = services_internal;
        Ok(())
    }

    async fn write(
        &self,