| //! This module converts a GattDatastore to an AttDatabase, |
| //! by converting a registry of services into a list of attributes, and proxying |
| //! ATT read/write requests into characteristic reads/writes |
| |
| use std::{cell::RefCell, collections::BTreeMap, ops::RangeInclusive, rc::Rc}; |
| |
| use anyhow::{bail, Result}; |
| use async_trait::async_trait; |
| use log::{error, warn}; |
| |
| use crate::{ |
| core::{ |
| shared_box::{SharedBox, WeakBox, WeakBoxRef}, |
| uuid::Uuid, |
| }, |
| gatt::{ |
| callbacks::{GattWriteRequestType, RawGattDatastore}, |
| ffi::AttributeBackingType, |
| ids::{AttHandle, TransportIndex}, |
| }, |
| packets::{ |
| AttAttributeDataChild, AttAttributeDataView, AttErrorCode, |
| GattCharacteristicDeclarationValueBuilder, GattCharacteristicPropertiesBuilder, |
| GattServiceDeclarationValueBuilder, UuidBuilder, |
| }, |
| }; |
| |
| use super::{ |
| att_database::{AttAttribute, AttDatabase}, |
| att_server_bearer::AttServerBearer, |
| }; |
| |
| pub use super::att_database::AttPermissions; |
| |
| /// Primary Service Declaration from Bluetooth Assigned Numbers 3.5 Declarations |
| pub const PRIMARY_SERVICE_DECLARATION_UUID: Uuid = Uuid::new(0x2800); |
| /// Secondary Service Declaration from Bluetooth Assigned Numbers 3.5 Declarations |
| pub const SECONDARY_SERVICE_DECLARATION_UUID: Uuid = Uuid::new(0x2801); |
| /// Characteristic Declaration from Bluetooth Assigned Numbers 3.5 Declarations |
| pub const CHARACTERISTIC_UUID: Uuid = Uuid::new(0x2803); |
| |
| /// A GattService (currently, only primary services are supported) has an |
| /// identifying UUID and a list of contained characteristics, as well as a |
| /// handle (indicating the attribute where the service declaration will live) |
| #[derive(Debug, Clone)] |
| pub struct GattServiceWithHandle { |
| /// The handle of the service declaration |
| pub handle: AttHandle, |
| /// The type of the service |
| pub type_: Uuid, |
| /// A list of contained characteristics (that must have handles between the |
| /// service declaration handle, and that of the next service) |
| pub characteristics: Vec<GattCharacteristicWithHandle>, |
| } |
| |
| /// A GattCharacteristic consists of a handle (where the value attribute lives), |
| /// a UUID identifying its type, and permissions indicating what operations can |
| /// be performed |
| #[derive(Debug, Clone)] |
| pub struct GattCharacteristicWithHandle { |
| /// The handle of the characteristic value attribute. The characteristic |
| /// declaration is one before this handle. |
| pub handle: AttHandle, |
| /// The UUID representing the type of the characteristic value. |
| pub type_: Uuid, |
| /// The permissions (read/write) indicate what operations can be performed. |
| pub permissions: AttPermissions, |
| /// The descriptors associated with this characteristic |
| pub descriptors: Vec<GattDescriptorWithHandle>, |
| } |
| |
| /// A GattDescriptor consists of a handle, type_, and permissions (similar to a |
| /// GattCharacteristic) It is guaranteed that the handle of the GattDescriptor |
| /// is after the handle of the characteristic value attribute, and before the |
| /// next characteristic/service declaration |
| #[derive(Debug, Clone)] |
| pub struct GattDescriptorWithHandle { |
| /// The handle of the descriptor. |
| pub handle: AttHandle, |
| /// The UUID representing the type of the descriptor. |
| pub type_: Uuid, |
| /// The permissions (read/write) indicate what operations can be performed. |
| pub permissions: AttPermissions, |
| } |
| |
| /// The GattDatabase implements AttDatabase, and converts attribute reads/writes |
| /// into GATT operations to be sent to the upper layers |
| #[derive(Default)] |
| pub struct GattDatabase { |
| schema: RefCell<GattDatabaseSchema>, |
| listeners: RefCell<Vec<Rc<dyn GattDatabaseCallbacks>>>, |
| } |
| |
| #[derive(Default)] |
| struct GattDatabaseSchema { |
| attributes: BTreeMap<AttHandle, AttAttributeWithBackingValue>, |
| } |
| |
| #[derive(Clone)] |
| enum AttAttributeBackingValue { |
| Static(AttAttributeDataChild), |
| DynamicCharacteristic(Rc<dyn RawGattDatastore>), |
| DynamicDescriptor(Rc<dyn RawGattDatastore>), |
| } |
| |
| #[derive(Clone)] |
| struct AttAttributeWithBackingValue { |
| attribute: AttAttribute, |
| value: AttAttributeBackingValue, |
| } |
| |
| /// Callbacks that can be registered on the GattDatabase to watch for |
| /// events of interest. |
| /// |
| /// Note: if the GattDatabase is dropped (e.g. due to unregistration), these |
| /// callbacks will not be invoked, even if the relevant event occurs later. |
| /// e.g. if we open the db, connect, close the db, then disconnect, then on_le_disconnect() |
| /// will NEVER be invoked. |
| pub trait GattDatabaseCallbacks { |
| /// A peer device on the given bearer has connected to this database (and can see its attributes) |
| fn on_le_connect( |
| &self, |
| tcb_idx: TransportIndex, |
| bearer: WeakBoxRef<AttServerBearer<AttDatabaseImpl>>, |
| ); |
| /// A peer device has disconnected from this database |
| fn on_le_disconnect(&self, tcb_idx: TransportIndex); |
| /// The attributes in the specified range have changed |
| fn on_service_change(&self, range: RangeInclusive<AttHandle>); |
| } |
| |
| impl GattDatabase { |
| /// Constructor, wrapping a GattDatastore |
| pub fn new() -> Self { |
| Default::default() |
| } |
| |
| /// Register an event listener |
| pub fn register_listener(&self, callbacks: Rc<dyn GattDatabaseCallbacks>) { |
| self.listeners.borrow_mut().push(callbacks); |
| } |
| |
| /// When a connection has been made with access to this database. |
| /// The supplied bearer is guaranteed to be ready for use. |
| pub fn on_bearer_ready( |
| &self, |
| tcb_idx: TransportIndex, |
| bearer: WeakBoxRef<AttServerBearer<AttDatabaseImpl>>, |
| ) { |
| for listener in self.listeners.borrow().iter() { |
| listener.on_le_connect(tcb_idx, bearer.clone()); |
| } |
| } |
| |
| /// When the connection has dropped. |
| pub fn on_bearer_dropped(&self, tcb_idx: TransportIndex) { |
| for listener in self.listeners.borrow().iter() { |
| listener.on_le_disconnect(tcb_idx); |
| } |
| } |
| |
| /// Add a service with pre-allocated handles (for co-existence with C++) backed by the supplied datastore |
| /// Assumes that the characteristic DECLARATION handles are one less than |
| /// the characteristic handles. |
| /// Returns failure if handles overlap with ones already allocated |
| pub fn add_service_with_handles( |
| &self, |
| service: GattServiceWithHandle, |
| datastore: Rc<dyn RawGattDatastore>, |
| ) -> Result<()> { |
| let mut attributes = BTreeMap::new(); |
| let mut attribute_cnt = 0; |
| |
| let mut add_attribute = |attribute: AttAttribute, value: AttAttributeBackingValue| { |
| attribute_cnt += 1; |
| attributes.insert(attribute.handle, AttAttributeWithBackingValue { attribute, value }) |
| }; |
| |
| let mut characteristics = vec![]; |
| |
| // service definition |
| add_attribute( |
| AttAttribute { |
| handle: service.handle, |
| type_: PRIMARY_SERVICE_DECLARATION_UUID, |
| permissions: AttPermissions::READABLE, |
| }, |
| AttAttributeBackingValue::Static( |
| GattServiceDeclarationValueBuilder { uuid: UuidBuilder::from(service.type_) } |
| .into(), |
| ), |
| ); |
| |
| // characteristics |
| for characteristic in service.characteristics { |
| characteristics.push(characteristic.clone()); |
| |
| // declaration |
| // Recall that we assume the declaration handle is one less than the value |
| // handle |
| let declaration_handle = AttHandle(characteristic.handle.0 - 1); |
| |
| add_attribute( |
| AttAttribute { |
| handle: declaration_handle, |
| type_: CHARACTERISTIC_UUID, |
| permissions: AttPermissions::READABLE, |
| }, |
| AttAttributeBackingValue::Static( |
| GattCharacteristicDeclarationValueBuilder { |
| properties: GattCharacteristicPropertiesBuilder { |
| broadcast: 0, |
| read: characteristic.permissions.readable().into(), |
| write_without_response: characteristic |
| .permissions |
| .writable_without_response() |
| .into(), |
| write: characteristic.permissions.writable_with_response().into(), |
| notify: 0, |
| indicate: characteristic.permissions.indicate().into(), |
| authenticated_signed_writes: 0, |
| extended_properties: 0, |
| }, |
| handle: characteristic.handle.into(), |
| uuid: characteristic.type_.into(), |
| } |
| .into(), |
| ), |
| ); |
| |
| // value |
| add_attribute( |
| AttAttribute { |
| handle: characteristic.handle, |
| type_: characteristic.type_, |
| permissions: characteristic.permissions, |
| }, |
| AttAttributeBackingValue::DynamicCharacteristic(datastore.clone()), |
| ); |
| |
| // descriptors |
| for descriptor in characteristic.descriptors { |
| add_attribute( |
| AttAttribute { |
| handle: descriptor.handle, |
| type_: descriptor.type_, |
| permissions: descriptor.permissions, |
| }, |
| AttAttributeBackingValue::DynamicDescriptor(datastore.clone()), |
| ); |
| } |
| } |
| |
| // validate attributes for overlap |
| let mut static_data = self.schema.borrow_mut(); |
| |
| for handle in attributes.keys() { |
| if static_data.attributes.contains_key(handle) { |
| bail!("duplicate handle detected"); |
| } |
| } |
| if attributes.len() != attribute_cnt { |
| bail!("duplicate handle detected"); |
| } |
| |
| // if we made it here, we successfully loaded the new service |
| static_data.attributes.extend(attributes.clone().into_iter()); |
| |
| // re-entrancy via the listeners is possible, so we prevent it by dropping here |
| drop(static_data); |
| |
| // notify listeners if any attribute changed |
| let added_handles = attributes.into_iter().map(|attr| attr.0).collect::<Vec<_>>(); |
| if !added_handles.is_empty() { |
| for listener in self.listeners.borrow().iter() { |
| listener.on_service_change( |
| *added_handles.iter().min().unwrap()..=*added_handles.iter().max().unwrap(), |
| ); |
| } |
| } |
| |
| Ok(()) |
| } |
| |
| /// Remove a previously-added service by service handle |
| pub fn remove_service_at_handle(&self, service_handle: AttHandle) -> Result<()> { |
| let mut static_data = self.schema.borrow_mut(); |
| |
| // find next service |
| let next_service_handle = static_data |
| .attributes |
| .values() |
| .find(|attribute| { |
| attribute.attribute.handle > service_handle |
| && attribute.attribute.type_ == PRIMARY_SERVICE_DECLARATION_UUID |
| }) |
| .map(|service| service.attribute.handle); |
| |
| // predicate matching all handles in our service |
| let in_service_pred = |handle: AttHandle| { |
| service_handle <= handle && next_service_handle.map(|x| handle < x).unwrap_or(true) |
| }; |
| |
| // record largest attribute matching predicate |
| let largest_service_handle = |
| static_data.attributes.keys().filter(|handle| in_service_pred(**handle)).max().cloned(); |
| |
| // clear out attributes |
| static_data.attributes.retain(|curr_handle, _| !in_service_pred(*curr_handle)); |
| |
| // re-entrancy via the listeners is possible, so we prevent it by dropping here |
| drop(static_data); |
| |
| // notify listeners if any attribute changed |
| if let Some(largest_service_handle) = largest_service_handle { |
| for listener in self.listeners.borrow().iter() { |
| listener.on_service_change(service_handle..=largest_service_handle); |
| } |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl SharedBox<GattDatabase> { |
| /// Generate an impl AttDatabase from a backing GattDatabase, associated |
| /// with a given connection. |
| /// |
| /// Note: After the AttDatabaseImpl is constructed, we MUST call on_bearer_ready() with |
| /// the resultant bearer, so that the listeners get the correct sequence of callbacks. |
| pub fn get_att_database(&self, tcb_idx: TransportIndex) -> AttDatabaseImpl { |
| AttDatabaseImpl { gatt_db: self.downgrade(), tcb_idx } |
| } |
| } |
| |
| /// An implementation of AttDatabase wrapping an underlying GattDatabase |
| pub struct AttDatabaseImpl { |
| gatt_db: WeakBox<GattDatabase>, |
| tcb_idx: TransportIndex, |
| } |
| |
| #[async_trait(?Send)] |
| impl AttDatabase for AttDatabaseImpl { |
| async fn read_attribute( |
| &self, |
| handle: AttHandle, |
| ) -> Result<AttAttributeDataChild, AttErrorCode> { |
| let value = self.gatt_db.with(|gatt_db| { |
| let Some(gatt_db) = gatt_db else { |
| // db must have been closed |
| return Err(AttErrorCode::INVALID_HANDLE); |
| }; |
| let services = gatt_db.schema.borrow(); |
| let Some(attr) = services.attributes.get(&handle) else { |
| return Err(AttErrorCode::INVALID_HANDLE); |
| }; |
| if !attr.attribute.permissions.readable() { |
| return Err(AttErrorCode::READ_NOT_PERMITTED); |
| } |
| Ok(attr.value.clone()) |
| })?; |
| |
| match value { |
| AttAttributeBackingValue::Static(val) => return Ok(val), |
| AttAttributeBackingValue::DynamicCharacteristic(datastore) => { |
| datastore |
| .read( |
| self.tcb_idx, |
| handle, |
| /* offset */ 0, |
| AttributeBackingType::Characteristic, |
| ) |
| .await |
| } |
| AttAttributeBackingValue::DynamicDescriptor(datastore) => { |
| datastore |
| .read( |
| self.tcb_idx, |
| handle, |
| /* offset */ 0, |
| AttributeBackingType::Descriptor, |
| ) |
| .await |
| } |
| } |
| } |
| |
| async fn write_attribute( |
| &self, |
| handle: AttHandle, |
| data: AttAttributeDataView<'_>, |
| ) -> Result<(), AttErrorCode> { |
| let value = self.gatt_db.with(|gatt_db| { |
| let Some(gatt_db) = gatt_db else { |
| // db must have been closed |
| return Err(AttErrorCode::INVALID_HANDLE); |
| }; |
| let services = gatt_db.schema.borrow(); |
| let Some(attr) = services.attributes.get(&handle) else { |
| return Err(AttErrorCode::INVALID_HANDLE); |
| }; |
| if !attr.attribute.permissions.writable_with_response() { |
| return Err(AttErrorCode::WRITE_NOT_PERMITTED); |
| } |
| Ok(attr.value.clone()) |
| })?; |
| |
| match value { |
| AttAttributeBackingValue::Static(val) => { |
| error!("A static attribute {val:?} is marked as writable - ignoring it and rejecting the write..."); |
| return Err(AttErrorCode::WRITE_NOT_PERMITTED); |
| } |
| AttAttributeBackingValue::DynamicCharacteristic(datastore) => { |
| datastore |
| .write( |
| self.tcb_idx, |
| handle, |
| AttributeBackingType::Characteristic, |
| GattWriteRequestType::Request, |
| data, |
| ) |
| .await |
| } |
| AttAttributeBackingValue::DynamicDescriptor(datastore) => { |
| datastore |
| .write( |
| self.tcb_idx, |
| handle, |
| AttributeBackingType::Descriptor, |
| GattWriteRequestType::Request, |
| data, |
| ) |
| .await |
| } |
| } |
| } |
| |
| fn write_no_response_attribute(&self, handle: AttHandle, data: AttAttributeDataView<'_>) { |
| let value = self.gatt_db.with(|gatt_db| { |
| let Some(gatt_db) = gatt_db else { |
| // db must have been closed |
| return None; |
| }; |
| let services = gatt_db.schema.borrow(); |
| let Some(attr) = services.attributes.get(&handle) else { |
| warn!("cannot find handle {handle:?}"); |
| return None; |
| }; |
| if !attr.attribute.permissions.writable_without_response() { |
| warn!("trying to write without response to {handle:?}, which doesn't support it"); |
| return None; |
| } |
| Some(attr.value.clone()) |
| }); |
| |
| let Some(value) = value else { |
| return; |
| }; |
| |
| match value { |
| AttAttributeBackingValue::Static(val) => { |
| error!("A static attribute {val:?} is marked as writable - ignoring it and rejecting the write..."); |
| } |
| AttAttributeBackingValue::DynamicCharacteristic(datastore) => { |
| datastore.write_no_response( |
| self.tcb_idx, |
| handle, |
| AttributeBackingType::Characteristic, |
| data, |
| ); |
| } |
| AttAttributeBackingValue::DynamicDescriptor(datastore) => { |
| datastore.write_no_response( |
| self.tcb_idx, |
| handle, |
| AttributeBackingType::Descriptor, |
| data, |
| ); |
| } |
| }; |
| } |
| |
| fn list_attributes(&self) -> Vec<AttAttribute> { |
| self.gatt_db.with(|db| { |
| db.map(|db| db.schema.borrow().attributes.values().map(|attr| attr.attribute).collect()) |
| .unwrap_or_default() |
| }) |
| } |
| } |
| |
| impl Clone for AttDatabaseImpl { |
| fn clone(&self) -> Self { |
| Self { gatt_db: self.gatt_db.clone(), tcb_idx: self.tcb_idx } |
| } |
| } |
| |
| impl AttDatabaseImpl { |
| /// When the bearer owning this AttDatabase is invalidated, |
| /// we must notify the listeners tied to our GattDatabase. |
| /// |
| /// Note: AttDatabases referring to the backing GattDatabase |
| /// may still exist after bearer invalidation, but the bearer will |
| /// no longer exist (so packets can no longer be sent/received). |
| pub fn on_bearer_dropped(&self) { |
| self.gatt_db.with(|db| { |
| db.map(|db| { |
| for listener in db.listeners.borrow().iter() { |
| listener.on_le_disconnect(self.tcb_idx) |
| } |
| }) |
| }); |
| } |
| } |
| |
| #[cfg(test)] |
| mod test { |
| use tokio::{join, sync::mpsc::error::TryRecvError, task::spawn_local}; |
| |
| use crate::{ |
| gatt::mocks::{ |
| mock_database_callbacks::{MockCallbackEvents, MockCallbacks}, |
| mock_datastore::{MockDatastore, MockDatastoreEvents}, |
| mock_raw_datastore::{MockRawDatastore, MockRawDatastoreEvents}, |
| }, |
| packets::Packet, |
| utils::{ |
| packet::{build_att_data, build_view_or_crash}, |
| task::block_on_locally, |
| }, |
| }; |
| |
| use super::*; |
| |
| const SERVICE_HANDLE: AttHandle = AttHandle(1); |
| const SERVICE_TYPE: Uuid = Uuid::new(0x1234); |
| |
| const CHARACTERISTIC_DECLARATION_HANDLE: AttHandle = AttHandle(2); |
| const CHARACTERISTIC_VALUE_HANDLE: AttHandle = AttHandle(3); |
| const CHARACTERISTIC_TYPE: Uuid = Uuid::new(0x5678); |
| |
| const DESCRIPTOR_HANDLE: AttHandle = AttHandle(4); |
| const DESCRIPTOR_TYPE: Uuid = Uuid::new(0x9ABC); |
| |
| const TCB_IDX: TransportIndex = TransportIndex(1); |
| |
| #[test] |
| fn test_read_empty_db() { |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| |
| let resp = tokio_test::block_on(att_db.read_attribute(AttHandle(1))); |
| |
| assert_eq!(resp, Err(AttErrorCode::INVALID_HANDLE)) |
| } |
| |
| #[test] |
| fn test_single_service() { |
| let (gatt_datastore, _) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| |
| let attrs = att_db.list_attributes(); |
| let service_value = tokio_test::block_on(att_db.read_attribute(SERVICE_HANDLE)); |
| |
| assert_eq!( |
| attrs, |
| vec![AttAttribute { |
| handle: SERVICE_HANDLE, |
| type_: PRIMARY_SERVICE_DECLARATION_UUID, |
| permissions: AttPermissions::READABLE |
| }] |
| ); |
| assert_eq!( |
| service_value, |
| Ok(AttAttributeDataChild::GattServiceDeclarationValue( |
| GattServiceDeclarationValueBuilder { uuid: SERVICE_TYPE.into() } |
| )) |
| ); |
| } |
| |
| #[test] |
| fn test_service_removal() { |
| // arrange three services, each with a single characteristic |
| let (gatt_datastore, _) = MockDatastore::new(); |
| let gatt_datastore = Rc::new(gatt_datastore); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(1), |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: AttHandle(3), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![], |
| }], |
| }, |
| gatt_datastore.clone(), |
| ) |
| .unwrap(); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(4), |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: AttHandle(6), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![], |
| }], |
| }, |
| gatt_datastore.clone(), |
| ) |
| .unwrap(); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(7), |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: AttHandle(9), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![], |
| }], |
| }, |
| gatt_datastore, |
| ) |
| .unwrap(); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| assert_eq!(att_db.list_attributes().len(), 9); |
| |
| // act: remove the middle service |
| gatt_db.remove_service_at_handle(AttHandle(4)).unwrap(); |
| let attrs = att_db.list_attributes(); |
| |
| // assert that the middle service is gone |
| assert_eq!(attrs.len(), 6, "{attrs:?}"); |
| |
| // assert the other two old services are still there |
| assert_eq!( |
| attrs[0], |
| AttAttribute { |
| handle: AttHandle(1), |
| type_: PRIMARY_SERVICE_DECLARATION_UUID, |
| permissions: AttPermissions::READABLE |
| } |
| ); |
| assert_eq!( |
| attrs[3], |
| AttAttribute { |
| handle: AttHandle(7), |
| type_: PRIMARY_SERVICE_DECLARATION_UUID, |
| permissions: AttPermissions::READABLE |
| } |
| ); |
| } |
| |
| #[test] |
| fn test_single_characteristic_declaration() { |
| let (gatt_datastore, _) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE |
| | AttPermissions::WRITABLE_WITH_RESPONSE |
| | AttPermissions::INDICATE, |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| |
| let attrs = att_db.list_attributes(); |
| let characteristic_decl = |
| tokio_test::block_on(att_db.read_attribute(CHARACTERISTIC_DECLARATION_HANDLE)); |
| |
| assert_eq!(attrs.len(), 3, "{attrs:?}"); |
| assert_eq!(attrs[0].type_, PRIMARY_SERVICE_DECLARATION_UUID); |
| assert_eq!( |
| attrs[1], |
| AttAttribute { |
| handle: CHARACTERISTIC_DECLARATION_HANDLE, |
| type_: CHARACTERISTIC_UUID, |
| permissions: AttPermissions::READABLE |
| } |
| ); |
| assert_eq!( |
| attrs[2], |
| AttAttribute { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE |
| | AttPermissions::WRITABLE_WITH_RESPONSE |
| | AttPermissions::INDICATE |
| } |
| ); |
| |
| assert_eq!( |
| characteristic_decl, |
| Ok(AttAttributeDataChild::GattCharacteristicDeclarationValue( |
| GattCharacteristicDeclarationValueBuilder { |
| properties: GattCharacteristicPropertiesBuilder { |
| read: 1, |
| broadcast: 0, |
| write_without_response: 0, |
| write: 1, |
| notify: 0, |
| indicate: 1, |
| authenticated_signed_writes: 0, |
| extended_properties: 0, |
| }, |
| handle: CHARACTERISTIC_VALUE_HANDLE.into(), |
| uuid: CHARACTERISTIC_TYPE.into() |
| } |
| )) |
| ); |
| } |
| |
| #[test] |
| fn test_all_characteristic_permissions() { |
| // arrange |
| let (gatt_datastore, _) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| |
| // act: add a characteristic with all permission bits set |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::all(), |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| |
| // assert: the characteristic declaration has all the bits we support set |
| let characteristic_decl = |
| tokio_test::block_on(att_db.read_attribute(CHARACTERISTIC_DECLARATION_HANDLE)); |
| assert_eq!( |
| characteristic_decl, |
| Ok(AttAttributeDataChild::GattCharacteristicDeclarationValue( |
| GattCharacteristicDeclarationValueBuilder { |
| properties: GattCharacteristicPropertiesBuilder { |
| read: 1, |
| broadcast: 0, |
| write_without_response: 1, |
| write: 1, |
| notify: 0, |
| indicate: 1, |
| authenticated_signed_writes: 0, |
| extended_properties: 0, |
| }, |
| handle: CHARACTERISTIC_VALUE_HANDLE.into(), |
| uuid: CHARACTERISTIC_TYPE.into() |
| } |
| )) |
| ); |
| } |
| |
| #[test] |
| fn test_single_characteristic_value() { |
| // arrange: create a database with a single characteristic |
| let (gatt_datastore, mut data_evts) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| let data = AttAttributeDataChild::RawData(Box::new([1, 2])); |
| |
| // act: read from the database, and supply a value from the backing datastore |
| let characteristic_value = tokio_test::block_on(async { |
| join!( |
| async { |
| let MockDatastoreEvents::Read( |
| TCB_IDX, |
| CHARACTERISTIC_VALUE_HANDLE, |
| AttributeBackingType::Characteristic, |
| reply, |
| ) = data_evts.recv().await.unwrap() else { |
| unreachable!() |
| }; |
| reply.send(Ok(data.clone())).unwrap(); |
| }, |
| att_db.read_attribute(CHARACTERISTIC_VALUE_HANDLE) |
| ) |
| .1 |
| }); |
| |
| // assert: the supplied value matches what the att datastore returned |
| assert_eq!(characteristic_value, Ok(data)); |
| } |
| |
| #[test] |
| fn test_unreadable_characteristic() { |
| let (gatt_datastore, _) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::empty(), |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| |
| let characteristic_value = tokio_test::block_on( |
| gatt_db.get_att_database(TCB_IDX).read_attribute(CHARACTERISTIC_VALUE_HANDLE), |
| ); |
| |
| assert_eq!(characteristic_value, Err(AttErrorCode::READ_NOT_PERMITTED)); |
| } |
| |
| #[test] |
| fn test_handle_clash() { |
| let (gatt_datastore, _) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| |
| let result = gatt_db.add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::WRITABLE_WITH_RESPONSE, |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ); |
| |
| assert!(result.is_err()); |
| } |
| |
| #[test] |
| fn test_handle_clash_with_existing() { |
| let (gatt_datastore, _) = MockDatastore::new(); |
| let gatt_datastore = Rc::new(gatt_datastore); |
| let gatt_db = Rc::new(GattDatabase::new()); |
| |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![], |
| }, |
| gatt_datastore.clone(), |
| ) |
| .unwrap(); |
| |
| let result = gatt_db.add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![], |
| }, |
| gatt_datastore, |
| ); |
| |
| assert!(result.is_err()); |
| } |
| |
| #[test] |
| fn test_write_single_characteristic_callback_invoked() { |
| // arrange: create a database with a single characteristic |
| let (gatt_datastore, mut data_evts) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::WRITABLE_WITH_RESPONSE, |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| let data = |
| build_view_or_crash(build_att_data(AttAttributeDataChild::RawData(Box::new([1, 2])))); |
| |
| // act: write to the database |
| let recv_data = block_on_locally(async { |
| // start write task |
| let cloned_data = data.view().to_owned_packet(); |
| spawn_local(async move { |
| att_db |
| .write_attribute(CHARACTERISTIC_VALUE_HANDLE, cloned_data.view()) |
| .await |
| .unwrap(); |
| }); |
| |
| let MockDatastoreEvents::Write( |
| TCB_IDX, |
| CHARACTERISTIC_VALUE_HANDLE, |
| AttributeBackingType::Characteristic, |
| recv_data, |
| _, |
| ) = data_evts.recv().await.unwrap() else { |
| unreachable!(); |
| }; |
| recv_data |
| }); |
| |
| // assert: the received value matches what we supplied |
| assert_eq!( |
| recv_data.view().get_raw_payload().collect::<Vec<_>>(), |
| data.view().get_raw_payload().collect::<Vec<_>>() |
| ); |
| } |
| |
| #[test] |
| fn test_write_single_characteristic_recv_response() { |
| // arrange: create a database with a single characteristic |
| let (gatt_datastore, mut data_evts) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::WRITABLE_WITH_RESPONSE, |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| let data = |
| build_view_or_crash(build_att_data(AttAttributeDataChild::RawData(Box::new([1, 2])))); |
| |
| // act: write to the database |
| let res = tokio_test::block_on(async { |
| join!( |
| async { |
| let MockDatastoreEvents::Write(_,_,_,_,reply) = data_evts.recv().await.unwrap() else { |
| unreachable!(); |
| }; |
| reply.send(Err(AttErrorCode::UNLIKELY_ERROR)).unwrap(); |
| }, |
| att_db.write_attribute(CHARACTERISTIC_VALUE_HANDLE, data.view()) |
| ) |
| .1 |
| }); |
| |
| // assert: the supplied value matches what the att datastore returned |
| assert_eq!(res, Err(AttErrorCode::UNLIKELY_ERROR)); |
| } |
| |
| #[test] |
| fn test_unwriteable_characteristic() { |
| let (gatt_datastore, _) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| let data = |
| build_view_or_crash(build_att_data(AttAttributeDataChild::RawData(Box::new([1, 2])))); |
| |
| let characteristic_value = tokio_test::block_on( |
| gatt_db |
| .get_att_database(TCB_IDX) |
| .write_attribute(CHARACTERISTIC_VALUE_HANDLE, data.view()), |
| ); |
| |
| assert_eq!(characteristic_value, Err(AttErrorCode::WRITE_NOT_PERMITTED)); |
| } |
| |
| #[test] |
| fn test_single_descriptor_declaration() { |
| let (gatt_datastore, mut data_evts) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![GattDescriptorWithHandle { |
| handle: DESCRIPTOR_HANDLE, |
| type_: DESCRIPTOR_TYPE, |
| permissions: AttPermissions::READABLE, |
| }], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| let data = AttAttributeDataChild::RawData(Box::new([1, 2])); |
| |
| let descriptor_value = block_on_locally(async { |
| // start write task |
| let pending_read = |
| spawn_local(async move { att_db.read_attribute(DESCRIPTOR_HANDLE).await.unwrap() }); |
| |
| let MockDatastoreEvents::Read( |
| TCB_IDX, |
| DESCRIPTOR_HANDLE, |
| AttributeBackingType::Descriptor, |
| reply, |
| ) = data_evts.recv().await.unwrap() else { |
| unreachable!(); |
| }; |
| |
| reply.send(Ok(data.clone())).unwrap(); |
| |
| pending_read.await.unwrap() |
| }); |
| |
| assert_eq!(descriptor_value, data); |
| } |
| |
| #[test] |
| fn test_write_descriptor() { |
| // arrange: db with a writable descriptor |
| let (gatt_datastore, mut data_evts) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![GattDescriptorWithHandle { |
| handle: DESCRIPTOR_HANDLE, |
| type_: DESCRIPTOR_TYPE, |
| permissions: AttPermissions::WRITABLE_WITH_RESPONSE, |
| }], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| let data = |
| build_view_or_crash(build_att_data(AttAttributeDataChild::RawData(Box::new([1, 2])))); |
| |
| // act: write, and wait for the callback to be invoked |
| block_on_locally(async { |
| // start write task |
| spawn_local(async move { |
| att_db.write_attribute(DESCRIPTOR_HANDLE, data.view()).await.unwrap() |
| }); |
| |
| let MockDatastoreEvents::Write( |
| TCB_IDX, |
| DESCRIPTOR_HANDLE, |
| AttributeBackingType::Descriptor, |
| _, |
| _, |
| ) = data_evts.recv().await.unwrap() else { |
| unreachable!(); |
| }; |
| }); |
| |
| // assert: nothing, if we reach this far we are OK |
| } |
| |
| #[test] |
| fn test_multiple_descriptors() { |
| // arrange: a database with some characteristics and descriptors |
| let (gatt_datastore, _) = MockDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(1), |
| type_: SERVICE_TYPE, |
| characteristics: vec![ |
| GattCharacteristicWithHandle { |
| handle: AttHandle(3), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![GattDescriptorWithHandle { |
| handle: AttHandle(4), |
| type_: DESCRIPTOR_TYPE, |
| permissions: AttPermissions::READABLE, |
| }], |
| }, |
| GattCharacteristicWithHandle { |
| handle: AttHandle(6), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![ |
| GattDescriptorWithHandle { |
| handle: AttHandle(7), |
| type_: DESCRIPTOR_TYPE, |
| permissions: AttPermissions::WRITABLE_WITH_RESPONSE, |
| }, |
| GattDescriptorWithHandle { |
| handle: AttHandle(8), |
| type_: DESCRIPTOR_TYPE, |
| permissions: AttPermissions::READABLE |
| | AttPermissions::WRITABLE_WITH_RESPONSE, |
| }, |
| ], |
| }, |
| ], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| |
| // act: get the attributes |
| let attributes = gatt_db.get_att_database(TCB_IDX).list_attributes(); |
| |
| // assert: check the attributes are in the correct order |
| assert_eq!(attributes.len(), 8); |
| assert_eq!(attributes[0].type_, PRIMARY_SERVICE_DECLARATION_UUID); |
| assert_eq!(attributes[1].type_, CHARACTERISTIC_UUID); |
| assert_eq!(attributes[2].type_, CHARACTERISTIC_TYPE); |
| assert_eq!(attributes[3].type_, DESCRIPTOR_TYPE); |
| assert_eq!(attributes[4].type_, CHARACTERISTIC_UUID); |
| assert_eq!(attributes[5].type_, CHARACTERISTIC_TYPE); |
| assert_eq!(attributes[6].type_, DESCRIPTOR_TYPE); |
| assert_eq!(attributes[7].type_, DESCRIPTOR_TYPE); |
| // assert: check the handles of the descriptors are correct |
| assert_eq!(attributes[3].handle, AttHandle(4)); |
| assert_eq!(attributes[6].handle, AttHandle(7)); |
| assert_eq!(attributes[7].handle, AttHandle(8)); |
| // assert: check the permissions of the descriptors are correct |
| assert_eq!(attributes[3].permissions, AttPermissions::READABLE); |
| assert_eq!(attributes[6].permissions, AttPermissions::WRITABLE_WITH_RESPONSE); |
| assert_eq!( |
| attributes[7].permissions, |
| AttPermissions::READABLE | AttPermissions::WRITABLE_WITH_RESPONSE |
| ); |
| } |
| |
| #[test] |
| fn test_multiple_datastores() { |
| // arrange: create a database with two services backed by different datastores |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| |
| let (gatt_datastore_1, mut data_evts_1) = MockDatastore::new(); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(1), |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: AttHandle(3), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore_1), |
| ) |
| .unwrap(); |
| |
| let (gatt_datastore_2, mut data_evts_2) = MockDatastore::new(); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(4), |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: AttHandle(6), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE, |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore_2), |
| ) |
| .unwrap(); |
| |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| let data = AttAttributeDataChild::RawData(Box::new([1, 2])); |
| |
| // act: read from the second characteristic and supply a response from the second datastore |
| let characteristic_value = tokio_test::block_on(async { |
| join!( |
| async { |
| let MockDatastoreEvents::Read( |
| TCB_IDX, |
| AttHandle(6), |
| AttributeBackingType::Characteristic, |
| reply, |
| ) = data_evts_2.recv().await.unwrap() else { |
| unreachable!() |
| }; |
| reply.send(Ok(data.clone())).unwrap(); |
| }, |
| att_db.read_attribute(AttHandle(6)) |
| ) |
| .1 |
| }); |
| |
| // assert: the supplied value matches what the att datastore returned |
| assert_eq!(characteristic_value, Ok(data)); |
| // the first datastore received no events |
| assert_eq!(data_evts_1.try_recv().unwrap_err(), TryRecvError::Empty); |
| // the second datastore has no remaining events |
| assert_eq!(data_evts_2.try_recv().unwrap_err(), TryRecvError::Empty); |
| } |
| |
| fn make_bearer( |
| gatt_db: &SharedBox<GattDatabase>, |
| ) -> SharedBox<AttServerBearer<AttDatabaseImpl>> { |
| SharedBox::new(AttServerBearer::new(gatt_db.get_att_database(TCB_IDX), |_| { |
| unreachable!(); |
| })) |
| } |
| |
| #[test] |
| fn test_connection_listener() { |
| // arrange: db with a listener |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| let (callbacks, mut rx) = MockCallbacks::new(); |
| gatt_db.register_listener(Rc::new(callbacks)); |
| let bearer = make_bearer(&gatt_db); |
| |
| // act: open a connection |
| gatt_db.on_bearer_ready(TCB_IDX, bearer.as_ref()); |
| |
| // assert: we got the callback |
| let event = rx.blocking_recv().unwrap(); |
| assert!(matches!(event, MockCallbackEvents::OnLeConnect(TCB_IDX, _))); |
| } |
| |
| #[test] |
| fn test_disconnection_listener() { |
| // arrange: db with a listener |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| let (callbacks, mut rx) = MockCallbacks::new(); |
| gatt_db.register_listener(Rc::new(callbacks)); |
| |
| // act: disconnect |
| gatt_db.on_bearer_dropped(TCB_IDX); |
| |
| // assert: we got the callback |
| let event = rx.blocking_recv().unwrap(); |
| assert!(matches!(event, MockCallbackEvents::OnLeDisconnect(TCB_IDX))); |
| } |
| |
| #[test] |
| fn test_multiple_listeners() { |
| // arrange: db with two listeners |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| let (callbacks1, mut rx1) = MockCallbacks::new(); |
| gatt_db.register_listener(Rc::new(callbacks1)); |
| let (callbacks2, mut rx2) = MockCallbacks::new(); |
| gatt_db.register_listener(Rc::new(callbacks2)); |
| |
| // act: disconnect |
| gatt_db.on_bearer_dropped(TCB_IDX); |
| |
| // assert: we got the callback on both listeners |
| let event = rx1.blocking_recv().unwrap(); |
| assert!(matches!(event, MockCallbackEvents::OnLeDisconnect(TCB_IDX))); |
| let event = rx2.blocking_recv().unwrap(); |
| assert!(matches!(event, MockCallbackEvents::OnLeDisconnect(TCB_IDX))); |
| } |
| |
| #[test] |
| fn test_add_service_changed_listener() { |
| // arrange: db with a listener |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| let (callbacks, mut rx) = MockCallbacks::new(); |
| let (datastore, _) = MockDatastore::new(); |
| |
| // act: start listening and add a new service |
| gatt_db.register_listener(Rc::new(callbacks)); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(4), |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: AttHandle(6), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::empty(), |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(datastore), |
| ) |
| .unwrap(); |
| |
| // assert: we got the callback |
| let event = rx.blocking_recv().unwrap(); |
| let MockCallbackEvents::OnServiceChange(range) = event else { |
| unreachable!(); |
| }; |
| assert_eq!(*range.start(), AttHandle(4)); |
| assert_eq!(*range.end(), AttHandle(6)); |
| } |
| |
| #[test] |
| fn test_partial_remove_service_changed_listener() { |
| // arrange: db with two services and a listener |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| let (callbacks, mut rx) = MockCallbacks::new(); |
| let (datastore, _) = MockDatastore::new(); |
| let datastore = Rc::new(datastore); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(4), |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: AttHandle(6), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::empty(), |
| descriptors: vec![], |
| }], |
| }, |
| datastore.clone(), |
| ) |
| .unwrap(); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(8), |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: AttHandle(10), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::empty(), |
| descriptors: vec![], |
| }], |
| }, |
| datastore, |
| ) |
| .unwrap(); |
| |
| // act: start listening and remove the first service |
| gatt_db.register_listener(Rc::new(callbacks)); |
| gatt_db.remove_service_at_handle(AttHandle(4)).unwrap(); |
| |
| // assert: we got the callback |
| let event = rx.blocking_recv().unwrap(); |
| let MockCallbackEvents::OnServiceChange(range) = event else { |
| unreachable!(); |
| }; |
| assert_eq!(*range.start(), AttHandle(4)); |
| assert_eq!(*range.end(), AttHandle(6)); |
| } |
| |
| #[test] |
| fn test_full_remove_service_changed_listener() { |
| // arrange: db with a listener and a service |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| let (callbacks, mut rx) = MockCallbacks::new(); |
| let (datastore, _) = MockDatastore::new(); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(4), |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: AttHandle(6), |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::empty(), |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(datastore), |
| ) |
| .unwrap(); |
| |
| // act: start listening and remove the service |
| gatt_db.register_listener(Rc::new(callbacks)); |
| gatt_db.remove_service_at_handle(AttHandle(4)).unwrap(); |
| |
| // assert: we got the callback |
| let event = rx.blocking_recv().unwrap(); |
| let MockCallbackEvents::OnServiceChange(range) = event else { |
| unreachable!(); |
| }; |
| assert_eq!(*range.start(), AttHandle(4)); |
| assert_eq!(*range.end(), AttHandle(6)); |
| } |
| |
| #[test] |
| fn test_trivial_remove_service_changed_listener() { |
| // arrange: db with a listener and a trivial service |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| let (callbacks, mut rx) = MockCallbacks::new(); |
| let (datastore, _) = MockDatastore::new(); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: AttHandle(4), |
| type_: SERVICE_TYPE, |
| characteristics: vec![], |
| }, |
| Rc::new(datastore), |
| ) |
| .unwrap(); |
| |
| // act: start listening and remove the service |
| gatt_db.register_listener(Rc::new(callbacks)); |
| gatt_db.remove_service_at_handle(AttHandle(4)).unwrap(); |
| |
| // assert: we got the callback |
| let event = rx.blocking_recv().unwrap(); |
| let MockCallbackEvents::OnServiceChange(range) = event else { |
| unreachable!(); |
| }; |
| assert_eq!(*range.start(), AttHandle(4)); |
| assert_eq!(*range.end(), AttHandle(4)); |
| } |
| |
| #[test] |
| fn test_write_no_response_single_characteristic() { |
| // arrange: create a database with a single characteristic |
| let (gatt_datastore, mut data_evts) = MockRawDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::WRITABLE_WITHOUT_RESPONSE, |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| let data = |
| build_view_or_crash(build_att_data(AttAttributeDataChild::RawData(Box::new([1, 2])))); |
| |
| // act: write without response to the database |
| att_db.write_no_response_attribute(CHARACTERISTIC_VALUE_HANDLE, data.view()); |
| |
| // assert: we got a callback |
| let event = data_evts.blocking_recv().unwrap(); |
| let MockRawDatastoreEvents::WriteNoResponse(TCB_IDX, CHARACTERISTIC_VALUE_HANDLE, AttributeBackingType::Characteristic, recv_data) = event else { |
| unreachable!("{event:?}"); |
| }; |
| assert_eq!( |
| recv_data.view().get_raw_payload().collect::<Vec<_>>(), |
| data.view().get_raw_payload().collect::<Vec<_>>() |
| ); |
| } |
| |
| #[test] |
| fn test_unwriteable_without_response_characteristic() { |
| // arrange: db with a characteristic that is writable, but not writable-without-response |
| let (gatt_datastore, mut data_events) = MockRawDatastore::new(); |
| let gatt_db = SharedBox::new(GattDatabase::new()); |
| gatt_db |
| .add_service_with_handles( |
| GattServiceWithHandle { |
| handle: SERVICE_HANDLE, |
| type_: SERVICE_TYPE, |
| characteristics: vec![GattCharacteristicWithHandle { |
| handle: CHARACTERISTIC_VALUE_HANDLE, |
| type_: CHARACTERISTIC_TYPE, |
| permissions: AttPermissions::READABLE |
| | AttPermissions::WRITABLE_WITH_RESPONSE, |
| descriptors: vec![], |
| }], |
| }, |
| Rc::new(gatt_datastore), |
| ) |
| .unwrap(); |
| let att_db = gatt_db.get_att_database(TCB_IDX); |
| let data = |
| build_view_or_crash(build_att_data(AttAttributeDataChild::RawData(Box::new([1, 2])))); |
| |
| // act: try writing without response to this characteristic |
| att_db.write_no_response_attribute(CHARACTERISTIC_VALUE_HANDLE, data.view()); |
| |
| // assert: no callback was sent |
| assert_eq!(data_events.try_recv().unwrap_err(), TryRecvError::Empty); |
| } |
| } |
