| # Copyright 2019 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Server side bluetooth GATT client helper class for testing""" |
| |
| import base64 |
| import json |
| |
| |
| class GATT_ClientFacade(object): |
| """A wrapper for getting GATT application from GATT server""" |
| |
| def __init__(self, bluetooth_facade): |
| """Initialize a GATT_ClientFacade |
| |
| @param bluetooth_facade: facade to communicate with adapter in DUT |
| |
| """ |
| self.bluetooth_facade = bluetooth_facade |
| |
| |
| def browse(self, address): |
| """Browse the application on GATT server |
| |
| @param address: a string of MAC address of the GATT server device |
| |
| @return: GATT_Application object |
| |
| """ |
| attr_map_json = json.loads(self.bluetooth_facade.\ |
| get_gatt_attributes_map(address)) |
| application = GATT_Application() |
| application.browse(attr_map_json, self.bluetooth_facade) |
| |
| return application |
| |
| |
| class GATT_Application(object): |
| """A GATT client application class""" |
| |
| def __init__(self): |
| """Initialize a GATT Application""" |
| self.services = dict() |
| |
| |
| def browse(self, attr_map_json, bluetooth_facade): |
| """Browse the application on GATT server |
| |
| @param attr_map_json: a json object returned by |
| bluetooth_device_xmlrpc_server |
| |
| @bluetooth_facade: facade to communicate with adapter in DUT |
| |
| """ |
| servs_json = attr_map_json['services'] |
| for uuid in servs_json: |
| path = servs_json[uuid]['path'] |
| service_obj = GATT_Service(uuid, path, bluetooth_facade) |
| service_obj.read_properties() |
| self.add_service(service_obj) |
| |
| chrcs_json = servs_json[uuid]['characteristics'] |
| for uuid in chrcs_json: |
| path = chrcs_json[uuid]['path'] |
| chrc_obj = GATT_Characteristic(uuid, path, bluetooth_facade) |
| chrc_obj.read_properties() |
| service_obj.add_characteristic(chrc_obj) |
| |
| descs_json = chrcs_json[uuid]['descriptors'] |
| for uuid in descs_json: |
| path = descs_json[uuid]['path'] |
| desc_obj = GATT_Descriptor(uuid, path, bluetooth_facade) |
| desc_obj.read_properties() |
| chrc_obj.add_descriptor(desc_obj) |
| |
| |
| def find_by_uuid(self, uuid): |
| """Find attribute under this application by specifying UUID |
| |
| @param uuid: string of UUID |
| |
| @return: Attribute object if found, |
| none otherwise |
| """ |
| for serv_uuid, serv in self.services.items(): |
| found = serv.find_by_uuid(uuid) |
| if found: |
| return found |
| return None |
| |
| |
| def add_service(self, service): |
| """Add a service into this application""" |
| self.services[service.uuid] = service |
| |
| |
| @staticmethod |
| def diff(appl_a, appl_b): |
| """Compare two Applications, and return their difference |
| |
| @param appl_a: the first application which is going to be compared |
| |
| @param appl_b: the second application which is going to be compared |
| |
| @return: a list of string, each describes one difference |
| |
| """ |
| result = [] |
| |
| uuids_a = set(appl_a.services.keys()) |
| uuids_b = set(appl_b.services.keys()) |
| uuids = uuids_a.union(uuids_b) |
| |
| for uuid in uuids: |
| serv_a = appl_a.services.get(uuid, None) |
| serv_b = appl_b.services.get(uuid, None) |
| |
| if not serv_a or not serv_b: |
| result.append("Service %s is not included in both Applications:" |
| "%s vs %s" % (uuid, bool(serv_a), bool(serv_b))) |
| else: |
| result.extend(GATT_Service.diff(serv_a, serv_b)) |
| return result |
| |
| |
| class GATT_Service(object): |
| """GATT client service class""" |
| PROPERTIES = ['UUID', 'Primary', 'Device', 'Includes'] |
| |
| |
| def __init__(self, uuid, object_path, bluetooth_facade): |
| """Initialize a GATT service object |
| |
| @param uuid: string of UUID |
| |
| @param object_path: object path of this service |
| |
| @param bluetooth_facade: facade to communicate with adapter in DUT |
| |
| """ |
| self.uuid = uuid |
| self.object_path = object_path |
| self.bluetooth_facade = bluetooth_facade |
| self.properties = dict() |
| self.characteristics = dict() |
| |
| |
| def add_characteristic(self, chrc_obj): |
| """Add a characteristic attribute into service |
| |
| @param chrc_obj: a characteristic object |
| |
| """ |
| self.characteristics[chrc_obj.uuid] = chrc_obj |
| |
| |
| def read_properties(self): |
| """Read all properties in this service""" |
| for prop_name in self.PROPERTIES: |
| self.properties[prop_name] = self.read_property(prop_name) |
| return self.properties |
| |
| |
| def read_property(self, property_name): |
| """Read a property in this service |
| |
| @param property_name: string of the name of the property |
| |
| @return: the value of the property |
| |
| """ |
| return self.bluetooth_facade.get_gatt_service_property( |
| self.object_path, property_name) |
| |
| def find_by_uuid(self, uuid): |
| """Find attribute under this service by specifying UUID |
| |
| @param uuid: string of UUID |
| |
| @return: Attribute object if found, |
| none otherwise |
| |
| """ |
| if self.uuid == uuid: |
| return self |
| |
| for chrc_uuid, chrc in self.characteristics.items(): |
| found = chrc.find_by_uuid(uuid) |
| if found: |
| return found |
| return None |
| |
| |
| @staticmethod |
| def diff(serv_a, serv_b): |
| """Compare two Services, and return their difference |
| |
| @param serv_a: the first service which is going to be compared |
| |
| @param serv_b: the second service which is going to be compared |
| |
| @return: a list of string, each describes one difference |
| |
| """ |
| result = [] |
| |
| for prop_name in GATT_Service.PROPERTIES: |
| if serv_a.properties[prop_name] != serv_b.properties[prop_name]: |
| result.append("Service %s is different in %s: %s vs %s" % |
| (serv_a.uuid, prop_name, |
| serv_a.properties[prop_name], |
| serv_b.properties[prop_name])) |
| |
| uuids_a = set(serv_a.characteristics.keys()) |
| uuids_b = set(serv_b.characteristics.keys()) |
| uuids = uuids_a.union(uuids_b) |
| |
| for uuid in uuids: |
| chrc_a = serv_a.characteristics.get(uuid, None) |
| chrc_b = serv_b.characteristics.get(uuid, None) |
| |
| if not chrc_a or not chrc_b: |
| result.append("Characteristic %s is not included in both " |
| "Services: %s vs %s" % (uuid, bool(chrc_a), |
| bool(chrc_b))) |
| else: |
| result.extend(GATT_Characteristic.diff(chrc_a, chrc_b)) |
| return result |
| |
| |
| class GATT_Characteristic(object): |
| """GATT client characteristic class""" |
| |
| PROPERTIES = ['UUID', 'Service', 'Value', 'Notifying', 'Flags'] |
| |
| |
| def __init__(self, uuid, object_path, bluetooth_facade): |
| """Initialize a GATT characteristic object |
| |
| @param uuid: string of UUID |
| |
| @param object_path: object path of this characteristic |
| |
| @param bluetooth_facade: facade to communicate with adapter in DUT |
| |
| """ |
| self.uuid = uuid |
| self.object_path = object_path |
| self.bluetooth_facade = bluetooth_facade |
| self.properties = dict() |
| self.descriptors = dict() |
| |
| |
| def add_descriptor(self, desc_obj): |
| """Add a characteristic attribute into service |
| |
| @param desc_obj: a descriptor object |
| |
| """ |
| self.descriptors[desc_obj.uuid] = desc_obj |
| |
| |
| def read_properties(self): |
| """Read all properties in this characteristic""" |
| for prop_name in self.PROPERTIES: |
| self.properties[prop_name] = self.read_property(prop_name) |
| return self.properties |
| |
| |
| def read_property(self, property_name): |
| """Read a property in this characteristic |
| |
| @param property_name: string of the name of the property |
| |
| @return: the value of the property |
| |
| """ |
| return self.bluetooth_facade.get_gatt_characteristic_property( |
| self.object_path, property_name) |
| |
| |
| def find_by_uuid(self, uuid): |
| """Find attribute under this characteristic by specifying UUID |
| |
| @param uuid: string of UUID |
| |
| @return: Attribute object if found, |
| none otherwise |
| |
| """ |
| if self.uuid == uuid: |
| return self |
| |
| for desc_uuid, desc in self.descriptors.items(): |
| if desc_uuid == uuid: |
| return desc |
| return None |
| |
| |
| def read_value(self): |
| """Perform ReadValue in DUT and store it in property 'Value' |
| |
| @return: bytearray of the value |
| |
| """ |
| value = self.bluetooth_facade.gatt_characteristic_read_value( |
| self.uuid, self.object_path) |
| self.properties['Value'] = bytearray(base64.standard_b64decode(value)) |
| return self.properties['Value'] |
| |
| |
| @staticmethod |
| def diff(chrc_a, chrc_b): |
| """Compare two Characteristics, and return their difference |
| |
| @param serv_a: the first service which is going to be compared |
| |
| @param serv_b: the second service which is going to be compared |
| |
| @return: a list of string, each describes one difference |
| |
| """ |
| result = [] |
| |
| for prop_name in GATT_Characteristic.PROPERTIES: |
| if chrc_a.properties[prop_name] != chrc_b.properties[prop_name]: |
| result.append("Characteristic %s is different in %s: %s vs %s" |
| % (chrc_a.uuid, prop_name, |
| chrc_a.properties[prop_name], |
| chrc_b.properties[prop_name])) |
| |
| uuids_a = set(chrc_a.descriptors.keys()) |
| uuids_b = set(chrc_b.descriptors.keys()) |
| uuids = uuids_a.union(uuids_b) |
| |
| for uuid in uuids: |
| desc_a = chrc_a.descriptors.get(uuid, None) |
| desc_b = chrc_b.descriptors.get(uuid, None) |
| |
| if not desc_a or not desc_b: |
| result.append("Descriptor %s is not included in both" |
| "Characteristic: %s vs %s" % (uuid, bool(desc_a), |
| bool(desc_b))) |
| else: |
| result.extend(GATT_Descriptor.diff(desc_a, desc_b)) |
| return result |
| |
| |
| class GATT_Descriptor(object): |
| """GATT client descriptor class""" |
| |
| PROPERTIES = ['UUID', 'Characteristic', 'Value', 'Flags'] |
| |
| def __init__(self, uuid, object_path, bluetooth_facade): |
| """Initialize a GATT descriptor object |
| |
| @param uuid: string of UUID |
| |
| @param object_path: object path of this descriptor |
| |
| @param bluetooth_facade: facade to communicate with adapter in DUT |
| |
| """ |
| self.uuid = uuid |
| self.object_path = object_path |
| self.bluetooth_facade = bluetooth_facade |
| self.properties = dict() |
| |
| |
| def read_properties(self): |
| """Read all properties in this characteristic""" |
| for prop_name in self.PROPERTIES: |
| self.properties[prop_name] = self.read_property(prop_name) |
| return self.properties |
| |
| |
| def read_property(self, property_name): |
| """Read a property in this characteristic |
| |
| @param property_name: string of the name of the property |
| |
| @return: the value of the property |
| |
| """ |
| return self.bluetooth_facade.get_gatt_descriptor_property( |
| self.object_path, property_name) |
| |
| |
| def read_value(self): |
| """Perform ReadValue in DUT and store it in property 'Value' |
| |
| @return: bytearray of the value |
| |
| """ |
| value = self.bluetooth_facade.gatt_descriptor_read_value( |
| self.uuid, self.object_path) |
| self.properties['Value'] = bytearray(base64.standard_b64decode(value)) |
| |
| return self.properties['Value'] |
| |
| |
| @staticmethod |
| def diff(desc_a, desc_b): |
| """Compare two Descriptors, and return their difference |
| |
| @param serv_a: the first service which is going to be compared |
| |
| @param serv_b: the second service which is going to be compared |
| |
| @return: a list of string, each describes one difference |
| |
| """ |
| result = [] |
| |
| for prop_name in desc_a.properties.keys(): |
| if desc_a.properties[prop_name] != desc_b.properties[prop_name]: |
| result.append("Descriptor %s is different in %s: %s vs %s" % |
| (desc_a.uuid, prop_name, |
| desc_a.properties[prop_name], |
| desc_b.properties[prop_name])) |
| |
| return result |
| |
| |
| def UUID_Short2Full(uuid): |
| """Transform 2 bytes uuid string to 16 bytes |
| |
| @param uuid: 2 bytes shortened UUID string in hex |
| |
| @return: full uuid string |
| """ |
| uuid_template = '0000%s-0000-1000-8000-00805f9b34fb' |
| return uuid_template % uuid |
| |
| |
| class GATT_HIDApplication(GATT_Application): |
| """Default HID Application on Raspberry Pi GATT server |
| """ |
| |
| BatteryServiceUUID = UUID_Short2Full('180f') |
| BatteryLevelUUID = UUID_Short2Full('2a19') |
| CliChrcConfigUUID = UUID_Short2Full('2902') |
| GenericAttributeProfileUUID = UUID_Short2Full('1801') |
| ServiceChangedUUID = UUID_Short2Full('2a05') |
| DeviceInfoUUID = UUID_Short2Full('180a') |
| ManufacturerNameStrUUID = UUID_Short2Full('2a29') |
| PnPIDUUID = UUID_Short2Full('2a50') |
| GenericAccessProfileUUID = UUID_Short2Full('1800') |
| DeviceNameUUID = UUID_Short2Full('2a00') |
| AppearanceUUID = UUID_Short2Full('2a01') |
| |
| |
| def __init__(self): |
| """ |
| """ |
| GATT_Application.__init__(self) |
| BatteryService = GATT_Service(self.BatteryServiceUUID, None, None) |
| BatteryService.properties = { |
| 'UUID': BatteryService.uuid, |
| 'Primary': True, |
| 'Device': None, |
| 'Includes': [] |
| } |
| self.add_service(BatteryService) |
| |
| BatteryLevel = GATT_Characteristic(self.BatteryLevelUUID, None, None) |
| BatteryLevel.properties = { |
| 'UUID': BatteryLevel.uuid, |
| 'Service': None, |
| 'Value': [], |
| 'Notifying': False, |
| 'Flags': ['read', 'notify'] |
| } |
| BatteryService.add_characteristic(BatteryLevel) |
| |
| CliChrcConfig = GATT_Descriptor(self.CliChrcConfigUUID, None, None) |
| CliChrcConfig.properties = { |
| 'UUID': CliChrcConfig.uuid, |
| 'Characteristic': None, |
| 'Value': [], |
| 'Flags': None |
| } |
| |
| BatteryLevel.add_descriptor(CliChrcConfig) |
| |
| GenericAttributeProfile = GATT_Service(self.GenericAttributeProfileUUID, |
| None, None) |
| GenericAttributeProfile.properties = { |
| 'UUID': GenericAttributeProfile.uuid, |
| 'Primary': True, |
| 'Device': None, |
| 'Includes': [] |
| } |
| self.add_service(GenericAttributeProfile) |
| |
| ServiceChanged = GATT_Characteristic(self.ServiceChangedUUID, None, |
| None) |
| ServiceChanged.properties = { |
| 'UUID': ServiceChanged.uuid, |
| 'Service': None, |
| 'Value': [], |
| 'Notifying': False, |
| 'Flags': ['indicate'] |
| } |
| GenericAttributeProfile.add_characteristic(ServiceChanged) |
| |
| CliChrcConfig = GATT_Descriptor(self.CliChrcConfigUUID, None, None) |
| CliChrcConfig.properties = { |
| 'UUID': CliChrcConfig.uuid, |
| 'Characteristic': None, |
| 'Value': [], |
| 'Flags': None |
| } |
| ServiceChanged.add_descriptor(CliChrcConfig) |
| |
| DeviceInfo = GATT_Service(self.DeviceInfoUUID, None, None) |
| DeviceInfo.properties = { |
| 'UUID': DeviceInfo.uuid, |
| 'Primary': True, |
| 'Device': None, |
| 'Includes': [] |
| } |
| self.add_service(DeviceInfo) |
| |
| ManufacturerNameStr = GATT_Characteristic(self.ManufacturerNameStrUUID, |
| None, None) |
| ManufacturerNameStr.properties = { |
| 'UUID': ManufacturerNameStr.uuid, |
| 'Service': None, |
| 'Value': [], |
| 'Notifying': None, |
| 'Flags': ['read'] |
| } |
| DeviceInfo.add_characteristic(ManufacturerNameStr) |
| |
| PnPID = GATT_Characteristic(self.PnPIDUUID, None, None) |
| PnPID.properties = { |
| 'UUID': PnPID.uuid, |
| 'Service': None, |
| 'Value': [], |
| 'Notifying': None, |
| 'Flags': ['read'] |
| } |
| DeviceInfo.add_characteristic(PnPID) |
| |
| GenericAccessProfile = GATT_Service(self.GenericAccessProfileUUID, |
| None, None) |
| GenericAccessProfile.properties = { |
| 'UUID': GenericAccessProfile.uuid, |
| 'Primary': True, |
| 'Device': None, |
| 'Includes': [] |
| } |
| self.add_service(GenericAccessProfile) |
| |
| DeviceName = GATT_Characteristic(self.DeviceNameUUID, None, None) |
| DeviceName.properties = { |
| 'UUID': DeviceName.uuid, |
| 'Service': None, |
| 'Value': [], |
| 'Notifying': None, |
| 'Flags': ['read'] |
| } |
| GenericAccessProfile.add_characteristic(DeviceName) |
| |
| Appearance = GATT_Characteristic(self.AppearanceUUID, None, None) |
| Appearance.properties = { |
| 'UUID': Appearance.uuid, |
| 'Service': None, |
| 'Value': [], |
| 'Notifying': None, |
| 'Flags': ['read'] |
| } |
| GenericAccessProfile.add_characteristic(Appearance) |
