bumble 0.0.198__tar.gz → 0.0.199__tar.gz

{bumble-0.0.198/bumble.egg-info → bumble-0.0.199}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bumble
-Version: 0.0.198
+Version: 0.0.199
 Summary: Bluetooth Stack for Apps, Emulation, Test and Experimentation
 Home-page: https://github.com/google/bumble
 Author: Google

{bumble-0.0.198 → bumble-0.0.199}/apps/pair.py

@@ -46,6 +46,12 @@ from bumble.att import (
     ATT_INSUFFICIENT_AUTHENTICATION_ERROR,
     ATT_INSUFFICIENT_ENCRYPTION_ERROR,
 )
+from bumble.utils import AsyncRunner
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+POST_PAIRING_DELAY = 1
 
 
 # -----------------------------------------------------------------------------
@@ -235,8 +241,10 @@ def on_connection(connection, request):
 
     # Listen for pairing events
     connection.on('pairing_start', on_pairing_start)
-    connection.on('pairing', lambda keys: on_pairing(connection.peer_address, keys))
-    connection.on('pairing_failure', on_pairing_failure)
+    connection.on('pairing', lambda keys: on_pairing(connection, keys))
+    connection.on(
+        'pairing_failure', lambda reason: on_pairing_failure(connection, reason)
+    )
 
     # Listen for encryption changes
     connection.on(
@@ -270,19 +278,24 @@ def on_pairing_start():
 
 
 # -----------------------------------------------------------------------------
-def on_pairing(address, keys):
+@AsyncRunner.run_in_task()
+async def on_pairing(connection, keys):
     print(color('***-----------------------------------', 'cyan'))
-    print(color(f'*** Paired! (peer identity={address})', 'cyan'))
+    print(color(f'*** Paired! (peer identity={connection.peer_address})', 'cyan'))
     keys.print(prefix=color('*** ', 'cyan'))
     print(color('***-----------------------------------', 'cyan'))
+    await asyncio.sleep(POST_PAIRING_DELAY)
+    await connection.disconnect()
     Waiter.instance.terminate()
 
 
 # -----------------------------------------------------------------------------
-def on_pairing_failure(reason):
+@AsyncRunner.run_in_task()
+async def on_pairing_failure(connection, reason):
     print(color('***-----------------------------------', 'red'))
     print(color(f'*** Pairing failed: {smp_error_name(reason)}', 'red'))
     print(color('***-----------------------------------', 'red'))
+    await connection.disconnect()
     Waiter.instance.terminate()
 
 
@@ -293,6 +306,7 @@ async def pair(
     mitm,
     bond,
     ctkd,
+    identity_address,
     linger,
     io,
     oob,
@@ -382,11 +396,18 @@ async def pair(
             oob_contexts = None
 
         # Set up a pairing config factory
+        if identity_address == 'public':
+            identity_address_type = PairingConfig.AddressType.PUBLIC
+        elif identity_address == 'random':
+            identity_address_type = PairingConfig.AddressType.RANDOM
+        else:
+            identity_address_type = None
         device.pairing_config_factory = lambda connection: PairingConfig(
             sc=sc,
             mitm=mitm,
             bonding=bond,
             oob=oob_contexts,
+            identity_address_type=identity_address_type,
             delegate=Delegate(mode, connection, io, prompt),
         )
 
@@ -457,6 +478,10 @@ class LogHandler(logging.Handler):
     help='Enable CTKD',
     show_default=True,
 )
+@click.option(
+    '--identity-address',
+    type=click.Choice(['random', 'public']),
+)
 @click.option('--linger', default=False, is_flag=True, help='Linger after pairing')
 @click.option(
     '--io',
@@ -493,6 +518,7 @@ def main(
     mitm,
     bond,
     ctkd,
+    identity_address,
     linger,
     io,
     oob,
@@ -518,6 +544,7 @@ def main(
             mitm,
             bond,
             ctkd,
+            identity_address,
             linger,
             io,
             oob,

{bumble-0.0.198 → bumble-0.0.199}/bumble/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.198'
-__version_tuple__ = version_tuple = (0, 0, 198)
+__version__ = version = '0.0.199'
+__version_tuple__ = version_tuple = (0, 0, 199)

{bumble-0.0.198 → bumble-0.0.199}/bumble/att.py

@@ -23,6 +23,7 @@
 # Imports
 # -----------------------------------------------------------------------------
 from __future__ import annotations
+
 import enum
 import functools
 import inspect
@@ -41,6 +42,7 @@ from typing import (
 
 from pyee import EventEmitter
 
+from bumble import utils
 from bumble.core import UUID, name_or_number, ProtocolError
 from bumble.hci import HCI_Object, key_with_value
 from bumble.colors import color
@@ -145,43 +147,57 @@ ATT_RESPONSES = [
     ATT_EXECUTE_WRITE_RESPONSE
 ]
 
-ATT_INVALID_HANDLE_ERROR                   = 0x01
-ATT_READ_NOT_PERMITTED_ERROR               = 0x02
-ATT_WRITE_NOT_PERMITTED_ERROR              = 0x03
-ATT_INVALID_PDU_ERROR                      = 0x04
-ATT_INSUFFICIENT_AUTHENTICATION_ERROR      = 0x05
-ATT_REQUEST_NOT_SUPPORTED_ERROR            = 0x06
-ATT_INVALID_OFFSET_ERROR                   = 0x07
-ATT_INSUFFICIENT_AUTHORIZATION_ERROR       = 0x08
-ATT_PREPARE_QUEUE_FULL_ERROR               = 0x09
-ATT_ATTRIBUTE_NOT_FOUND_ERROR              = 0x0A
-ATT_ATTRIBUTE_NOT_LONG_ERROR               = 0x0B
-ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR = 0x0C
-ATT_INVALID_ATTRIBUTE_LENGTH_ERROR         = 0x0D
-ATT_UNLIKELY_ERROR_ERROR                   = 0x0E
-ATT_INSUFFICIENT_ENCRYPTION_ERROR          = 0x0F
-ATT_UNSUPPORTED_GROUP_TYPE_ERROR           = 0x10
-ATT_INSUFFICIENT_RESOURCES_ERROR           = 0x11
-
-ATT_ERROR_NAMES = {
-    ATT_INVALID_HANDLE_ERROR:                   'ATT_INVALID_HANDLE_ERROR',
-    ATT_READ_NOT_PERMITTED_ERROR:               'ATT_READ_NOT_PERMITTED_ERROR',
-    ATT_WRITE_NOT_PERMITTED_ERROR:              'ATT_WRITE_NOT_PERMITTED_ERROR',
-    ATT_INVALID_PDU_ERROR:                      'ATT_INVALID_PDU_ERROR',
-    ATT_INSUFFICIENT_AUTHENTICATION_ERROR:      'ATT_INSUFFICIENT_AUTHENTICATION_ERROR',
-    ATT_REQUEST_NOT_SUPPORTED_ERROR:            'ATT_REQUEST_NOT_SUPPORTED_ERROR',
-    ATT_INVALID_OFFSET_ERROR:                   'ATT_INVALID_OFFSET_ERROR',
-    ATT_INSUFFICIENT_AUTHORIZATION_ERROR:       'ATT_INSUFFICIENT_AUTHORIZATION_ERROR',
-    ATT_PREPARE_QUEUE_FULL_ERROR:               'ATT_PREPARE_QUEUE_FULL_ERROR',
-    ATT_ATTRIBUTE_NOT_FOUND_ERROR:              'ATT_ATTRIBUTE_NOT_FOUND_ERROR',
-    ATT_ATTRIBUTE_NOT_LONG_ERROR:               'ATT_ATTRIBUTE_NOT_LONG_ERROR',
-    ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR: 'ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR',
-    ATT_INVALID_ATTRIBUTE_LENGTH_ERROR:         'ATT_INVALID_ATTRIBUTE_LENGTH_ERROR',
-    ATT_UNLIKELY_ERROR_ERROR:                   'ATT_UNLIKELY_ERROR_ERROR',
-    ATT_INSUFFICIENT_ENCRYPTION_ERROR:          'ATT_INSUFFICIENT_ENCRYPTION_ERROR',
-    ATT_UNSUPPORTED_GROUP_TYPE_ERROR:           'ATT_UNSUPPORTED_GROUP_TYPE_ERROR',
-    ATT_INSUFFICIENT_RESOURCES_ERROR:           'ATT_INSUFFICIENT_RESOURCES_ERROR'
-}
+class ErrorCode(utils.OpenIntEnum):
+    '''
+    See
+
+    * Bluetooth spec @ Vol 3, Part F - 3.4.1.1 Error Response
+    * Core Specification Supplement: Common Profile And Service Error Codes
+    '''
+    INVALID_HANDLE                   = 0x01
+    READ_NOT_PERMITTED               = 0x02
+    WRITE_NOT_PERMITTED              = 0x03
+    INVALID_PDU                      = 0x04
+    INSUFFICIENT_AUTHENTICATION      = 0x05
+    REQUEST_NOT_SUPPORTED            = 0x06
+    INVALID_OFFSET                   = 0x07
+    INSUFFICIENT_AUTHORIZATION       = 0x08
+    PREPARE_QUEUE_FULL               = 0x09
+    ATTRIBUTE_NOT_FOUND              = 0x0A
+    ATTRIBUTE_NOT_LONG               = 0x0B
+    INSUFFICIENT_ENCRYPTION_KEY_SIZE = 0x0C
+    INVALID_ATTRIBUTE_LENGTH         = 0x0D
+    UNLIKELY_ERROR                   = 0x0E
+    INSUFFICIENT_ENCRYPTION          = 0x0F
+    UNSUPPORTED_GROUP_TYPE           = 0x10
+    INSUFFICIENT_RESOURCES           = 0x11
+    DATABASE_OUT_OF_SYNC             = 0x12
+    VALUE_NOT_ALLOWED                = 0x13
+    # 0x80 – 0x9F: Application Error
+    # 0xE0 – 0xFF: Common Profile and Service Error Codes
+    WRITE_REQUEST_REJECTED           = 0xFC
+    CCCD_IMPROPERLY_CONFIGURED       = 0xFD
+    PROCEDURE_ALREADY_IN_PROGRESS    = 0xFE
+    OUT_OF_RANGE                     = 0xFF
+
+# Backward Compatible Constants
+ATT_INVALID_HANDLE_ERROR                   = ErrorCode.INVALID_HANDLE
+ATT_READ_NOT_PERMITTED_ERROR               = ErrorCode.READ_NOT_PERMITTED
+ATT_WRITE_NOT_PERMITTED_ERROR              = ErrorCode.WRITE_NOT_PERMITTED
+ATT_INVALID_PDU_ERROR                      = ErrorCode.INVALID_PDU
+ATT_INSUFFICIENT_AUTHENTICATION_ERROR      = ErrorCode.INSUFFICIENT_AUTHENTICATION
+ATT_REQUEST_NOT_SUPPORTED_ERROR            = ErrorCode.REQUEST_NOT_SUPPORTED
+ATT_INVALID_OFFSET_ERROR                   = ErrorCode.INVALID_OFFSET
+ATT_INSUFFICIENT_AUTHORIZATION_ERROR       = ErrorCode.INSUFFICIENT_AUTHORIZATION
+ATT_PREPARE_QUEUE_FULL_ERROR               = ErrorCode.PREPARE_QUEUE_FULL
+ATT_ATTRIBUTE_NOT_FOUND_ERROR              = ErrorCode.ATTRIBUTE_NOT_FOUND
+ATT_ATTRIBUTE_NOT_LONG_ERROR               = ErrorCode.ATTRIBUTE_NOT_LONG
+ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR = ErrorCode.INSUFFICIENT_ENCRYPTION_KEY_SIZE
+ATT_INVALID_ATTRIBUTE_LENGTH_ERROR         = ErrorCode.INVALID_ATTRIBUTE_LENGTH
+ATT_UNLIKELY_ERROR_ERROR                   = ErrorCode.UNLIKELY_ERROR
+ATT_INSUFFICIENT_ENCRYPTION_ERROR          = ErrorCode.INSUFFICIENT_ENCRYPTION
+ATT_UNSUPPORTED_GROUP_TYPE_ERROR           = ErrorCode.UNSUPPORTED_GROUP_TYPE
+ATT_INSUFFICIENT_RESOURCES_ERROR           = ErrorCode.INSUFFICIENT_RESOURCES
 
 ATT_DEFAULT_MTU = 23
 
@@ -245,9 +261,9 @@ class ATT_PDU:
     def pdu_name(op_code):
         return name_or_number(ATT_PDU_NAMES, op_code, 2)
 
-    @staticmethod
-    def error_name(error_code):
-        return name_or_number(ATT_ERROR_NAMES, error_code, 2)
+    @classmethod
+    def error_name(cls, error_code: int) -> str:
+        return ErrorCode(error_code).name
 
     @staticmethod
     def subclass(fields):

{bumble-0.0.198 → bumble-0.0.199}/bumble/avdtp.py

@@ -580,10 +580,10 @@ class ServiceCapabilities:
         self.service_category = service_category
         self.service_capabilities_bytes = service_capabilities_bytes
 
-    def to_string(self, details: List[str] = []) -> str:
+    def to_string(self, details: Optional[List[str]] = None) -> str:
         attributes = ','.join(
             [name_or_number(AVDTP_SERVICE_CATEGORY_NAMES, self.service_category)]
-            + details
+            + (details or [])
         )
         return f'ServiceCapabilities({attributes})'
 

{bumble-0.0.198 → bumble-0.0.199}/bumble/decoder.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Union
+
 # -----------------------------------------------------------------------------
 # Constants
 # -----------------------------------------------------------------------------
@@ -149,7 +151,7 @@ QMF_COEFFS = [3, -11, 12, 32, -210, 951, 3876, -805, 362, -156, 53, -11]
 # -----------------------------------------------------------------------------
 # Classes
 # -----------------------------------------------------------------------------
-class G722Decoder(object):
+class G722Decoder:
     """G.722 decoder with bitrate 64kbit/s.
 
     For the Blocks in the sub-band decoders, please refer to the G.722
@@ -157,7 +159,7 @@ class G722Decoder(object):
     https://www.itu.int/rec/T-REC-G.722-201209-I
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._x = [0] * 24
         self._band = [Band(), Band()]
         # The initial value in BLOCK 3L
@@ -165,12 +167,12 @@ class G722Decoder(object):
         # The initial value in BLOCK 3H
         self._band[1].det = 8
 
-    def decode_frame(self, encoded_data) -> bytearray:
+    def decode_frame(self, encoded_data: Union[bytes, bytearray]) -> bytearray:
         result_array = bytearray(len(encoded_data) * 4)
         self.g722_decode(result_array, encoded_data)
         return result_array
 
-    def g722_decode(self, result_array, encoded_data) -> int:
+    def g722_decode(self, result_array, encoded_data: Union[bytes, bytearray]) -> int:
         """Decode the data frame using g722 decoder."""
         result_length = 0
 
@@ -198,14 +200,16 @@ class G722Decoder(object):
 
         return result_length
 
-    def update_decoded_result(self, xout, byte_length, byte_array) -> int:
+    def update_decoded_result(
+        self, xout: int, byte_length: int, byte_array: bytearray
+    ) -> int:
         result = (int)(xout >> 11)
         bytes_result = result.to_bytes(2, 'little', signed=True)
         byte_array[byte_length] = bytes_result[0]
         byte_array[byte_length + 1] = bytes_result[1]
         return byte_length + 2
 
-    def lower_sub_band_decoder(self, lower_bits) -> int:
+    def lower_sub_band_decoder(self, lower_bits: int) -> int:
         """Lower sub-band decoder for last six bits."""
 
         # Block 5L
@@ -258,7 +262,7 @@ class G722Decoder(object):
 
         return rlow
 
-    def higher_sub_band_decoder(self, higher_bits) -> int:
+    def higher_sub_band_decoder(self, higher_bits: int) -> int:
         """Higher sub-band decoder for first two bits."""
 
         # Block 2H
@@ -306,14 +310,14 @@ class G722Decoder(object):
 
 
 # -----------------------------------------------------------------------------
-class Band(object):
-    """Structure for G722 decode proccessing."""
+class Band:
+    """Structure for G722 decode processing."""
 
     s: int = 0
     nb: int = 0
     det: int = 0
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._sp = 0
         self._sz = 0
         self._r = [0] * 3

{bumble-0.0.198 → bumble-0.0.199}/bumble/drivers/rtk.py

@@ -301,6 +301,8 @@ class Driver(common.Driver):
         fw_name: str = ""
         config_name: str = ""
 
+    POST_RESET_DELAY: float = 0.2
+
     DRIVER_INFOS = [
         # 8723A
         DriverInfo(
@@ -495,12 +497,24 @@ class Driver(common.Driver):
 
     @classmethod
     async def driver_info_for_host(cls, host):
-        await host.send_command(HCI_Reset_Command(), check_result=True)
-        host.ready = True  # Needed to let the host know the controller is ready.
+        try:
+            await host.send_command(
+                HCI_Reset_Command(),
+                check_result=True,
+                response_timeout=cls.POST_RESET_DELAY,
+            )
+            host.ready = True  # Needed to let the host know the controller is ready.
+        except asyncio.exceptions.TimeoutError:
+            logger.warning("timeout waiting for hci reset, retrying")
+            await host.send_command(HCI_Reset_Command(), check_result=True)
+            host.ready = True
+
+        command = HCI_Read_Local_Version_Information_Command()
+        response = await host.send_command(command, check_result=True)
+        if response.command_opcode != command.op_code:
+            logger.error("failed to probe local version information")
+            return None
 
-        response = await host.send_command(
-            HCI_Read_Local_Version_Information_Command(), check_result=True
-        )
         local_version = response.return_parameters
 
         logger.debug(

{bumble-0.0.198 → bumble-0.0.199}/bumble/gatt.py

@@ -238,22 +238,22 @@ GATT_SEARCH_CONTROL_POINT_CHARACTERISTIC                  = UUID.from_16_bits(0x
 GATT_CONTENT_CONTROL_ID_CHARACTERISTIC                    = UUID.from_16_bits(0x2BBA, 'Content Control Id')
 
 # Telephone Bearer Service (TBS)
-GATT_BEARER_PROVIDER_NAME_CHARACTERISTIC                      = UUID.from_16_bits(0x2BB4, 'Bearer Provider Name')
-GATT_BEARER_UCI_CHARACTERISTIC                                = UUID.from_16_bits(0x2BB5, 'Bearer UCI')
-GATT_BEARER_TECHNOLOGY_CHARACTERISTIC                         = UUID.from_16_bits(0x2BB6, 'Bearer Technology')
-GATT_BEARER_URI_SCHEMES_SUPPORTED_LIST_CHARACTERISTIC         = UUID.from_16_bits(0x2BB7, 'Bearer URI Schemes Supported List')
-GATT_BEARER_SIGNAL_STRENGTH_CHARACTERISTIC                    = UUID.from_16_bits(0x2BB8, 'Bearer Signal Strength')
-GATT_BEARER_SIGNAL_STRENGTH_REPORTING_INTERVAL_CHARACTERISTIC = UUID.from_16_bits(0x2BB9, 'Bearer Signal Strength Reporting Interval')
-GATT_BEARER_LIST_CURRENT_CALLS_CHARACTERISTIC                 = UUID.from_16_bits(0x2BBA, 'Bearer List Current Calls')
-GATT_CONTENT_CONTROL_ID_CHARACTERISTIC                        = UUID.from_16_bits(0x2BBB, 'Content Control ID')
-GATT_STATUS_FLAGS_CHARACTERISTIC                              = UUID.from_16_bits(0x2BBC, 'Status Flags')
-GATT_INCOMING_CALL_TARGET_BEARER_URI_CHARACTERISTIC           = UUID.from_16_bits(0x2BBD, 'Incoming Call Target Bearer URI')
-GATT_CALL_STATE_CHARACTERISTIC                                = UUID.from_16_bits(0x2BBE, 'Call State')
-GATT_CALL_CONTROL_POINT_CHARACTERISTIC                        = UUID.from_16_bits(0x2BBF, 'Call Control Point')
-GATT_CALL_CONTROL_POINT_OPTIONAL_OPCODES_CHARACTERISTIC       = UUID.from_16_bits(0x2BC0, 'Call Control Point Optional Opcodes')
-GATT_TERMINATION_REASON_CHARACTERISTIC                        = UUID.from_16_bits(0x2BC1, 'Termination Reason')
-GATT_INCOMING_CALL_CHARACTERISTIC                             = UUID.from_16_bits(0x2BC2, 'Incoming Call')
-GATT_CALL_FRIENDLY_NAME_CHARACTERISTIC                        = UUID.from_16_bits(0x2BC3, 'Call Friendly Name')
+GATT_BEARER_PROVIDER_NAME_CHARACTERISTIC                      = UUID.from_16_bits(0x2BB3, 'Bearer Provider Name')
+GATT_BEARER_UCI_CHARACTERISTIC                                = UUID.from_16_bits(0x2BB4, 'Bearer UCI')
+GATT_BEARER_TECHNOLOGY_CHARACTERISTIC                         = UUID.from_16_bits(0x2BB5, 'Bearer Technology')
+GATT_BEARER_URI_SCHEMES_SUPPORTED_LIST_CHARACTERISTIC         = UUID.from_16_bits(0x2BB6, 'Bearer URI Schemes Supported List')
+GATT_BEARER_SIGNAL_STRENGTH_CHARACTERISTIC                    = UUID.from_16_bits(0x2BB7, 'Bearer Signal Strength')
+GATT_BEARER_SIGNAL_STRENGTH_REPORTING_INTERVAL_CHARACTERISTIC = UUID.from_16_bits(0x2BB8, 'Bearer Signal Strength Reporting Interval')
+GATT_BEARER_LIST_CURRENT_CALLS_CHARACTERISTIC                 = UUID.from_16_bits(0x2BB9, 'Bearer List Current Calls')
+GATT_CONTENT_CONTROL_ID_CHARACTERISTIC                        = UUID.from_16_bits(0x2BBA, 'Content Control ID')
+GATT_STATUS_FLAGS_CHARACTERISTIC                              = UUID.from_16_bits(0x2BBB, 'Status Flags')
+GATT_INCOMING_CALL_TARGET_BEARER_URI_CHARACTERISTIC           = UUID.from_16_bits(0x2BBC, 'Incoming Call Target Bearer URI')
+GATT_CALL_STATE_CHARACTERISTIC                                = UUID.from_16_bits(0x2BBD, 'Call State')
+GATT_CALL_CONTROL_POINT_CHARACTERISTIC                        = UUID.from_16_bits(0x2BBE, 'Call Control Point')
+GATT_CALL_CONTROL_POINT_OPTIONAL_OPCODES_CHARACTERISTIC       = UUID.from_16_bits(0x2BBF, 'Call Control Point Optional Opcodes')
+GATT_TERMINATION_REASON_CHARACTERISTIC                        = UUID.from_16_bits(0x2BC0, 'Termination Reason')
+GATT_INCOMING_CALL_CHARACTERISTIC                             = UUID.from_16_bits(0x2BC1, 'Incoming Call')
+GATT_CALL_FRIENDLY_NAME_CHARACTERISTIC                        = UUID.from_16_bits(0x2BC2, 'Call Friendly Name')
 
 # Microphone Control Service (MICS)
 GATT_MUTE_CHARACTERISTIC = UUID.from_16_bits(0x2BC3, 'Mute')
@@ -275,6 +275,11 @@ GATT_SOURCE_AUDIO_LOCATION_CHARACTERISTIC       = UUID.from_16_bits(0x2BCC, 'Sou
 GATT_AVAILABLE_AUDIO_CONTEXTS_CHARACTERISTIC    = UUID.from_16_bits(0x2BCD, 'Available Audio Contexts')
 GATT_SUPPORTED_AUDIO_CONTEXTS_CHARACTERISTIC    = UUID.from_16_bits(0x2BCE, 'Supported Audio Contexts')
 
+# Hearing Access Service
+GATT_HEARING_AID_FEATURES_CHARACTERISTIC             = UUID.from_16_bits(0x2BDA, 'Hearing Aid Features')
+GATT_HEARING_AID_PRESET_CONTROL_POINT_CHARACTERISTIC = UUID.from_16_bits(0x2BDB, 'Hearing Aid Preset Control Point')
+GATT_ACTIVE_PRESET_INDEX_CHARACTERISTIC              = UUID.from_16_bits(0x2BDC, 'Active Preset Index')
+
 # ASHA Service
 GATT_ASHA_SERVICE                             = UUID.from_16_bits(0xFDF0, 'Audio Streaming for Hearing Aid')
 GATT_ASHA_READ_ONLY_PROPERTIES_CHARACTERISTIC = UUID('6333651e-c481-4a3e-9169-7c902aad37bb', 'ReadOnlyProperties')
@@ -340,7 +345,7 @@ class Service(Attribute):
         uuid: Union[str, UUID],
         characteristics: List[Characteristic],
         primary=True,
-        included_services: List[Service] = [],
+        included_services: Iterable[Service] = (),
     ) -> None:
         # Convert the uuid to a UUID object if it isn't already
         if isinstance(uuid, str):
@@ -356,7 +361,7 @@ class Service(Attribute):
             uuid.to_pdu_bytes(),
         )
         self.uuid = uuid
-        self.included_services = included_services[:]
+        self.included_services = list(included_services)
         self.characteristics = characteristics[:]
         self.primary = primary
 
@@ -390,7 +395,7 @@ class TemplateService(Service):
         self,
         characteristics: List[Characteristic],
         primary: bool = True,
-        included_services: List[Service] = [],
+        included_services: Iterable[Service] = (),
     ) -> None:
         super().__init__(self.UUID, characteristics, primary, included_services)
 

{bumble-0.0.198 → bumble-0.0.199}/bumble/gatt_client.py

@@ -68,7 +68,7 @@ from .att import (
     ATT_Error,
 )
 from . import core
-from .core import UUID, InvalidStateError, ProtocolError
+from .core import UUID, InvalidStateError
 from .gatt import (
     GATT_CHARACTERISTIC_ATTRIBUTE_TYPE,
     GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR,
@@ -345,12 +345,7 @@ class Client:
         self.mtu_exchange_done = True
         response = await self.send_request(ATT_Exchange_MTU_Request(client_rx_mtu=mtu))
         if response.op_code == ATT_ERROR_RESPONSE:
-            raise ProtocolError(
-                response.error_code,
-                'att',
-                ATT_PDU.error_name(response.error_code),
-                response,
-            )
+            raise ATT_Error(error_code=response.error_code, message=response)
 
         # Compute the final MTU
         self.connection.att_mtu = min(mtu, response.server_rx_mtu)
@@ -936,12 +931,7 @@ class Client:
         if response is None:
             raise TimeoutError('read timeout')
         if response.op_code == ATT_ERROR_RESPONSE:
-            raise ProtocolError(
-                response.error_code,
-                'att',
-                ATT_PDU.error_name(response.error_code),
-                response,
-            )
+            raise ATT_Error(error_code=response.error_code, message=response)
 
         # If the value is the max size for the MTU, try to read more unless the caller
         # specifically asked not to do that
@@ -963,12 +953,7 @@ class Client:
                         ATT_INVALID_OFFSET_ERROR,
                     ):
                         break
-                    raise ProtocolError(
-                        response.error_code,
-                        'att',
-                        ATT_PDU.error_name(response.error_code),
-                        response,
-                    )
+                    raise ATT_Error(error_code=response.error_code, message=response)
 
                 part = response.part_attribute_value
                 attribute_value += part
@@ -1061,12 +1046,7 @@ class Client:
                 )
             )
             if response.op_code == ATT_ERROR_RESPONSE:
-                raise ProtocolError(
-                    response.error_code,
-                    'att',
-                    ATT_PDU.error_name(response.error_code),
-                    response,
-                )
+                raise ATT_Error(error_code=response.error_code, message=response)
         else:
             await self.send_command(
                 ATT_Write_Command(

{bumble-0.0.198 → bumble-0.0.199}/bumble/gatt_server.py

@@ -915,7 +915,7 @@ class Server(EventEmitter):
         See Bluetooth spec Vol 3, Part F - 3.4.5.1 Write Request
         '''
 
-        # Check  that the attribute exists
+        # Check that the attribute exists
         attribute = self.get_attribute(request.attribute_handle)
         if attribute is None:
             self.send_response(
@@ -942,11 +942,19 @@ class Server(EventEmitter):
             )
             return
 
-        # Accept the value
-        await attribute.write_value(connection, request.attribute_value)
-
-        # Done
-        self.send_response(connection, ATT_Write_Response())
+        try:
+            # Accept the value
+            await attribute.write_value(connection, request.attribute_value)
+        except ATT_Error as error:
+            response = ATT_Error_Response(
+                request_opcode_in_error=request.op_code,
+                attribute_handle_in_error=request.attribute_handle,
+                error_code=error.error_code,
+            )
+        else:
+            # Done
+            response = ATT_Write_Response()
+        self.send_response(connection, response)
 
     @AsyncRunner.run_in_task()
     async def on_att_write_command(self, connection, request):