update websockets version (for better typecheck)

Fix Lint error in VCP example

.vscode/settings.json

@@ -74,6 +74,8 @@
         "substates",
         "tobytes",
         "tsep",
+        "UNMUTE",
+        "unmuted",
         "usbmodem",
         "vhci",
         "websockets",

apps/bench.py

@@ -50,10 +50,8 @@ from bumble.sdp import (
     SDP_PUBLIC_BROWSE_ROOT,
     SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
     SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-    SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
     DataElement,
     ServiceAttribute,
-    Client as SdpClient,
 )
 from bumble.transport import open_transport_or_link
 import bumble.rfcomm
@@ -89,6 +87,7 @@ DEFAULT_LINGER_TIME = 1.0
 DEFAULT_POST_CONNECTION_WAIT_TIME = 1.0
 
 DEFAULT_RFCOMM_CHANNEL = 8
+DEFAULT_RFCOMM_MTU = 2048
 
 
 # -----------------------------------------------------------------------------
@@ -198,48 +197,6 @@ def make_sdp_records(channel):
     }
 
 
-async def find_rfcomm_channel_with_uuid(connection: Connection, uuid: str) -> int:
-    # Connect to the SDP Server
-    sdp_client = SdpClient(connection)
-    await sdp_client.connect()
-
-    # Search for services with an L2CAP service attribute
-    search_result = await sdp_client.search_attributes(
-        [BT_L2CAP_PROTOCOL_ID],
-        [
-            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-        ],
-    )
-    for attribute_list in search_result:
-        service_uuid = None
-        service_class_id_list = ServiceAttribute.find_attribute_in_list(
-            attribute_list, SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID
-        )
-        if service_class_id_list:
-            if service_class_id_list.value:
-                for service_class_id in service_class_id_list.value:
-                    service_uuid = service_class_id.value
-        if str(service_uuid) != uuid:
-            # This service doesn't have a UUID or isn't the right one.
-            continue
-
-        # Look for the RFCOMM Channel number
-        protocol_descriptor_list = ServiceAttribute.find_attribute_in_list(
-            attribute_list, SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID
-        )
-        if protocol_descriptor_list:
-            for protocol_descriptor in protocol_descriptor_list.value:
-                if len(protocol_descriptor.value) >= 2:
-                    if protocol_descriptor.value[0].value == BT_RFCOMM_PROTOCOL_ID:
-                        await sdp_client.disconnect()
-                        return protocol_descriptor.value[1].value
-
-    await sdp_client.disconnect()
-    return 0
-
-
 def log_stats(title, stats):
     stats_min = min(stats)
     stats_max = max(stats)
@@ -940,11 +897,14 @@ class L2capServer(StreamedPacketIO):
 # RfcommClient
 # -----------------------------------------------------------------------------
 class RfcommClient(StreamedPacketIO):
-    def __init__(self, device, channel, uuid):
+    def __init__(self, device, channel, uuid, l2cap_mtu, max_frame_size, window_size):
         super().__init__()
         self.device = device
         self.channel = channel
         self.uuid = uuid
+        self.l2cap_mtu = l2cap_mtu
+        self.max_frame_size = max_frame_size
+        self.window_size = window_size
         self.rfcomm_session = None
         self.ready = asyncio.Event()
 
@@ -957,7 +917,9 @@ class RfcommClient(StreamedPacketIO):
             logging.info(
                 color(f'@@@ Discovering channel number from UUID {self.uuid}', 'cyan')
             )
-            channel = await find_rfcomm_channel_with_uuid(connection, self.uuid)
+            channel = await bumble.rfcomm.find_rfcomm_channel_with_uuid(
+                connection, self.uuid
+            )
             logging.info(color(f'@@@ Channel number = {channel}', 'cyan'))
             if channel == 0:
                 logging.info(color('!!! No RFComm service with this UUID found', 'red'))
@@ -966,13 +928,21 @@ class RfcommClient(StreamedPacketIO):
 
         # Create a client and start it
         logging.info(color('*** Starting RFCOMM client...', 'blue'))
-        rfcomm_client = bumble.rfcomm.Client(connection)
+        rfcomm_options = {}
+        if self.l2cap_mtu:
+            rfcomm_options['l2cap_mtu'] = self.l2cap_mtu
+        rfcomm_client = bumble.rfcomm.Client(connection, **rfcomm_options)
         rfcomm_mux = await rfcomm_client.start()
         logging.info(color('*** Started', 'blue'))
 
         logging.info(color(f'### Opening session for channel {channel}...', 'yellow'))
         try:
-            rfcomm_session = await rfcomm_mux.open_dlc(channel)
+            dlc_options = {}
+            if self.max_frame_size:
+                dlc_options['max_frame_size'] = self.max_frame_size
+            if self.window_size:
+                dlc_options['window_size'] = self.window_size
+            rfcomm_session = await rfcomm_mux.open_dlc(channel, **dlc_options)
             logging.info(color(f'### Session open: {rfcomm_session}', 'yellow'))
         except bumble.core.ConnectionError as error:
             logging.info(color(f'!!! Session open failed: {error}', 'red'))
@@ -997,13 +967,16 @@ class RfcommClient(StreamedPacketIO):
 # RfcommServer
 # -----------------------------------------------------------------------------
 class RfcommServer(StreamedPacketIO):
-    def __init__(self, device, channel):
+    def __init__(self, device, channel, l2cap_mtu):
         super().__init__()
         self.dlc = None
         self.ready = asyncio.Event()
 
         # Create and register a server
-        rfcomm_server = bumble.rfcomm.Server(device)
+        server_options = {}
+        if l2cap_mtu:
+            server_options['l2cap_mtu'] = l2cap_mtu
+        rfcomm_server = bumble.rfcomm.Server(device, **server_options)
 
         # Listen for incoming DLC connections
         channel_number = rfcomm_server.listen(self.on_dlc, channel)
@@ -1340,11 +1313,20 @@ def create_mode_factory(ctx, default_mode):
 
         if mode == 'rfcomm-client':
             return RfcommClient(
-                device, channel=ctx.obj['rfcomm_channel'], uuid=ctx.obj['rfcomm_uuid']
+                device,
+                channel=ctx.obj['rfcomm_channel'],
+                uuid=ctx.obj['rfcomm_uuid'],
+                l2cap_mtu=ctx.obj['rfcomm_l2cap_mtu'],
+                max_frame_size=ctx.obj['rfcomm_max_frame_size'],
+                window_size=ctx.obj['rfcomm_window_size'],
             )
 
         if mode == 'rfcomm-server':
-            return RfcommServer(device, channel=ctx.obj['rfcomm_channel'])
+            return RfcommServer(
+                device,
+                channel=ctx.obj['rfcomm_channel'],
+                l2cap_mtu=ctx.obj['rfcomm_l2cap_mtu'],
+            )
 
         raise ValueError('invalid mode')
 
@@ -1431,6 +1413,21 @@ def create_role_factory(ctx, default_role):
     default=DEFAULT_RFCOMM_UUID,
     help='RFComm service UUID to use (ignored if --rfcomm-channel is not 0)',
 )
+@click.option(
+    '--rfcomm-l2cap-mtu',
+    type=int,
+    help='RFComm L2CAP MTU',
+)
+@click.option(
+    '--rfcomm-max-frame-size',
+    type=int,
+    help='RFComm maximum frame size',
+)
+@click.option(
+    '--rfcomm-window-size',
+    type=int,
+    help='RFComm window size',
+)
 @click.option(
     '--l2cap-psm',
     type=int,
@@ -1528,6 +1525,9 @@ def bench(
     linger,
     rfcomm_channel,
     rfcomm_uuid,
+    rfcomm_l2cap_mtu,
+    rfcomm_max_frame_size,
+    rfcomm_window_size,
     l2cap_psm,
     l2cap_mtu,
     l2cap_mps,
@@ -1540,6 +1540,9 @@ def bench(
     ctx.obj['att_mtu'] = att_mtu
     ctx.obj['rfcomm_channel'] = rfcomm_channel
     ctx.obj['rfcomm_uuid'] = rfcomm_uuid
+    ctx.obj['rfcomm_l2cap_mtu'] = rfcomm_l2cap_mtu
+    ctx.obj['rfcomm_max_frame_size'] = rfcomm_max_frame_size
+    ctx.obj['rfcomm_window_size'] = rfcomm_window_size
     ctx.obj['l2cap_psm'] = l2cap_psm
     ctx.obj['l2cap_mtu'] = l2cap_mtu
     ctx.obj['l2cap_mps'] = l2cap_mps

apps/controller_loopback.py

@@ -99,7 +99,12 @@ class Loopback:
 
             # make sure data can fit in one l2cap pdu
             l2cap_header_size = 4
-            max_packet_size = host.acl_packet_queue.max_packet_size - l2cap_header_size
+
+            max_packet_size = (
+                host.acl_packet_queue
+                if host.acl_packet_queue
+                else host.le_acl_packet_queue
+            ).max_packet_size - l2cap_header_size
             if self.packet_size > max_packet_size:
                 print(
                     color(
@@ -183,7 +188,7 @@ class Loopback:
     '--packet-count',
     '-c',
     metavar='COUNT',
-    type=int,
+    type=click.IntRange(1, 65535),
     default=10,
     help='Packet count',
 )

bumble/avdtp.py

@@ -1470,10 +1470,10 @@ class Protocol(EventEmitter):
             f'[{transaction_label}] {message}'
         )
         max_fragment_size = (
-            self.l2cap_channel.mtu - 3
+            self.l2cap_channel.peer_mtu - 3
         )  # Enough space for a 3-byte start packet header
         payload = message.payload
-        if len(payload) + 2 <= self.l2cap_channel.mtu:
+        if len(payload) + 2 <= self.l2cap_channel.peer_mtu:
             # Fits in a single packet
             packet_type = self.PacketType.SINGLE_PACKET
         else:

bumble/controller.py

@@ -1151,7 +1151,28 @@ class Controller:
         '''
         See Bluetooth spec Vol 4, Part E - 7.4.3 Read Local Supported Features Command
         '''
-        return bytes([HCI_SUCCESS]) + self.lmp_features
+        return bytes([HCI_SUCCESS]) + self.lmp_features[:8]
+
+    def on_hci_read_local_extended_features_command(self, command):
+        '''
+        See Bluetooth spec Vol 4, Part E - 7.4.4 Read Local Extended Features Command
+        '''
+        if command.page_number * 8 > len(self.lmp_features):
+            return bytes([HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR])
+        return (
+            bytes(
+                [
+                    # Status
+                    HCI_SUCCESS,
+                    # Page number
+                    command.page_number,
+                    # Max page number
+                    len(self.lmp_features) // 8 - 1,
+                ]
+            )
+            # Features of the current page
+            + self.lmp_features[command.page_number * 8 : (command.page_number + 1) * 8]
+        )
 
     def on_hci_read_buffer_size_command(self, _command):
         '''
@@ -1522,6 +1543,20 @@ class Controller:
         }
         return bytes([HCI_SUCCESS])
 
+    def on_hci_le_read_maximum_advertising_data_length_command(self, _command):
+        '''
+        See Bluetooth spec Vol 4, Part E - 7.8.57 LE Read Maximum Advertising Data
+        Length Command
+        '''
+        return struct.pack('<BH', HCI_SUCCESS, 0x0672)
+
+    def on_hci_le_read_number_of_supported_advertising_sets_command(self, _command):
+        '''
+        See Bluetooth spec Vol 4, Part E - 7.8.58 LE Read Number of Supported
+        Advertising Set Command
+        '''
+        return struct.pack('<BB', HCI_SUCCESS, 0xF0)
+
     def on_hci_le_read_transmit_power_command(self, _command):
         '''
         See Bluetooth spec Vol 4, Part E - 7.8.74 LE Read Transmit Power Command

bumble/gatt_client.py

@@ -1068,7 +1068,7 @@ class Client:
                 logger.warning('!!! unexpected response, there is no pending request')
                 return
 
-            # Sanity check: the response should match the pending request unless it is
+            # The response should match the pending request unless it is
             # an error response
             if att_pdu.op_code != ATT_ERROR_RESPONSE:
                 expected_response_name = self.pending_request.name.replace(

bumble/gatt_server.py

@@ -328,7 +328,7 @@ class Server(EventEmitter):
             f'handle=0x{characteristic.handle:04X}: {value.hex()}'
         )
 
-        # Sanity check
+        # Check parameters
         if len(value) != 2:
             logger.warning('CCCD value not 2 bytes long')
             return

bumble/hci.py

@@ -23,7 +23,7 @@ import functools
 import logging
 import secrets
 import struct
-from typing import Any, Dict, Callable, Optional, Type, Union, List
+from typing import Any, Callable, Dict, Iterable, List, Optional, Type, Union
 
 from bumble import crypto
 from .colors import color
@@ -223,41 +223,47 @@ HCI_VENDOR_EVENT = 0xFF
 
 
 # HCI Subevent Codes
-HCI_LE_CONNECTION_COMPLETE_EVENT                         = 0x01
-HCI_LE_ADVERTISING_REPORT_EVENT                          = 0x02
-HCI_LE_CONNECTION_UPDATE_COMPLETE_EVENT                  = 0x03
-HCI_LE_READ_REMOTE_FEATURES_COMPLETE_EVENT               = 0x04
-HCI_LE_LONG_TERM_KEY_REQUEST_EVENT                       = 0x05
-HCI_LE_REMOTE_CONNECTION_PARAMETER_REQUEST_EVENT         = 0x06
-HCI_LE_DATA_LENGTH_CHANGE_EVENT                          = 0x07
-HCI_LE_READ_LOCAL_P_256_PUBLIC_KEY_COMPLETE_EVENT        = 0x08
-HCI_LE_GENERATE_DHKEY_COMPLETE_EVENT                     = 0x09
-HCI_LE_ENHANCED_CONNECTION_COMPLETE_EVENT                = 0x0A
-HCI_LE_DIRECTED_ADVERTISING_REPORT_EVENT                 = 0x0B
-HCI_LE_PHY_UPDATE_COMPLETE_EVENT                         = 0x0C
-HCI_LE_EXTENDED_ADVERTISING_REPORT_EVENT                 = 0x0D
-HCI_LE_PERIODIC_ADVERTISING_SYNC_ESTABLISHED_EVENT       = 0x0E
-HCI_LE_PERIODIC_ADVERTISING_REPORT_EVENT                 = 0x0F
-HCI_LE_PERIODIC_ADVERTISING_SYNC_LOST_EVENT              = 0x10
-HCI_LE_SCAN_TIMEOUT_EVENT                                = 0x11
-HCI_LE_ADVERTISING_SET_TERMINATED_EVENT                  = 0x12
-HCI_LE_SCAN_REQUEST_RECEIVED_EVENT                       = 0x13
-HCI_LE_CHANNEL_SELECTION_ALGORITHM_EVENT                 = 0x14
-HCI_LE_CONNECTIONLESS_IQ_REPORT_EVENT                    = 0X15
-HCI_LE_CONNECTION_IQ_REPORT_EVENT                        = 0X16
-HCI_LE_CTE_REQUEST_FAILED_EVENT                          = 0X17
-HCI_LE_PERIODIC_ADVERTISING_SYNC_TRANSFER_RECEIVED_EVENT = 0X18
-HCI_LE_CIS_ESTABLISHED_EVENT                             = 0X19
-HCI_LE_CIS_REQUEST_EVENT                                 = 0X1A
-HCI_LE_CREATE_BIG_COMPLETE_EVENT                         = 0X1B
-HCI_LE_TERMINATE_BIG_COMPLETE_EVENT                      = 0X1C
-HCI_LE_BIG_SYNC_ESTABLISHED_EVENT                        = 0X1D
-HCI_LE_BIG_SYNC_LOST_EVENT                               = 0X1E
-HCI_LE_REQUEST_PEER_SCA_COMPLETE_EVENT                   = 0X1F
-HCI_LE_PATH_LOSS_THRESHOLD_EVENT                         = 0X20
-HCI_LE_TRANSMIT_POWER_REPORTING_EVENT                    = 0X21
-HCI_LE_BIGINFO_ADVERTISING_REPORT_EVENT                  = 0X22
-HCI_LE_SUBRATE_CHANGE_EVENT                              = 0X23
+HCI_LE_CONNECTION_COMPLETE_EVENT                            = 0x01
+HCI_LE_ADVERTISING_REPORT_EVENT                             = 0x02
+HCI_LE_CONNECTION_UPDATE_COMPLETE_EVENT                     = 0x03
+HCI_LE_READ_REMOTE_FEATURES_COMPLETE_EVENT                  = 0x04
+HCI_LE_LONG_TERM_KEY_REQUEST_EVENT                          = 0x05
+HCI_LE_REMOTE_CONNECTION_PARAMETER_REQUEST_EVENT            = 0x06
+HCI_LE_DATA_LENGTH_CHANGE_EVENT                             = 0x07
+HCI_LE_READ_LOCAL_P_256_PUBLIC_KEY_COMPLETE_EVENT           = 0x08
+HCI_LE_GENERATE_DHKEY_COMPLETE_EVENT                        = 0x09
+HCI_LE_ENHANCED_CONNECTION_COMPLETE_EVENT                   = 0x0A
+HCI_LE_DIRECTED_ADVERTISING_REPORT_EVENT                    = 0x0B
+HCI_LE_PHY_UPDATE_COMPLETE_EVENT                            = 0x0C
+HCI_LE_EXTENDED_ADVERTISING_REPORT_EVENT                    = 0x0D
+HCI_LE_PERIODIC_ADVERTISING_SYNC_ESTABLISHED_EVENT          = 0x0E
+HCI_LE_PERIODIC_ADVERTISING_REPORT_EVENT                    = 0x0F
+HCI_LE_PERIODIC_ADVERTISING_SYNC_LOST_EVENT                 = 0x10
+HCI_LE_SCAN_TIMEOUT_EVENT                                   = 0x11
+HCI_LE_ADVERTISING_SET_TERMINATED_EVENT                     = 0x12
+HCI_LE_SCAN_REQUEST_RECEIVED_EVENT                          = 0x13
+HCI_LE_CHANNEL_SELECTION_ALGORITHM_EVENT                    = 0x14
+HCI_LE_CONNECTIONLESS_IQ_REPORT_EVENT                       = 0X15
+HCI_LE_CONNECTION_IQ_REPORT_EVENT                           = 0X16
+HCI_LE_CTE_REQUEST_FAILED_EVENT                             = 0X17
+HCI_LE_PERIODIC_ADVERTISING_SYNC_TRANSFER_RECEIVED_EVENT    = 0X18
+HCI_LE_CIS_ESTABLISHED_EVENT                                = 0X19
+HCI_LE_CIS_REQUEST_EVENT                                    = 0X1A
+HCI_LE_CREATE_BIG_COMPLETE_EVENT                            = 0X1B
+HCI_LE_TERMINATE_BIG_COMPLETE_EVENT                         = 0X1C
+HCI_LE_BIG_SYNC_ESTABLISHED_EVENT                           = 0X1D
+HCI_LE_BIG_SYNC_LOST_EVENT                                  = 0X1E
+HCI_LE_REQUEST_PEER_SCA_COMPLETE_EVENT                      = 0X1F
+HCI_LE_PATH_LOSS_THRESHOLD_EVENT                            = 0X20
+HCI_LE_TRANSMIT_POWER_REPORTING_EVENT                       = 0X21
+HCI_LE_BIGINFO_ADVERTISING_REPORT_EVENT                     = 0X22
+HCI_LE_SUBRATE_CHANGE_EVENT                                 = 0X23
+HCI_LE_PERIODIC_ADVERTISING_SYNC_ESTABLISHED_V2_EVENT       = 0X24
+HCI_LE_PERIODIC_ADVERTISING_REPORT_V2_EVENT                 = 0X25
+HCI_LE_PERIODIC_ADVERTISING_SYNC_TRANSFER_RECEIVED_V2_EVENT = 0X26
+HCI_LE_PERIODIC_ADVERTISING_SUBEVENT_DATA_REQUEST_EVENT     = 0X27
+HCI_LE_PERIODIC_ADVERTISING_RESPONSE_REPORT_EVENT           = 0X28
+HCI_LE_ENHANCED_CONNECTION_COMPLETE_V2_EVENT                = 0X29
 
 
 # HCI Command
@@ -650,47 +656,6 @@ HCI_ERROR_NAMES[HCI_SUCCESS] = 'HCI_SUCCESS'
 # Command Status codes
 HCI_COMMAND_STATUS_PENDING = 0
 
-# LE Event Masks
-HCI_LE_CONNECTION_COMPLETE_EVENT_MASK                         = (1 << 0)
-HCI_LE_ADVERTISING_REPORT_EVENT_MASK                          = (1 << 1)
-HCI_LE_CONNECTION_UPDATE_COMPLETE_EVENT_MASK                  = (1 << 2)
-HCI_LE_READ_REMOTE_FEATURES_COMPLETE_EVENT_MASK               = (1 << 3)
-HCI_LE_LONG_TERM_KEY_REQUEST_EVENT_MASK                       = (1 << 4)
-HCI_LE_REMOTE_CONNECTION_PARAMETER_REQUEST_EVENT_MASK         = (1 << 5)
-HCI_LE_DATA_LENGTH_CHANGE_EVENT_MASK                          = (1 << 6)
-HCI_LE_READ_LOCAL_P_256_PUBLIC_KEY_COMPLETE_EVENT_MASK        = (1 << 7)
-HCI_LE_GENERATE_DHKEY_COMPLETE_EVENT_MASK                     = (1 << 8)
-HCI_LE_ENHANCED_CONNECTION_COMPLETE_EVENT_MASK                = (1 << 9)
-HCI_LE_DIRECTED_ADVERTISING_REPORT_EVENT_MASK                 = (1 << 10)
-HCI_LE_PHY_UPDATE_COMPLETE_EVENT_MASK                         = (1 << 11)
-HCI_LE_EXTENDED_ADVERTISING_REPORT_EVENT_MASK                 = (1 << 12)
-HCI_LE_PERIODIC_ADVERTISING_SYNC_ESTABLISHED_EVENT_MASK       = (1 << 13)
-HCI_LE_PERIODIC_ADVERTISING_REPORT_EVENT_MASK                 = (1 << 14)
-HCI_LE_PERIODIC_ADVERTISING_SYNC_LOST_EVENT_MASK              = (1 << 15)
-HCI_LE_EXTENDED_SCAN_TIMEOUT_EVENT_MASK                       = (1 << 16)
-HCI_LE_EXTENDED_ADVERTISING_SET_TERMINATED_EVENT_MASK         = (1 << 17)
-HCI_LE_SCAN_REQUEST_RECEIVED_EVENT_MASK                       = (1 << 18)
-HCI_LE_CHANNEL_SELECTION_ALGORITHM_EVENT_MASK                 = (1 << 19)
-HCI_LE_CONNECTIONLESS_IQ_REPORT_EVENT_MASK                    = (1 << 20)
-HCI_LE_CONNECTION_IQ_REPORT_EVENT_MASK                        = (1 << 21)
-HCI_LE_CTE_REQUEST_FAILED_EVENT_MASK                          = (1 << 22)
-HCI_LE_PERIODIC_ADVERTISING_SYNC_TRANSFER_RECEIVED_EVENT_MASK = (1 << 23)
-HCI_LE_CIS_ESTABLISHED_EVENT_MASK                             = (1 << 24)
-HCI_LE_CIS_REQUEST_EVENT_MASK                                 = (1 << 25)
-HCI_LE_CREATE_BIG_COMPLETE_EVENT_MASK                         = (1 << 26)
-HCI_LE_TERMINATE_BIG_COMPLETE_EVENT_MASK                      = (1 << 27)
-HCI_LE_BIG_SYNC_ESTABLISHED_EVENT_MASK                        = (1 << 28)
-HCI_LE_BIG_SYNC_LOST_EVENT_MASK                               = (1 << 29)
-HCI_LE_REQUEST_PEER_SCA_COMPLETE_EVENT_MASK                   = (1 << 30)
-HCI_LE_PATH_LOSS_THRESHOLD_EVENT_MASK                         = (1 << 31)
-HCI_LE_TRANSMIT_POWER_REPORTING_EVENT_MASK                    = (1 << 32)
-HCI_LE_BIGINFO_ADVERTISING_REPORT_EVENT_MASK                  = (1 << 33)
-HCI_LE_SUBRATE_CHANGE_EVENT_MASK                              = (1 << 34)
-
-HCI_LE_EVENT_MASK_NAMES = {
-    mask: mask_name for (mask_name, mask) in globals().items()
-    if mask_name.startswith('HCI_LE_') and mask_name.endswith('_EVENT_MASK')
-}
 
 # ACL
 HCI_ACL_PB_FIRST_NON_FLUSHABLE = 0
@@ -732,15 +697,15 @@ HCI_LE_PHY_TYPE_TO_BIT = {
 
 
 class Phy(enum.IntEnum):
-    LE_1M    = 0x01
-    LE_2M    = 0x02
-    LE_CODED = 0x03
+    LE_1M    = HCI_LE_1M_PHY
+    LE_2M    = HCI_LE_2M_PHY
+    LE_CODED = HCI_LE_CODED_PHY
 
 
 class PhyBit(enum.IntFlag):
-    LE_1M    = 0b00000001
-    LE_2M    = 0b00000010
-    LE_CODED = 0b00000100
+    LE_1M    = 1 << HCI_LE_1M_PHY_BIT
+    LE_2M    = 1 << HCI_LE_2M_PHY_BIT
+    LE_CODED = 1 << HCI_LE_CODED_PHY_BIT
 
 
 # Connection Parameters
@@ -1452,6 +1417,180 @@ class LeFeatureMask(enum.IntFlag):
     PERIODIC_ADVERTISING_WITH_RESPONSES_ADVERTISER = 1 << LeFeature.PERIODIC_ADVERTISING_WITH_RESPONSES_ADVERTISER
     PERIODIC_ADVERTISING_WITH_RESPONSES_SCANNER    = 1 << LeFeature.PERIODIC_ADVERTISING_WITH_RESPONSES_SCANNER
 
+class LmpFeature(enum.IntEnum):
+    # Page 0 (Legacy LMP features)
+    LMP_3_SLOT_PACKETS                                           = 0
+    LMP_5_SLOT_PACKETS                                           = 1
+    ENCRYPTION                                                   = 2
+    SLOT_OFFSET                                                  = 3
+    TIMING_ACCURACY                                              = 4
+    ROLE_SWITCH                                                  = 5
+    HOLD_MODE                                                    = 6
+    SNIFF_MODE                                                   = 7
+    # PREVIOUSLY_USED                                            = 8
+    POWER_CONTROL_REQUESTS                                       = 9
+    CHANNEL_QUALITY_DRIVEN_DATA_RATE_CQDDR                       = 10
+    SCO_LINK                                                     = 11
+    HV2_PACKETS                                                  = 12
+    HV3_PACKETS                                                  = 13
+    U_LAW_LOG_SYNCHRONOUS_DATA                                   = 14
+    A_LAW_LOG_SYNCHRONOUS_DATA                                   = 15
+    CVSD_SYNCHRONOUS_DATA                                        = 16
+    PAGING_PARAMETER_NEGOTIATION                                 = 17
+    POWER_CONTROL                                                = 18
+    TRANSPARENT_SYNCHRONOUS_DATA                                 = 19
+    FLOW_CONTROL_LAG_LEAST_SIGNIFICANT_BIT                       = 20
+    FLOW_CONTROL_LAG_MIDDLE_BIT                                  = 21
+    FLOW_CONTROL_LAG_MOST_SIGNIFICANT_BIT                        = 22
+    BROADCAST_ENCRYPTION                                         = 23
+    # RESERVED_FOR_FUTURE_USE                                    = 24
+    ENHANCED_DATA_RATE_ACL_2_MBPS_MODE                           = 25
+    ENHANCED_DATA_RATE_ACL_3_MBPS_MODE                           = 26
+    ENHANCED_INQUIRY_SCAN                                        = 27
+    INTERLACED_INQUIRY_SCAN                                      = 28
+    INTERLACED_PAGE_SCAN                                         = 29
+    RSSI_WITH_INQUIRY_RESULTS                                    = 30
+    EXTENDED_SCO_LINK_EV3_PACKETS                                = 31
+    EV4_PACKETS                                                  = 32
+    EV5_PACKETS                                                  = 33
+    # RESERVED_FOR_FUTURE_USE                                    = 34
+    AFH_CAPABLE_PERIPHERAL                                       = 35
+    AFH_CLASSIFICATION_PERIPHERAL                                = 36
+    BR_EDR_NOT_SUPPORTED                                         = 37
+    LE_SUPPORTED_CONTROLLER                                      = 38
+    LMP_3_SLOT_ENHANCED_DATA_RATE_ACL_PACKETS                    = 39
+    LMP_5_SLOT_ENHANCED_DATA_RATE_ACL_PACKETS                    = 40
+    SNIFF_SUBRATING                                              = 41
+    PAUSE_ENCRYPTION                                             = 42
+    AFH_CAPABLE_CENTRAL                                          = 43
+    AFH_CLASSIFICATION_CENTRAL                                   = 44
+    ENHANCED_DATA_RATE_ESCO_2_MBPS_MODE                          = 45
+    ENHANCED_DATA_RATE_ESCO_3_MBPS_MODE                          = 46
+    LMP_3_SLOT_ENHANCED_DATA_RATE_ESCO_PACKETS                   = 47
+    EXTENDED_INQUIRY_RESPONSE                                    = 48
+    SIMULTANEOUS_LE_AND_BR_EDR_TO_SAME_DEVICE_CAPABLE_CONTROLLER = 49
+    # RESERVED_FOR_FUTURE_USE                                    = 50
+    SECURE_SIMPLE_PAIRING_CONTROLLER_SUPPORT                     = 51
+    ENCAPSULATED_PDU                                             = 52
+    ERRONEOUS_DATA_REPORTING                                     = 53
+    NON_FLUSHABLE_PACKET_BOUNDARY_FLAG                           = 54
+    # RESERVED_FOR_FUTURE_USE                                    = 55
+    HCI_LINK_SUPERVISION_TIMEOUT_CHANGED_EVENT                   = 56
+    VARIABLE_INQUIRY_TX_POWER_LEVEL                              = 57
+    ENHANCED_POWER_CONTROL                                       = 58
+    # RESERVED_FOR_FUTURE_USE                                    = 59
+    # RESERVED_FOR_FUTURE_USE                                    = 60
+    # RESERVED_FOR_FUTURE_USE                                    = 61
+    # RESERVED_FOR_FUTURE_USE                                    = 62
+    EXTENDED_FEATURES                                            = 63
+
+    # Page 1
+    SECURE_SIMPLE_PAIRING_HOST_SUPPORT                           = 64
+    LE_SUPPORTED_HOST                                            = 65
+    # PREVIOUSLY_USED                                            = 66
+    SECURE_CONNECTIONS_HOST_SUPPORT                              = 67
+
+    # Page 2
+    CONNECTIONLESS_PERIPHERAL_BROADCAST_TRANSMITTER_OPERATION    = 128
+    CONNECTIONLESS_PERIPHERAL_BROADCAST_RECEIVER_OPERATION       = 129
+    SYNCHRONIZATION_TRAIN                                        = 130
+    SYNCHRONIZATION_SCAN                                         = 131
+    HCI_INQUIRY_RESPONSE_NOTIFICATION_EVENT                      = 132
+    GENERALIZED_INTERLACED_SCAN                                  = 133
+    COARSE_CLOCK_ADJUSTMENT                                      = 134
+    RESERVED_FOR_FUTURE_USE                                      = 135
+    SECURE_CONNECTIONS_CONTROLLER_SUPPORT                        = 136
+    PING                                                         = 137
+    SLOT_AVAILABILITY_MASK                                       = 138
+    TRAIN_NUDGING                                                = 139
+
+class LmpFeatureMask(enum.IntFlag):
+    # Page 0 (Legacy LMP features)
+    LMP_3_SLOT_PACKETS                                           = (1 << LmpFeature.LMP_3_SLOT_PACKETS)
+    LMP_5_SLOT_PACKETS                                           = (1 << LmpFeature.LMP_5_SLOT_PACKETS)
+    ENCRYPTION                                                   = (1 << LmpFeature.ENCRYPTION)
+    SLOT_OFFSET                                                  = (1 << LmpFeature.SLOT_OFFSET)
+    TIMING_ACCURACY                                              = (1 << LmpFeature.TIMING_ACCURACY)
+    ROLE_SWITCH                                                  = (1 << LmpFeature.ROLE_SWITCH)
+    HOLD_MODE                                                    = (1 << LmpFeature.HOLD_MODE)
+    SNIFF_MODE                                                   = (1 << LmpFeature.SNIFF_MODE)
+    # PREVIOUSLY_USED                                            = (1 << LmpFeature.PREVIOUSLY_USED)
+    POWER_CONTROL_REQUESTS                                       = (1 << LmpFeature.POWER_CONTROL_REQUESTS)
+    CHANNEL_QUALITY_DRIVEN_DATA_RATE_CQDDR                       = (1 << LmpFeature.CHANNEL_QUALITY_DRIVEN_DATA_RATE_CQDDR)
+    SCO_LINK                                                     = (1 << LmpFeature.SCO_LINK)
+    HV2_PACKETS                                                  = (1 << LmpFeature.HV2_PACKETS)
+    HV3_PACKETS                                                  = (1 << LmpFeature.HV3_PACKETS)
+    U_LAW_LOG_SYNCHRONOUS_DATA                                   = (1 << LmpFeature.U_LAW_LOG_SYNCHRONOUS_DATA)
+    A_LAW_LOG_SYNCHRONOUS_DATA                                   = (1 << LmpFeature.A_LAW_LOG_SYNCHRONOUS_DATA)
+    CVSD_SYNCHRONOUS_DATA                                        = (1 << LmpFeature.CVSD_SYNCHRONOUS_DATA)
+    PAGING_PARAMETER_NEGOTIATION                                 = (1 << LmpFeature.PAGING_PARAMETER_NEGOTIATION)
+    POWER_CONTROL                                                = (1 << LmpFeature.POWER_CONTROL)
+    TRANSPARENT_SYNCHRONOUS_DATA                                 = (1 << LmpFeature.TRANSPARENT_SYNCHRONOUS_DATA)
+    FLOW_CONTROL_LAG_LEAST_SIGNIFICANT_BIT                       = (1 << LmpFeature.FLOW_CONTROL_LAG_LEAST_SIGNIFICANT_BIT)
+    FLOW_CONTROL_LAG_MIDDLE_BIT                                  = (1 << LmpFeature.FLOW_CONTROL_LAG_MIDDLE_BIT)
+    FLOW_CONTROL_LAG_MOST_SIGNIFICANT_BIT                        = (1 << LmpFeature.FLOW_CONTROL_LAG_MOST_SIGNIFICANT_BIT)
+    BROADCAST_ENCRYPTION                                         = (1 << LmpFeature.BROADCAST_ENCRYPTION)
+    # RESERVED_FOR_FUTURE_USE                                    = (1 << LmpFeature.RESERVED_FOR_FUTURE_USE)
+    ENHANCED_DATA_RATE_ACL_2_MBPS_MODE                           = (1 << LmpFeature.ENHANCED_DATA_RATE_ACL_2_MBPS_MODE)
+    ENHANCED_DATA_RATE_ACL_3_MBPS_MODE                           = (1 << LmpFeature.ENHANCED_DATA_RATE_ACL_3_MBPS_MODE)
+    ENHANCED_INQUIRY_SCAN                                        = (1 << LmpFeature.ENHANCED_INQUIRY_SCAN)
+    INTERLACED_INQUIRY_SCAN                                      = (1 << LmpFeature.INTERLACED_INQUIRY_SCAN)
+    INTERLACED_PAGE_SCAN                                         = (1 << LmpFeature.INTERLACED_PAGE_SCAN)
+    RSSI_WITH_INQUIRY_RESULTS                                    = (1 << LmpFeature.RSSI_WITH_INQUIRY_RESULTS)
+    EXTENDED_SCO_LINK_EV3_PACKETS                                = (1 << LmpFeature.EXTENDED_SCO_LINK_EV3_PACKETS)
+    EV4_PACKETS                                                  = (1 << LmpFeature.EV4_PACKETS)
+    EV5_PACKETS                                                  = (1 << LmpFeature.EV5_PACKETS)
+    # RESERVED_FOR_FUTURE_USE                                    = (1 << LmpFeature.RESERVED_FOR_FUTURE_USE)
+    AFH_CAPABLE_PERIPHERAL                                       = (1 << LmpFeature.AFH_CAPABLE_PERIPHERAL)
+    AFH_CLASSIFICATION_PERIPHERAL                                = (1 << LmpFeature.AFH_CLASSIFICATION_PERIPHERAL)
+    BR_EDR_NOT_SUPPORTED                                         = (1 << LmpFeature.BR_EDR_NOT_SUPPORTED)
+    LE_SUPPORTED_CONTROLLER                                      = (1 << LmpFeature.LE_SUPPORTED_CONTROLLER)
+    LMP_3_SLOT_ENHANCED_DATA_RATE_ACL_PACKETS                    = (1 << LmpFeature.LMP_3_SLOT_ENHANCED_DATA_RATE_ACL_PACKETS)
+    LMP_5_SLOT_ENHANCED_DATA_RATE_ACL_PACKETS                    = (1 << LmpFeature.LMP_5_SLOT_ENHANCED_DATA_RATE_ACL_PACKETS)
+    SNIFF_SUBRATING                                              = (1 << LmpFeature.SNIFF_SUBRATING)
+    PAUSE_ENCRYPTION                                             = (1 << LmpFeature.PAUSE_ENCRYPTION)
+    AFH_CAPABLE_CENTRAL                                          = (1 << LmpFeature.AFH_CAPABLE_CENTRAL)
+    AFH_CLASSIFICATION_CENTRAL                                   = (1 << LmpFeature.AFH_CLASSIFICATION_CENTRAL)
+    ENHANCED_DATA_RATE_ESCO_2_MBPS_MODE                          = (1 << LmpFeature.ENHANCED_DATA_RATE_ESCO_2_MBPS_MODE)
+    ENHANCED_DATA_RATE_ESCO_3_MBPS_MODE                          = (1 << LmpFeature.ENHANCED_DATA_RATE_ESCO_3_MBPS_MODE)
+    LMP_3_SLOT_ENHANCED_DATA_RATE_ESCO_PACKETS                   = (1 << LmpFeature.LMP_3_SLOT_ENHANCED_DATA_RATE_ESCO_PACKETS)
+    EXTENDED_INQUIRY_RESPONSE                                    = (1 << LmpFeature.EXTENDED_INQUIRY_RESPONSE)
+    SIMULTANEOUS_LE_AND_BR_EDR_TO_SAME_DEVICE_CAPABLE_CONTROLLER = (1 << LmpFeature.SIMULTANEOUS_LE_AND_BR_EDR_TO_SAME_DEVICE_CAPABLE_CONTROLLER)
+    # RESERVED_FOR_FUTURE_USE                                    = (1 << LmpFeature.RESERVED_FOR_FUTURE_USE)
+    SECURE_SIMPLE_PAIRING_CONTROLLER_SUPPORT                     = (1 << LmpFeature.SECURE_SIMPLE_PAIRING_CONTROLLER_SUPPORT)
+    ENCAPSULATED_PDU                                             = (1 << LmpFeature.ENCAPSULATED_PDU)
+    ERRONEOUS_DATA_REPORTING                                     = (1 << LmpFeature.ERRONEOUS_DATA_REPORTING)
+    NON_FLUSHABLE_PACKET_BOUNDARY_FLAG                           = (1 << LmpFeature.NON_FLUSHABLE_PACKET_BOUNDARY_FLAG)
+    # RESERVED_FOR_FUTURE_USE                                    = (1 << LmpFeature.RESERVED_FOR_FUTURE_USE)
+    HCI_LINK_SUPERVISION_TIMEOUT_CHANGED_EVENT                   = (1 << LmpFeature.HCI_LINK_SUPERVISION_TIMEOUT_CHANGED_EVENT)
+    VARIABLE_INQUIRY_TX_POWER_LEVEL                              = (1 << LmpFeature.VARIABLE_INQUIRY_TX_POWER_LEVEL)
+    ENHANCED_POWER_CONTROL                                       = (1 << LmpFeature.ENHANCED_POWER_CONTROL)
+    # RESERVED_FOR_FUTURE_USE                                    = (1 << LmpFeature.RESERVED_FOR_FUTURE_USE)
+    # RESERVED_FOR_FUTURE_USE                                    = (1 << LmpFeature.RESERVED_FOR_FUTURE_USE)
+    # RESERVED_FOR_FUTURE_USE                                    = (1 << LmpFeature.RESERVED_FOR_FUTURE_USE)
+    # RESERVED_FOR_FUTURE_USE                                    = (1 << LmpFeature.RESERVED_FOR_FUTURE_USE)
+    EXTENDED_FEATURES                                            = (1 << LmpFeature.EXTENDED_FEATURES)
+
+    # Page 1
+    SECURE_SIMPLE_PAIRING_HOST_SUPPORT                           = (1 << LmpFeature.SECURE_SIMPLE_PAIRING_HOST_SUPPORT)
+    LE_SUPPORTED_HOST                                            = (1 << LmpFeature.LE_SUPPORTED_HOST)
+    # PREVIOUSLY_USED                                            = (1 << LmpFeature.PREVIOUSLY_USED)
+    SECURE_CONNECTIONS_HOST_SUPPORT                              = (1 << LmpFeature.SECURE_CONNECTIONS_HOST_SUPPORT)
+
+    # Page 2
+    CONNECTIONLESS_PERIPHERAL_BROADCAST_TRANSMITTER_OPERATION    = (1 << LmpFeature.CONNECTIONLESS_PERIPHERAL_BROADCAST_TRANSMITTER_OPERATION)
+    CONNECTIONLESS_PERIPHERAL_BROADCAST_RECEIVER_OPERATION       = (1 << LmpFeature.CONNECTIONLESS_PERIPHERAL_BROADCAST_RECEIVER_OPERATION)
+    SYNCHRONIZATION_TRAIN                                        = (1 << LmpFeature.SYNCHRONIZATION_TRAIN)
+    SYNCHRONIZATION_SCAN                                         = (1 << LmpFeature.SYNCHRONIZATION_SCAN)
+    HCI_INQUIRY_RESPONSE_NOTIFICATION_EVENT                      = (1 << LmpFeature.HCI_INQUIRY_RESPONSE_NOTIFICATION_EVENT)
+    GENERALIZED_INTERLACED_SCAN                                  = (1 << LmpFeature.GENERALIZED_INTERLACED_SCAN)
+    COARSE_CLOCK_ADJUSTMENT                                      = (1 << LmpFeature.COARSE_CLOCK_ADJUSTMENT)
+    RESERVED_FOR_FUTURE_USE                                      = (1 << LmpFeature.RESERVED_FOR_FUTURE_USE)
+    SECURE_CONNECTIONS_CONTROLLER_SUPPORT                        = (1 << LmpFeature.SECURE_CONNECTIONS_CONTROLLER_SUPPORT)
+    PING                                                         = (1 << LmpFeature.PING)
+    SLOT_AVAILABILITY_MASK                                       = (1 << LmpFeature.SLOT_AVAILABILITY_MASK)
+    TRAIN_NUDGING                                                = (1 << LmpFeature.TRAIN_NUDGING)
+
 
 # fmt: on
 # pylint: enable=line-too-long
@@ -2910,6 +3049,20 @@ class HCI_Set_Event_Mask_Command(HCI_Command):
     See Bluetooth spec @ 7.3.1 Set Event Mask Command
     '''
 
+    @staticmethod
+    def mask(event_codes: Iterable[int]) -> bytes:
+        '''
+        Compute the event mask value for a list of events.
+        '''
+        # NOTE: this implementation takes advantage of the fact that as of version 5.4
+        # of the core specification, the bit number for each event code is equal to one
+        # less than the event code.
+        # If future versions of the specification deviate from that, a different
+        # implementation would be needed.
+        return sum((1 << event_code - 1) for event_code in event_codes).to_bytes(
+            8, 'little'
+        )
+
 
 # -----------------------------------------------------------------------------
 @HCI_Command.command()
@@ -3319,7 +3472,12 @@ class HCI_Read_Local_Supported_Commands_Command(HCI_Command):
 
 
 # -----------------------------------------------------------------------------
-@HCI_Command.command()
+@HCI_Command.command(
+    return_parameters_fields=[
+        ('status', STATUS_SPEC),
+        ('lmp_features', 8),
+    ]
+)
 class HCI_Read_Local_Supported_Features_Command(HCI_Command):
     '''
     See Bluetooth spec @ 7.4.3 Read Local Supported Features Command
@@ -3433,6 +3591,20 @@ class HCI_LE_Set_Event_Mask_Command(HCI_Command):
     See Bluetooth spec @ 7.8.1 LE Set Event Mask Command
     '''
 
+    @staticmethod
+    def mask(event_codes: Iterable[int]) -> bytes:
+        '''
+        Compute the event mask value for a list of events.
+        '''
+        # NOTE: this implementation takes advantage of the fact that as of version 5.4
+        # of the core specification, the bit number for each event code is equal to one
+        # less than the event code.
+        # If future versions of the specification deviate from that, a different
+        # implementation would be needed.
+        return sum((1 << event_code - 1) for event_code in event_codes).to_bytes(
+            8, 'little'
+        )
+
 
 # -----------------------------------------------------------------------------
 @HCI_Command.command(
@@ -4040,13 +4212,16 @@ class HCI_LE_Set_Advertising_Set_Random_Address_Command(HCI_Command):
         ('advertising_sid', 1),
         ('scan_request_notification_enable', 1),
     ],
-    return_parameters_fields=[('status', STATUS_SPEC), ('selected_tx__power', 1)],
+    return_parameters_fields=[('status', STATUS_SPEC), ('selected_tx_power', 1)],
 )
 class HCI_LE_Set_Extended_Advertising_Parameters_Command(HCI_Command):
     '''
     See Bluetooth spec @ 7.8.53 LE Set Extended Advertising Parameters Command
     '''
 
+    TX_POWER_NO_PREFERENCE = 0x7F
+    SHOULD_NOT_FRAGMENT = 0x01
+
     class AdvertisingProperties(enum.IntFlag):
         CONNECTABLE_ADVERTISING = 1 << 0
         SCANNABLE_ADVERTISING = 1 << 1
@@ -4291,7 +4466,7 @@ class HCI_LE_Set_Extended_Scan_Parameters_Command(HCI_Command):
             ('scanning_filter_policy:', self.scanning_filter_policy),
             ('scanning_phys:         ', ','.join(scanning_phys_strs)),
         ]
-        for (i, scanning_phy_str) in enumerate(scanning_phys_strs):
+        for i, scanning_phy_str in enumerate(scanning_phys_strs):
             fields.append(
                 (
                     f'{scanning_phy_str}.scan_type:    ',
@@ -4434,7 +4609,7 @@ class HCI_LE_Extended_Create_Connection_Command(HCI_Command):
             ('peer_address:           ', str(self.peer_address)),
             ('initiating_phys:        ', ','.join(initiating_phys_strs)),
         ]
-        for (i, initiating_phys_str) in enumerate(initiating_phys_strs):
+        for i, initiating_phys_str in enumerate(initiating_phys_strs):
             fields.append(
                 (
                     f'{initiating_phys_str}.scan_interval:          ',
@@ -5321,7 +5496,7 @@ HCI_LE_Meta_Event.subevent_classes[
         ('status', 1),
         ('advertising_handle', 1),
         ('connection_handle', 2),
-        ('number_completed_extended_advertising_events', 1),
+        ('num_completed_extended_advertising_events', 1),
     ]
 )
 class HCI_LE_Advertising_Set_Terminated_Event(HCI_LE_Meta_Event):
@@ -6262,7 +6437,7 @@ class HCI_IsoDataPacket(HCI_Packet):
 
         if ts_flag:
             if not should_include_sdu_info:
-                logger.warn(f'Timestamp included when pb_flag={bin(pb_flag)}')
+                logger.warning(f'Timestamp included when pb_flag={bin(pb_flag)}')
             time_stamp, *_ = struct.unpack_from('<I', packet, pos)
             pos += 4
 
@@ -6375,7 +6550,7 @@ class HCI_AclDataPacketAssembler:
             self.current_data = None
             self.l2cap_pdu_length = 0
         else:
-            # Sanity check
+            # Compliance check
             if len(self.current_data) > self.l2cap_pdu_length + 4:
                 logger.warning('!!! ACL data exceeds L2CAP PDU')
                 self.current_data = None

bumble/hfp.py

@@ -21,12 +21,11 @@ import asyncio
 import dataclasses
 import enum
 import traceback
-import warnings
-from typing import Dict, List, Union, Set, Any, TYPE_CHECKING
-
-from . import at
-from . import rfcomm
+import pyee
+from typing import Dict, List, Union, Set, Any, Optional, TYPE_CHECKING
 
+from bumble import at
+from bumble import rfcomm
 from bumble.colors import color
 from bumble.core import (
     ProtocolError,
@@ -79,7 +78,6 @@ class HfpProtocol:
     lines_available: asyncio.Event
 
     def __init__(self, dlc: rfcomm.DLC) -> None:
-        warnings.warn("See HfProtocol", DeprecationWarning)
         self.dlc = dlc
         self.buffer = ''
         self.lines = collections.deque()
@@ -128,10 +126,13 @@ class HfpProtocol:
 # -----------------------------------------------------------------------------
 
 
-# HF supported features (AT+BRSF=) (normative).
-# Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07
-# and 3GPP 27.007
 class HfFeature(enum.IntFlag):
+    """
+    HF supported features (AT+BRSF=) (normative).
+
+    Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07 and 3GPP 27.007.
+    """
+
     EC_NR = 0x001  # Echo Cancel & Noise reduction
     THREE_WAY_CALLING = 0x002
     CLI_PRESENTATION_CAPABILITY = 0x004
@@ -146,10 +147,13 @@ class HfFeature(enum.IntFlag):
     VOICE_RECOGNITION_TEST = 0x800
 
 
-# AG supported features (+BRSF:) (normative).
-# Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07
-# and 3GPP 27.007
 class AgFeature(enum.IntFlag):
+    """
+    AG supported features (+BRSF:) (normative).
+
+    Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07 and 3GPP 27.007.
+    """
+
     THREE_WAY_CALLING = 0x001
     EC_NR = 0x002  # Echo Cancel & Noise reduction
     VOICE_RECOGNITION_FUNCTION = 0x004
@@ -166,52 +170,90 @@ class AgFeature(enum.IntFlag):
     VOICE_RECOGNITION_TEST = 0x2000
 
 
-# Audio Codec IDs (normative).
-# Hands-Free Profile v1.8, 10 Appendix B
 class AudioCodec(enum.IntEnum):
+    """
+    Audio Codec IDs (normative).
+
+    Hands-Free Profile v1.9, 11 Appendix B
+    """
+
     CVSD = 0x01  # Support for CVSD audio codec
     MSBC = 0x02  # Support for mSBC audio codec
+    LC3_SWB = 0x03  # Support for LC3-SWB audio codec
 
 
-# HF Indicators (normative).
-# Bluetooth Assigned Numbers, 6.10.1 HF Indicators
 class HfIndicator(enum.IntEnum):
+    """
+    HF Indicators (normative).
+
+    Bluetooth Assigned Numbers, 6.10.1 HF Indicators.
+    """
+
     ENHANCED_SAFETY = 0x01  # Enhanced safety feature
     BATTERY_LEVEL = 0x02  # Battery level feature
 
 
-# Call Hold supported operations (normative).
-# AT Commands Reference Guide, 3.5.2.3.12 +CHLD - Call Holding Services
 class CallHoldOperation(enum.IntEnum):
+    """
+    Call Hold supported operations (normative).
+
+    AT Commands Reference Guide, 3.5.2.3.12 +CHLD - Call Holding Services.
+    """
+
     RELEASE_ALL_HELD_CALLS = 0  # Release all held calls
     RELEASE_ALL_ACTIVE_CALLS = 1  # Release all active calls, accept other
     HOLD_ALL_ACTIVE_CALLS = 2  # Place all active calls on hold, accept other
     ADD_HELD_CALL = 3  # Adds a held call to conversation
 
 
-# Response Hold status (normative).
-# Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07
-# and 3GPP 27.007
 class ResponseHoldStatus(enum.IntEnum):
+    """
+    Response Hold status (normative).
+
+    Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07 and 3GPP 27.007.
+    """
+
     INC_CALL_HELD = 0  # Put incoming call on hold
     HELD_CALL_ACC = 1  # Accept a held incoming call
     HELD_CALL_REJ = 2  # Reject a held incoming call
 
 
-# Values for the Call Setup AG indicator (normative).
-# Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07
-# and 3GPP 27.007
+class AgIndicator(enum.Enum):
+    """
+    Values for the AG indicator (normative).
+
+    Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07 and 3GPP 27.007.
+    """
+
+    SERVICE = 'service'
+    CALL = 'call'
+    CALL_SETUP = 'callsetup'
+    CALL_HELD = 'callheld'
+    SIGNAL = 'signal'
+    ROAM = 'roam'
+    BATTERY_CHARGE = 'battchg'
+
+
 class CallSetupAgIndicator(enum.IntEnum):
+    """
+    Values for the Call Setup AG indicator (normative).
+
+    Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07 and 3GPP 27.007.
+    """
+
     NOT_IN_CALL_SETUP = 0
     INCOMING_CALL_PROCESS = 1
     OUTGOING_CALL_SETUP = 2
     REMOTE_ALERTED = 3  # Remote party alerted in an outgoing call
 
 
-# Values for the Call Held AG indicator (normative).
-# Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07
-# and 3GPP 27.007
 class CallHeldAgIndicator(enum.IntEnum):
+    """
+    Values for the Call Held AG indicator (normative).
+
+    Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07 and 3GPP 27.007.
+    """
+
     NO_CALLS_HELD = 0
     # Call is placed on hold or active/held calls swapped
     # (The AG has both an active AND a held call)
@@ -219,16 +261,24 @@ class CallHeldAgIndicator(enum.IntEnum):
     CALL_ON_HOLD_NO_ACTIVE_CALL = 2  # Call on hold, no active call
 
 
-# Call Info direction (normative).
-# AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls
 class CallInfoDirection(enum.IntEnum):
+    """
+    Call Info direction (normative).
+
+    AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls.
+    """
+
     MOBILE_ORIGINATED_CALL = 0
     MOBILE_TERMINATED_CALL = 1
 
 
-# Call Info status (normative).
-# AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls
 class CallInfoStatus(enum.IntEnum):
+    """
+    Call Info status (normative).
+
+    AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls.
+    """
+
     ACTIVE = 0
     HELD = 1
     DIALING = 2
@@ -237,15 +287,47 @@ class CallInfoStatus(enum.IntEnum):
     WAITING = 5
 
 
-# Call Info mode (normative).
-# AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls
 class CallInfoMode(enum.IntEnum):
+    """
+    Call Info mode (normative).
+
+    AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls.
+    """
+
     VOICE = 0
     DATA = 1
     FAX = 2
     UNKNOWN = 9
 
 
+class CallInfoMultiParty(enum.IntEnum):
+    """
+    Call Info Multi-Party state (normative).
+
+    AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls.
+    """
+
+    NOT_IN_CONFERENCE = 0
+    IN_CONFERENCE = 1
+
+
+@dataclasses.dataclass
+class CallInfo:
+    """
+    Enhanced call status.
+
+    AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls.
+    """
+
+    index: int
+    direction: CallInfoDirection
+    status: CallInfoStatus
+    mode: CallInfoMode
+    multi_party: CallInfoMultiParty
+    number: Optional[int] = None
+    type: Optional[int] = None
+
+
 # -----------------------------------------------------------------------------
 # Hands-Free Control Interoperability Requirements
 # -----------------------------------------------------------------------------
@@ -326,8 +408,9 @@ class Configuration:
 
 
 class AtResponseType(enum.Enum):
-    """Indicate if a response is expected from an AT command, and if multiple
-    responses are accepted."""
+    """
+    Indicates if a response is expected from an AT command, and if multiple responses are accepted.
+    """
 
     NONE = 0
     SINGLE = 1
@@ -361,9 +444,20 @@ class HfIndicatorState:
     enabled: bool = False
 
 
-class HfProtocol:
-    """Implementation for the Hands-Free side of the Hands-Free profile.
-    Reference specification Hands-Free Profile v1.8"""
+class HfProtocol(pyee.EventEmitter):
+    """
+    Implementation for the Hands-Free side of the Hands-Free profile.
+
+    Reference specification Hands-Free Profile v1.8.
+
+    Emitted events:
+        codec_negotiation: When codec is renegotiated, notify the new codec.
+            Args:
+                active_codec: AudioCodec
+        ag_indicator: When AG update their indicators, notify the new state.
+            Args:
+                ag_indicator: AgIndicator
+    """
 
     supported_hf_features: int
     supported_audio_codecs: List[AudioCodec]
@@ -383,14 +477,18 @@ class HfProtocol:
         response_queue: asyncio.Queue
         unsolicited_queue: asyncio.Queue
     read_buffer: bytearray
+    active_codec: AudioCodec
+
+    def __init__(self, dlc: rfcomm.DLC, configuration: Configuration) -> None:
+        super().__init__()
 
-    def __init__(self, dlc: rfcomm.DLC, configuration: Configuration):
         # Configure internal state.
         self.dlc = dlc
         self.command_lock = asyncio.Lock()
         self.response_queue = asyncio.Queue()
         self.unsolicited_queue = asyncio.Queue()
         self.read_buffer = bytearray()
+        self.active_codec = AudioCodec.CVSD
 
         # Build local features.
         self.supported_hf_features = sum(configuration.supported_hf_features)
@@ -415,10 +513,12 @@ class HfProtocol:
     def supports_ag_feature(self, feature: AgFeature) -> bool:
         return (self.supported_ag_features & feature) != 0
 
-    # Read AT messages from the RFCOMM channel.
-    # Enqueue AT commands, responses, unsolicited responses to their
-    # respective queues, and set the corresponding event.
     def _read_at(self, data: bytes):
+        """
+        Reads AT messages from the RFCOMM channel.
+
+        Enqueues AT commands, responses, unsolicited responses to their respective queues, and set the corresponding event.
+        """
         # Append to the read buffer.
         self.read_buffer.extend(data)
 
@@ -446,17 +546,25 @@ class HfProtocol:
         else:
             logger.warning(f"dropping unexpected response with code '{response.code}'")
 
-    # Send an AT command and wait for the peer response.
-    # Wait for the AT responses sent by the peer, to the status code.
-    # Raises asyncio.TimeoutError if the status is not received
-    # after a timeout (default 1 second).
-    # Raises ProtocolError if the status is not OK.
     async def execute_command(
         self,
         cmd: str,
         timeout: float = 1.0,
         response_type: AtResponseType = AtResponseType.NONE,
     ) -> Union[None, AtResponse, List[AtResponse]]:
+        """
+        Sends an AT command and wait for the peer response.
+        Wait for the AT responses sent by the peer, to the status code.
+
+        Args:
+            cmd: the AT command in string to execute.
+            timeout: timeout in float seconds.
+            response_type: type of response.
+
+        Raises:
+            asyncio.TimeoutError: the status is not received after a timeout (default 1 second).
+            ProtocolError: the status is not OK.
+        """
         async with self.command_lock:
             logger.debug(f">>> {cmd}")
             self.dlc.write(cmd + '\r')
@@ -479,8 +587,9 @@ class HfProtocol:
                     raise HfpProtocolError(result.code)
                 responses.append(result)
 
-    # 4.2.1 Service Level Connection Initialization.
     async def initiate_slc(self):
+        """4.2.1 Service Level Connection Initialization."""
+
         # 4.2.1.1 Supported features exchange
         # First, in the initialization procedure, the HF shall send the
         # AT+BRSF=<HF supported features> command to the AG to both notify
@@ -620,16 +729,17 @@ class HfProtocol:
 
         logger.info("SLC setup completed")
 
-    # 4.11.2 Audio Connection Setup by HF
     async def setup_audio_connection(self):
+        """4.11.2 Audio Connection Setup by HF."""
+
         # When the HF triggers the establishment of the Codec Connection it
         # shall send the AT command AT+BCC to the AG. The AG shall respond with
         # OK if it will start the Codec Connection procedure, and with ERROR
         # if it cannot start the Codec Connection procedure.
         await self.execute_command("AT+BCC")
 
-    # 4.11.3 Codec Connection Setup
     async def setup_codec_connection(self, codec_id: int):
+        """4.11.3 Codec Connection Setup."""
         # The AG shall send a +BCS=<Codec ID> unsolicited response to the HF.
         # The HF shall then respond to the incoming unsolicited response with
         # the AT command AT+BCS=<Codec ID>. The ID shall be the same as in the
@@ -647,27 +757,29 @@ class HfProtocol:
         # Synchronous Connection with the settings that are determined by the
         # ID. The HF shall be ready to accept the synchronous connection
         # establishment as soon as it has sent the AT commands AT+BCS=<Codec ID>.
+        self.active_codec = AudioCodec(codec_id)
+        self.emit('codec_negotiation', self.active_codec)
 
         logger.info("codec connection setup completed")
 
-    # 4.13.1 Answer Incoming Call from the HF – In-Band Ringing
     async def answer_incoming_call(self):
+        """4.13.1 Answer Incoming Call from the HF - In-Band Ringing."""
         # The user accepts the incoming voice call by using the proper means
         # provided by the HF. The HF shall then send the ATA command
         # (see Section 4.34) to the AG. The AG shall then begin the procedure for
         # accepting the incoming call.
         await self.execute_command("ATA")
 
-    # 4.14.1 Reject an Incoming Call from the HF
     async def reject_incoming_call(self):
+        """4.14.1 Reject an Incoming Call from the HF."""
         # The user rejects the incoming call by using the User Interface on the
         # Hands-Free unit. The HF shall then send the AT+CHUP command
         # (see Section 4.34) to the AG. This may happen at any time during the
         # procedures described in Sections 4.13.1 and 4.13.2.
         await self.execute_command("AT+CHUP")
 
-    # 4.15.1 Terminate a Call Process from the HF
     async def terminate_call(self):
+        """4.15.1 Terminate a Call Process from the HF."""
         # The user may abort the ongoing call process using whatever means
         # provided by the Hands-Free unit. The HF shall send AT+CHUP command
         # (see Section 4.34) to the AG, and the AG shall then start the
@@ -676,8 +788,35 @@ class HfProtocol:
         # code, with the value indicating (call=0).
         await self.execute_command("AT+CHUP")
 
+    async def query_current_calls(self) -> List[CallInfo]:
+        """4.32.1 Query List of Current Calls in AG.
+
+        Return:
+            List of current calls in AG.
+        """
+        responses = await self.execute_command(
+            "AT+CLCC", response_type=AtResponseType.MULTIPLE
+        )
+        assert isinstance(responses, list)
+
+        calls = []
+        for response in responses:
+            call_info = CallInfo(
+                index=int(response.parameters[0]),
+                direction=CallInfoDirection(int(response.parameters[1])),
+                status=CallInfoStatus(int(response.parameters[2])),
+                mode=CallInfoMode(int(response.parameters[3])),
+                multi_party=CallInfoMultiParty(int(response.parameters[4])),
+            )
+            if len(response.parameters) >= 7:
+                call_info.number = int(response.parameters[5])
+                call_info.type = int(response.parameters[6])
+            calls.append(call_info)
+        return calls
+
     async def update_ag_indicator(self, index: int, value: int):
         self.ag_indicators[index].current_status = value
+        self.emit('ag_indicator', self.ag_indicators[index])
         logger.info(
             f"AG indicator updated: {self.ag_indicators[index].description}, {value}"
         )
@@ -695,9 +834,11 @@ class HfProtocol:
             logging.info(f"unhandled unsolicited response {result.code}")
 
     async def run(self):
-        """Main rountine for the Hands-Free side of the HFP protocol.
-        Initiates the service level connection then loops handling
-        unsolicited AG responses."""
+        """
+        Main routine for the Hands-Free side of the HFP protocol.
+
+        Initiates the service level connection then loops handling unsolicited AG responses.
+        """
 
         try:
             await self.initiate_slc()
@@ -713,9 +854,13 @@ class HfProtocol:
 # -----------------------------------------------------------------------------
 
 
-# Profile version (normative).
-# Hands-Free Profile v1.8, 5.3 SDP Interoperability Requirements
 class ProfileVersion(enum.IntEnum):
+    """
+    Profile version (normative).
+
+    Hands-Free Profile v1.8, 5.3 SDP Interoperability Requirements.
+    """
+
     V1_5 = 0x0105
     V1_6 = 0x0106
     V1_7 = 0x0107
@@ -723,9 +868,13 @@ class ProfileVersion(enum.IntEnum):
     V1_9 = 0x0109
 
 
-# HF supported features (normative).
-# Hands-Free Profile v1.8, 5.3 SDP Interoperability Requirements
 class HfSdpFeature(enum.IntFlag):
+    """
+    HF supported features (normative).
+
+    Hands-Free Profile v1.8, 5.3 SDP Interoperability Requirements.
+    """
+
     EC_NR = 0x01  # Echo Cancel & Noise reduction
     THREE_WAY_CALLING = 0x02
     CLI_PRESENTATION_CAPABILITY = 0x04
@@ -736,9 +885,13 @@ class HfSdpFeature(enum.IntFlag):
     VOICE_RECOGNITION_TEST = 0x80
 
 
-# AG supported features (normative).
-# Hands-Free Profile v1.8, 5.3 SDP Interoperability Requirements
 class AgSdpFeature(enum.IntFlag):
+    """
+    AG supported features (normative).
+
+    Hands-Free Profile v1.8, 5.3 SDP Interoperability Requirements.
+    """
+
     THREE_WAY_CALLING = 0x01
     EC_NR = 0x02  # Echo Cancel & Noise reduction
     VOICE_RECOGNITION_FUNCTION = 0x04
@@ -752,9 +905,12 @@ class AgSdpFeature(enum.IntFlag):
 def sdp_records(
     service_record_handle: int, rfcomm_channel: int, configuration: Configuration
 ) -> List[ServiceAttribute]:
-    """Generate the SDP record for HFP Hands-Free support.
+    """
+    Generates the SDP record for HFP Hands-Free support.
+
     The record exposes the features supported in the input configuration,
-    and the allocated RFCOMM channel."""
+    and the allocated RFCOMM channel.
+    """
 
     hf_supported_features = 0
 

bumble/hid.py

@@ -416,7 +416,7 @@ class Device(HID):
             data = bytearray()
             data.append(report_id)
             data.extend(ret.data)
-            if len(data) < self.l2cap_ctrl_channel.mtu:  # type: ignore[union-attr]
+            if len(data) < self.l2cap_ctrl_channel.peer_mtu:  # type: ignore[union-attr]
                 self.send_control_data(report_type=report_type, data=data)
             else:
                 self.send_handshake_message(Message.Handshake.ERR_INVALID_PARAMETER)

bumble/host.py

@@ -28,59 +28,15 @@ from bumble.colors import color
 from bumble.l2cap import L2CAP_PDU
 from bumble.snoop import Snooper
 from bumble import drivers
-
-from .hci import (
-    Address,
-    HCI_ACL_DATA_PACKET,
-    HCI_COMMAND_PACKET,
-    HCI_EVENT_PACKET,
-    HCI_ISO_DATA_PACKET,
-    HCI_LE_READ_BUFFER_SIZE_COMMAND,
-    HCI_LE_READ_LOCAL_SUPPORTED_FEATURES_COMMAND,
-    HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND,
-    HCI_LE_WRITE_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND,
-    HCI_READ_BUFFER_SIZE_COMMAND,
-    HCI_READ_LOCAL_VERSION_INFORMATION_COMMAND,
-    HCI_RESET_COMMAND,
-    HCI_SUCCESS,
-    HCI_SUPPORTED_COMMANDS_FLAGS,
-    HCI_SYNCHRONOUS_DATA_PACKET,
-    HCI_VERSION_BLUETOOTH_CORE_4_0,
-    HCI_AclDataPacket,
-    HCI_AclDataPacketAssembler,
-    HCI_Command,
-    HCI_Command_Complete_Event,
-    HCI_Constant,
-    HCI_Error,
-    HCI_Event,
-    HCI_IsoDataPacket,
-    HCI_LE_Long_Term_Key_Request_Negative_Reply_Command,
-    HCI_LE_Long_Term_Key_Request_Reply_Command,
-    HCI_LE_Read_Buffer_Size_Command,
-    HCI_LE_Read_Local_Supported_Features_Command,
-    HCI_LE_Read_Suggested_Default_Data_Length_Command,
-    HCI_LE_Remote_Connection_Parameter_Request_Reply_Command,
-    HCI_LE_Set_Event_Mask_Command,
-    HCI_LE_Write_Suggested_Default_Data_Length_Command,
-    HCI_Link_Key_Request_Negative_Reply_Command,
-    HCI_Link_Key_Request_Reply_Command,
-    HCI_Packet,
-    HCI_Read_Buffer_Size_Command,
-    HCI_Read_Local_Supported_Commands_Command,
-    HCI_Read_Local_Version_Information_Command,
-    HCI_Reset_Command,
-    HCI_Set_Event_Mask_Command,
-    HCI_SynchronousDataPacket,
-    LeFeatureMask,
-)
-from .core import (
+from bumble import hci
+from bumble.core import (
     BT_BR_EDR_TRANSPORT,
     BT_LE_TRANSPORT,
     ConnectionPHY,
     ConnectionParameters,
 )
-from .utils import AbortableEventEmitter
-from .transport.common import TransportLostError
+from bumble.utils import AbortableEventEmitter
+from bumble.transport.common import TransportLostError
 
 if TYPE_CHECKING:
     from .transport.common import TransportSink, TransportSource
@@ -100,15 +56,15 @@ class AclPacketQueue:
         self,
         max_packet_size: int,
         max_in_flight: int,
-        send: Callable[[HCI_Packet], None],
+        send: Callable[[hci.HCI_Packet], None],
     ) -> None:
         self.max_packet_size = max_packet_size
         self.max_in_flight = max_in_flight
         self.in_flight = 0
         self.send = send
-        self.packets: Deque[HCI_AclDataPacket] = collections.deque()
+        self.packets: Deque[hci.HCI_AclDataPacket] = collections.deque()
 
-    def enqueue(self, packet: HCI_AclDataPacket) -> None:
+    def enqueue(self, packet: hci.HCI_AclDataPacket) -> None:
         self.packets.appendleft(packet)
         self.check_queue()
 
@@ -140,11 +96,13 @@ class AclPacketQueue:
 
 # -----------------------------------------------------------------------------
 class Connection:
-    def __init__(self, host: Host, handle: int, peer_address: Address, transport: int):
+    def __init__(
+        self, host: Host, handle: int, peer_address: hci.Address, transport: int
+    ):
         self.host = host
         self.handle = handle
         self.peer_address = peer_address
-        self.assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
+        self.assembler = hci.HCI_AclDataPacketAssembler(self.on_acl_pdu)
         self.transport = transport
         acl_packet_queue: Optional[AclPacketQueue] = (
             host.le_acl_packet_queue
@@ -154,7 +112,7 @@ class Connection:
         assert acl_packet_queue
         self.acl_packet_queue = acl_packet_queue
 
-    def on_hci_acl_data_packet(self, packet: HCI_AclDataPacket) -> None:
+    def on_hci_acl_data_packet(self, packet: hci.HCI_AclDataPacket) -> None:
         self.assembler.feed_packet(packet)
 
     def on_acl_pdu(self, pdu: bytes) -> None:
@@ -165,14 +123,14 @@ class Connection:
 # -----------------------------------------------------------------------------
 @dataclasses.dataclass
 class ScoLink:
-    peer_address: Address
+    peer_address: hci.Address
     handle: int
 
 
 # -----------------------------------------------------------------------------
 @dataclasses.dataclass
 class CisLink:
-    peer_address: Address
+    peer_address: hci.Address
     handle: int
 
 
@@ -188,7 +146,7 @@ class Host(AbortableEventEmitter):
     long_term_key_provider: Optional[
         Callable[[int, bytes, int], Awaitable[Optional[bytes]]]
     ]
-    link_key_provider: Optional[Callable[[Address], Awaitable[Optional[bytes]]]]
+    link_key_provider: Optional[Callable[[hci.Address], Awaitable[Optional[bytes]]]]
 
     def __init__(
         self,
@@ -204,9 +162,12 @@ class Host(AbortableEventEmitter):
         self.sco_links = {}  # SCO links, by connection handle
         self.pending_command = None
         self.pending_response = None
+        self.number_of_supported_advertising_sets = 0
+        self.maximum_advertising_data_length = 31
         self.local_version = None
         self.local_supported_commands = bytes(64)
         self.local_le_features = 0
+        self.local_lmp_features = hci.LmpFeatureMask(0)  # Classic LMP features
         self.suggested_max_tx_octets = 251  # Max allowed
         self.suggested_max_tx_time = 2120  # Max allowed
         self.command_semaphore = asyncio.Semaphore(1)
@@ -223,7 +184,7 @@ class Host(AbortableEventEmitter):
 
     def find_connection_by_bd_addr(
         self,
-        bd_addr: Address,
+        bd_addr: hci.Address,
         transport: Optional[int] = None,
         check_address_type: bool = False,
     ) -> Optional[Connection]:
@@ -265,49 +226,165 @@ class Host(AbortableEventEmitter):
 
         # Send a reset command unless a driver has already done so.
         if reset_needed:
-            await self.send_command(HCI_Reset_Command(), check_result=True)
+            await self.send_command(hci.HCI_Reset_Command(), check_result=True)
             self.ready = True
 
         response = await self.send_command(
-            HCI_Read_Local_Supported_Commands_Command(), check_result=True
+            hci.HCI_Read_Local_Supported_Commands_Command(), check_result=True
         )
         self.local_supported_commands = response.return_parameters.supported_commands
 
-        if self.supports_command(HCI_LE_READ_LOCAL_SUPPORTED_FEATURES_COMMAND):
+        if self.supports_command(hci.HCI_LE_READ_LOCAL_SUPPORTED_FEATURES_COMMAND):
             response = await self.send_command(
-                HCI_LE_Read_Local_Supported_Features_Command(), check_result=True
+                hci.HCI_LE_Read_Local_Supported_Features_Command(), check_result=True
             )
             self.local_le_features = struct.unpack(
                 '<Q', response.return_parameters.le_features
             )[0]
 
-        if self.supports_command(HCI_READ_LOCAL_VERSION_INFORMATION_COMMAND):
+        if self.supports_command(hci.HCI_READ_LOCAL_VERSION_INFORMATION_COMMAND):
             response = await self.send_command(
-                HCI_Read_Local_Version_Information_Command(), check_result=True
+                hci.HCI_Read_Local_Version_Information_Command(), check_result=True
             )
             self.local_version = response.return_parameters
 
+        if self.supports_command(hci.HCI_READ_LOCAL_EXTENDED_FEATURES_COMMAND):
+            max_page_number = 0
+            page_number = 0
+            lmp_features = 0
+            while page_number <= max_page_number:
+                response = await self.send_command(
+                    hci.HCI_Read_Local_Extended_Features_Command(
+                        page_number=page_number
+                    ),
+                    check_result=True,
+                )
+                lmp_features |= int.from_bytes(
+                    response.return_parameters.extended_lmp_features, 'little'
+                ) << (64 * page_number)
+                max_page_number = response.return_parameters.maximum_page_number
+                page_number += 1
+            self.local_lmp_features = hci.LmpFeatureMask(lmp_features)
+
+        elif self.supports_command(hci.HCI_READ_LOCAL_SUPPORTED_FEATURES_COMMAND):
+            response = await self.send_command(
+                hci.HCI_Read_Local_Supported_Features_Command(), check_result=True
+            )
+            self.local_lmp_features = hci.LmpFeatureMask(
+                int.from_bytes(response.return_parameters.lmp_features, 'little')
+            )
+
         await self.send_command(
-            HCI_Set_Event_Mask_Command(event_mask=bytes.fromhex('FFFFFFFFFFFFFF3F'))
+            hci.HCI_Set_Event_Mask_Command(
+                event_mask=hci.HCI_Set_Event_Mask_Command.mask(
+                    [
+                        hci.HCI_INQUIRY_COMPLETE_EVENT,
+                        hci.HCI_INQUIRY_RESULT_EVENT,
+                        hci.HCI_CONNECTION_COMPLETE_EVENT,
+                        hci.HCI_CONNECTION_REQUEST_EVENT,
+                        hci.HCI_DISCONNECTION_COMPLETE_EVENT,
+                        hci.HCI_AUTHENTICATION_COMPLETE_EVENT,
+                        hci.HCI_REMOTE_NAME_REQUEST_COMPLETE_EVENT,
+                        hci.HCI_ENCRYPTION_CHANGE_EVENT,
+                        hci.HCI_CHANGE_CONNECTION_LINK_KEY_COMPLETE_EVENT,
+                        hci.HCI_LINK_KEY_TYPE_CHANGED_EVENT,
+                        hci.HCI_READ_REMOTE_SUPPORTED_FEATURES_COMPLETE_EVENT,
+                        hci.HCI_READ_REMOTE_VERSION_INFORMATION_COMPLETE_EVENT,
+                        hci.HCI_QOS_SETUP_COMPLETE_EVENT,
+                        hci.HCI_HARDWARE_ERROR_EVENT,
+                        hci.HCI_FLUSH_OCCURRED_EVENT,
+                        hci.HCI_ROLE_CHANGE_EVENT,
+                        hci.HCI_MODE_CHANGE_EVENT,
+                        hci.HCI_RETURN_LINK_KEYS_EVENT,
+                        hci.HCI_PIN_CODE_REQUEST_EVENT,
+                        hci.HCI_LINK_KEY_REQUEST_EVENT,
+                        hci.HCI_LINK_KEY_NOTIFICATION_EVENT,
+                        hci.HCI_LOOPBACK_COMMAND_EVENT,
+                        hci.HCI_DATA_BUFFER_OVERFLOW_EVENT,
+                        hci.HCI_MAX_SLOTS_CHANGE_EVENT,
+                        hci.HCI_READ_CLOCK_OFFSET_COMPLETE_EVENT,
+                        hci.HCI_CONNECTION_PACKET_TYPE_CHANGED_EVENT,
+                        hci.HCI_QOS_VIOLATION_EVENT,
+                        hci.HCI_PAGE_SCAN_REPETITION_MODE_CHANGE_EVENT,
+                        hci.HCI_FLOW_SPECIFICATION_COMPLETE_EVENT,
+                        hci.HCI_INQUIRY_RESULT_WITH_RSSI_EVENT,
+                        hci.HCI_READ_REMOTE_EXTENDED_FEATURES_COMPLETE_EVENT,
+                        hci.HCI_SYNCHRONOUS_CONNECTION_COMPLETE_EVENT,
+                        hci.HCI_SYNCHRONOUS_CONNECTION_CHANGED_EVENT,
+                        hci.HCI_SNIFF_SUBRATING_EVENT,
+                        hci.HCI_EXTENDED_INQUIRY_RESULT_EVENT,
+                        hci.HCI_ENCRYPTION_KEY_REFRESH_COMPLETE_EVENT,
+                        hci.HCI_IO_CAPABILITY_REQUEST_EVENT,
+                        hci.HCI_IO_CAPABILITY_RESPONSE_EVENT,
+                        hci.HCI_USER_CONFIRMATION_REQUEST_EVENT,
+                        hci.HCI_USER_PASSKEY_REQUEST_EVENT,
+                        hci.HCI_REMOTE_OOB_DATA_REQUEST_EVENT,
+                        hci.HCI_SIMPLE_PAIRING_COMPLETE_EVENT,
+                        hci.HCI_LINK_SUPERVISION_TIMEOUT_CHANGED_EVENT,
+                        hci.HCI_ENHANCED_FLUSH_COMPLETE_EVENT,
+                        hci.HCI_USER_PASSKEY_NOTIFICATION_EVENT,
+                        hci.HCI_KEYPRESS_NOTIFICATION_EVENT,
+                        hci.HCI_REMOTE_HOST_SUPPORTED_FEATURES_NOTIFICATION_EVENT,
+                        hci.HCI_LE_META_EVENT,
+                    ]
+                )
+            )
         )
 
         if (
             self.local_version is not None
-            and self.local_version.hci_version <= HCI_VERSION_BLUETOOTH_CORE_4_0
+            and self.local_version.hci_version <= hci.HCI_VERSION_BLUETOOTH_CORE_4_0
         ):
             # Some older controllers don't like event masks with bits they don't
             # understand
             le_event_mask = bytes.fromhex('1F00000000000000')
         else:
-            le_event_mask = bytes.fromhex('FFFFFFFF00000000')
+            le_event_mask = hci.HCI_LE_Set_Event_Mask_Command.mask(
+                [
+                    hci.HCI_LE_CONNECTION_COMPLETE_EVENT,
+                    hci.HCI_LE_ADVERTISING_REPORT_EVENT,
+                    hci.HCI_LE_CONNECTION_UPDATE_COMPLETE_EVENT,
+                    hci.HCI_LE_READ_REMOTE_FEATURES_COMPLETE_EVENT,
+                    hci.HCI_LE_LONG_TERM_KEY_REQUEST_EVENT,
+                    hci.HCI_LE_REMOTE_CONNECTION_PARAMETER_REQUEST_EVENT,
+                    hci.HCI_LE_DATA_LENGTH_CHANGE_EVENT,
+                    hci.HCI_LE_READ_LOCAL_P_256_PUBLIC_KEY_COMPLETE_EVENT,
+                    hci.HCI_LE_GENERATE_DHKEY_COMPLETE_EVENT,
+                    hci.HCI_LE_ENHANCED_CONNECTION_COMPLETE_EVENT,
+                    hci.HCI_LE_DIRECTED_ADVERTISING_REPORT_EVENT,
+                    hci.HCI_LE_PHY_UPDATE_COMPLETE_EVENT,
+                    hci.HCI_LE_EXTENDED_ADVERTISING_REPORT_EVENT,
+                    hci.HCI_LE_PERIODIC_ADVERTISING_SYNC_ESTABLISHED_EVENT,
+                    hci.HCI_LE_PERIODIC_ADVERTISING_REPORT_EVENT,
+                    hci.HCI_LE_PERIODIC_ADVERTISING_SYNC_LOST_EVENT,
+                    hci.HCI_LE_SCAN_TIMEOUT_EVENT,
+                    hci.HCI_LE_ADVERTISING_SET_TERMINATED_EVENT,
+                    hci.HCI_LE_SCAN_REQUEST_RECEIVED_EVENT,
+                    hci.HCI_LE_CONNECTIONLESS_IQ_REPORT_EVENT,
+                    hci.HCI_LE_CONNECTION_IQ_REPORT_EVENT,
+                    hci.HCI_LE_CTE_REQUEST_FAILED_EVENT,
+                    hci.HCI_LE_PERIODIC_ADVERTISING_SYNC_TRANSFER_RECEIVED_EVENT,
+                    hci.HCI_LE_CIS_ESTABLISHED_EVENT,
+                    hci.HCI_LE_CIS_REQUEST_EVENT,
+                    hci.HCI_LE_CREATE_BIG_COMPLETE_EVENT,
+                    hci.HCI_LE_TERMINATE_BIG_COMPLETE_EVENT,
+                    hci.HCI_LE_BIG_SYNC_ESTABLISHED_EVENT,
+                    hci.HCI_LE_BIG_SYNC_LOST_EVENT,
+                    hci.HCI_LE_REQUEST_PEER_SCA_COMPLETE_EVENT,
+                    hci.HCI_LE_PATH_LOSS_THRESHOLD_EVENT,
+                    hci.HCI_LE_TRANSMIT_POWER_REPORTING_EVENT,
+                    hci.HCI_LE_BIGINFO_ADVERTISING_REPORT_EVENT,
+                    hci.HCI_LE_SUBRATE_CHANGE_EVENT,
+                ]
+            )
 
         await self.send_command(
-            HCI_LE_Set_Event_Mask_Command(le_event_mask=le_event_mask)
+            hci.HCI_LE_Set_Event_Mask_Command(le_event_mask=le_event_mask)
         )
 
-        if self.supports_command(HCI_READ_BUFFER_SIZE_COMMAND):
+        if self.supports_command(hci.HCI_READ_BUFFER_SIZE_COMMAND):
             response = await self.send_command(
-                HCI_Read_Buffer_Size_Command(), check_result=True
+                hci.HCI_Read_Buffer_Size_Command(), check_result=True
             )
             hc_acl_data_packet_length = (
                 response.return_parameters.hc_acl_data_packet_length
@@ -330,9 +407,9 @@ class Host(AbortableEventEmitter):
 
         hc_le_acl_data_packet_length = 0
         hc_total_num_le_acl_data_packets = 0
-        if self.supports_command(HCI_LE_READ_BUFFER_SIZE_COMMAND):
+        if self.supports_command(hci.HCI_LE_READ_BUFFER_SIZE_COMMAND):
             response = await self.send_command(
-                HCI_LE_Read_Buffer_Size_Command(), check_result=True
+                hci.HCI_LE_Read_Buffer_Size_Command(), check_result=True
             )
             hc_le_acl_data_packet_length = (
                 response.return_parameters.hc_le_acl_data_packet_length
@@ -359,10 +436,12 @@ class Host(AbortableEventEmitter):
             )
 
         if self.supports_command(
-            HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND
-        ) and self.supports_command(HCI_LE_WRITE_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND):
+            hci.HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND
+        ) and self.supports_command(
+            hci.HCI_LE_WRITE_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND
+        ):
             response = await self.send_command(
-                HCI_LE_Read_Suggested_Default_Data_Length_Command()
+                hci.HCI_LE_Read_Suggested_Default_Data_Length_Command()
             )
             suggested_max_tx_octets = response.return_parameters.suggested_max_tx_octets
             suggested_max_tx_time = response.return_parameters.suggested_max_tx_time
@@ -371,12 +450,34 @@ class Host(AbortableEventEmitter):
                 or suggested_max_tx_time != self.suggested_max_tx_time
             ):
                 await self.send_command(
-                    HCI_LE_Write_Suggested_Default_Data_Length_Command(
+                    hci.HCI_LE_Write_Suggested_Default_Data_Length_Command(
                         suggested_max_tx_octets=self.suggested_max_tx_octets,
                         suggested_max_tx_time=self.suggested_max_tx_time,
                     )
                 )
 
+        if self.supports_command(
+            hci.HCI_LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS_COMMAND
+        ):
+            response = await self.send_command(
+                hci.HCI_LE_Read_Number_Of_Supported_Advertising_Sets_Command(),
+                check_result=True,
+            )
+            self.number_of_supported_advertising_sets = (
+                response.return_parameters.num_supported_advertising_sets
+            )
+
+        if self.supports_command(
+            hci.HCI_LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH_COMMAND
+        ):
+            response = await self.send_command(
+                hci.HCI_LE_Read_Maximum_Advertising_Data_Length_Command(),
+                check_result=True,
+            )
+            self.maximum_advertising_data_length = (
+                response.return_parameters.max_advertising_data_length
+            )
+
     @property
     def controller(self) -> Optional[TransportSink]:
         return self.hci_sink
@@ -394,7 +495,7 @@ class Host(AbortableEventEmitter):
         source.set_packet_sink(self)
         self.hci_metadata = getattr(source, 'metadata', self.hci_metadata)
 
-    def send_hci_packet(self, packet: HCI_Packet) -> None:
+    def send_hci_packet(self, packet: hci.HCI_Packet) -> None:
         logger.debug(f'{color("### HOST -> CONTROLLER", "blue")}: {packet}')
         if self.snooper:
             self.snooper.snoop(bytes(packet), Snooper.Direction.HOST_TO_CONTROLLER)
@@ -425,11 +526,12 @@ class Host(AbortableEventEmitter):
                     else:
                         status = response.return_parameters.status
 
-                    if status != HCI_SUCCESS:
+                    if status != hci.HCI_SUCCESS:
                         logger.warning(
-                            f'{command.name} failed ({HCI_Constant.error_name(status)})'
+                            f'{command.name} failed '
+                            f'({hci.HCI_Constant.error_name(status)})'
                         )
-                        raise HCI_Error(status)
+                        raise hci.HCI_Error(status)
 
                 return response
             except Exception as error:
@@ -442,8 +544,8 @@ class Host(AbortableEventEmitter):
                 self.pending_response = None
 
     # Use this method to send a command from a task
-    def send_command_sync(self, command: HCI_Command) -> None:
-        async def send_command(command: HCI_Command) -> None:
+    def send_command_sync(self, command: hci.HCI_Command) -> None:
+        async def send_command(command: hci.HCI_Command) -> None:
             await self.send_command(command)
 
         asyncio.create_task(send_command(command))
@@ -468,7 +570,7 @@ class Host(AbortableEventEmitter):
         pb_flag = 0
         while bytes_remaining:
             data_total_length = min(bytes_remaining, packet_queue.max_packet_size)
-            acl_packet = HCI_AclDataPacket(
+            acl_packet = hci.HCI_AclDataPacket(
                 connection_handle=connection_handle,
                 pb_flag=pb_flag,
                 bc_flag=0,
@@ -483,7 +585,7 @@ class Host(AbortableEventEmitter):
 
     def supports_command(self, command):
         # Find the support flag position for this command
-        for octet, flags in enumerate(HCI_SUPPORTED_COMMANDS_FLAGS):
+        for octet, flags in enumerate(hci.HCI_SUPPORTED_COMMANDS_FLAGS):
             for flag_position, value in enumerate(flags):
                 if value == command:
                     # Check if the flag is set
@@ -498,18 +600,21 @@ class Host(AbortableEventEmitter):
     def supported_commands(self):
         commands = []
         for octet, flags in enumerate(self.local_supported_commands):
-            if octet < len(HCI_SUPPORTED_COMMANDS_FLAGS):
+            if octet < len(hci.HCI_SUPPORTED_COMMANDS_FLAGS):
                 for flag in range(8):
                     if flags & (1 << flag) != 0:
-                        command = HCI_SUPPORTED_COMMANDS_FLAGS[octet][flag]
+                        command = hci.HCI_SUPPORTED_COMMANDS_FLAGS[octet][flag]
                         if command is not None:
                             commands.append(command)
 
         return commands
 
-    def supports_le_features(self, feature: LeFeatureMask) -> bool:
+    def supports_le_features(self, feature: hci.LeFeatureMask) -> bool:
         return (self.local_le_features & feature) == feature
 
+    def supports_lmp_features(self, feature: hci.LmpFeatureMask) -> bool:
+        return self.local_lmp_features & (feature) == feature
+
     @property
     def supported_le_features(self):
         return [
@@ -518,10 +623,10 @@ class Host(AbortableEventEmitter):
 
     # Packet Sink protocol (packets coming from the controller via HCI)
     def on_packet(self, packet: bytes) -> None:
-        hci_packet = HCI_Packet.from_bytes(packet)
+        hci_packet = hci.HCI_Packet.from_bytes(packet)
         if self.ready or (
-            isinstance(hci_packet, HCI_Command_Complete_Event)
-            and hci_packet.command_opcode == HCI_RESET_COMMAND
+            isinstance(hci_packet, hci.HCI_Command_Complete_Event)
+            and hci_packet.command_opcode == hci.HCI_RESET_COMMAND
         ):
             self.on_hci_packet(hci_packet)
         else:
@@ -534,44 +639,44 @@ class Host(AbortableEventEmitter):
 
         self.emit('flush')
 
-    def on_hci_packet(self, packet: HCI_Packet) -> None:
+    def on_hci_packet(self, packet: hci.HCI_Packet) -> None:
         logger.debug(f'{color("### CONTROLLER -> HOST", "green")}: {packet}')
 
         if self.snooper:
             self.snooper.snoop(bytes(packet), Snooper.Direction.CONTROLLER_TO_HOST)
 
         # If the packet is a command, invoke the handler for this packet
-        if packet.hci_packet_type == HCI_COMMAND_PACKET:
-            self.on_hci_command_packet(cast(HCI_Command, packet))
-        elif packet.hci_packet_type == HCI_EVENT_PACKET:
-            self.on_hci_event_packet(cast(HCI_Event, packet))
-        elif packet.hci_packet_type == HCI_ACL_DATA_PACKET:
-            self.on_hci_acl_data_packet(cast(HCI_AclDataPacket, packet))
-        elif packet.hci_packet_type == HCI_SYNCHRONOUS_DATA_PACKET:
-            self.on_hci_sco_data_packet(cast(HCI_SynchronousDataPacket, packet))
-        elif packet.hci_packet_type == HCI_ISO_DATA_PACKET:
-            self.on_hci_iso_data_packet(cast(HCI_IsoDataPacket, packet))
+        if packet.hci_packet_type == hci.HCI_COMMAND_PACKET:
+            self.on_hci_command_packet(cast(hci.HCI_Command, packet))
+        elif packet.hci_packet_type == hci.HCI_EVENT_PACKET:
+            self.on_hci_event_packet(cast(hci.HCI_Event, packet))
+        elif packet.hci_packet_type == hci.HCI_ACL_DATA_PACKET:
+            self.on_hci_acl_data_packet(cast(hci.HCI_AclDataPacket, packet))
+        elif packet.hci_packet_type == hci.HCI_SYNCHRONOUS_DATA_PACKET:
+            self.on_hci_sco_data_packet(cast(hci.HCI_SynchronousDataPacket, packet))
+        elif packet.hci_packet_type == hci.HCI_ISO_DATA_PACKET:
+            self.on_hci_iso_data_packet(cast(hci.HCI_IsoDataPacket, packet))
         else:
             logger.warning(f'!!! unknown packet type {packet.hci_packet_type}')
 
-    def on_hci_command_packet(self, command: HCI_Command) -> None:
+    def on_hci_command_packet(self, command: hci.HCI_Command) -> None:
         logger.warning(f'!!! unexpected command packet: {command}')
 
-    def on_hci_event_packet(self, event: HCI_Event) -> None:
+    def on_hci_event_packet(self, event: hci.HCI_Event) -> None:
         handler_name = f'on_{event.name.lower()}'
         handler = getattr(self, handler_name, self.on_hci_event)
         handler(event)
 
-    def on_hci_acl_data_packet(self, packet: HCI_AclDataPacket) -> None:
+    def on_hci_acl_data_packet(self, packet: hci.HCI_AclDataPacket) -> None:
         # Look for the connection to which this data belongs
         if connection := self.connections.get(packet.connection_handle):
             connection.on_hci_acl_data_packet(packet)
 
-    def on_hci_sco_data_packet(self, packet: HCI_SynchronousDataPacket) -> None:
+    def on_hci_sco_data_packet(self, packet: hci.HCI_SynchronousDataPacket) -> None:
         # Experimental
         self.emit('sco_packet', packet.connection_handle, packet)
 
-    def on_hci_iso_data_packet(self, packet: HCI_IsoDataPacket) -> None:
+    def on_hci_iso_data_packet(self, packet: hci.HCI_IsoDataPacket) -> None:
         # Experimental
         self.emit('iso_packet', packet.connection_handle, packet)
 
@@ -635,11 +740,11 @@ class Host(AbortableEventEmitter):
 
     def on_hci_le_connection_complete_event(self, event):
         # Check if this is a cancellation
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             # Create/update the connection
             logger.debug(
                 f'### LE CONNECTION: [0x{event.connection_handle:04X}] '
-                f'{event.peer_address} as {HCI_Constant.role_name(event.role)}'
+                f'{event.peer_address} as {hci.HCI_Constant.role_name(event.role)}'
             )
 
             connection = self.connections.get(event.connection_handle)
@@ -679,7 +784,7 @@ class Host(AbortableEventEmitter):
         self.on_hci_le_connection_complete_event(event)
 
     def on_hci_connection_complete_event(self, event):
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             # Create/update the connection
             logger.debug(
                 f'### BR/EDR CONNECTION: [0x{event.connection_handle:04X}] '
@@ -726,7 +831,7 @@ class Host(AbortableEventEmitter):
             logger.warning('!!! DISCONNECTION COMPLETE: unknown handle')
             return
 
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             logger.debug(
                 f'### DISCONNECTION: [0x{handle:04X}] '
                 f'{connection.peer_address} '
@@ -735,7 +840,9 @@ class Host(AbortableEventEmitter):
 
             # Notify the listeners
             self.emit('disconnection', handle, event.reason)
-            (
+
+            # Remove the handle reference
+            _ = (
                 self.connections.pop(handle, 0)
                 or self.cis_links.pop(handle, 0)
                 or self.sco_links.pop(handle, 0)
@@ -752,7 +859,7 @@ class Host(AbortableEventEmitter):
             return
 
         # Notify the client
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             connection_parameters = ConnectionParameters(
                 event.connection_interval,
                 event.peripheral_latency,
@@ -772,7 +879,7 @@ class Host(AbortableEventEmitter):
             return
 
         # Notify the client
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             connection_phy = ConnectionPHY(event.tx_phy, event.rx_phy)
             self.emit('connection_phy_update', connection.handle, connection_phy)
         else:
@@ -791,6 +898,7 @@ class Host(AbortableEventEmitter):
             event.status,
             event.advertising_handle,
             event.connection_handle,
+            event.num_completed_extended_advertising_events,
         )
 
     def on_hci_le_cis_request_event(self, event):
@@ -804,10 +912,10 @@ class Host(AbortableEventEmitter):
 
     def on_hci_le_cis_established_event(self, event):
         # The remaining parameters are unused for now.
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             self.cis_links[event.connection_handle] = CisLink(
                 handle=event.connection_handle,
-                peer_address=Address.ANY,
+                peer_address=hci.Address.ANY,
             )
             self.emit('cis_establishment', event.connection_handle)
         else:
@@ -823,7 +931,7 @@ class Host(AbortableEventEmitter):
         # For now, just accept everything
         # TODO: delegate the decision
         self.send_command_sync(
-            HCI_LE_Remote_Connection_Parameter_Request_Reply_Command(
+            hci.HCI_LE_Remote_Connection_Parameter_Request_Reply_Command(
                 connection_handle=event.connection_handle,
                 interval_min=event.interval_min,
                 interval_max=event.interval_max,
@@ -854,12 +962,12 @@ class Host(AbortableEventEmitter):
                     ),
                 )
             if long_term_key:
-                response = HCI_LE_Long_Term_Key_Request_Reply_Command(
+                response = hci.HCI_LE_Long_Term_Key_Request_Reply_Command(
                     connection_handle=event.connection_handle,
                     long_term_key=long_term_key,
                 )
             else:
-                response = HCI_LE_Long_Term_Key_Request_Negative_Reply_Command(
+                response = hci.HCI_LE_Long_Term_Key_Request_Negative_Reply_Command(
                     connection_handle=event.connection_handle
                 )
 
@@ -868,7 +976,7 @@ class Host(AbortableEventEmitter):
         asyncio.create_task(send_long_term_key())
 
     def on_hci_synchronous_connection_complete_event(self, event):
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             # Create/update the connection
             logger.debug(
                 f'### SCO CONNECTION: [0x{event.connection_handle:04X}] '
@@ -897,16 +1005,16 @@ class Host(AbortableEventEmitter):
         pass
 
     def on_hci_role_change_event(self, event):
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             logger.debug(
                 f'role change for {event.bd_addr}: '
-                f'{HCI_Constant.role_name(event.new_role)}'
+                f'{hci.HCI_Constant.role_name(event.new_role)}'
             )
             self.emit('role_change', event.bd_addr, event.new_role)
         else:
             logger.debug(
                 f'role change for {event.bd_addr} failed: '
-                f'{HCI_Constant.error_name(event.status)}'
+                f'{hci.HCI_Constant.error_name(event.status)}'
             )
             self.emit('role_change_failure', event.bd_addr, event.status)
 
@@ -922,7 +1030,7 @@ class Host(AbortableEventEmitter):
 
     def on_hci_authentication_complete_event(self, event):
         # Notify the client
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             self.emit('connection_authentication', event.connection_handle)
         else:
             self.emit(
@@ -933,7 +1041,7 @@ class Host(AbortableEventEmitter):
 
     def on_hci_encryption_change_event(self, event):
         # Notify the client
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             self.emit(
                 'connection_encryption_change',
                 event.connection_handle,
@@ -946,7 +1054,7 @@ class Host(AbortableEventEmitter):
 
     def on_hci_encryption_key_refresh_complete_event(self, event):
         # Notify the client
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             self.emit('connection_encryption_key_refresh', event.connection_handle)
         else:
             self.emit(
@@ -967,16 +1075,16 @@ class Host(AbortableEventEmitter):
     def on_hci_link_key_notification_event(self, event):
         logger.debug(
             f'link key for {event.bd_addr}: {event.link_key.hex()}, '
-            f'type={HCI_Constant.link_key_type_name(event.key_type)}'
+            f'type={hci.HCI_Constant.link_key_type_name(event.key_type)}'
         )
         self.emit('link_key', event.bd_addr, event.link_key, event.key_type)
 
     def on_hci_simple_pairing_complete_event(self, event):
         logger.debug(
             f'simple pairing complete for {event.bd_addr}: '
-            f'status={HCI_Constant.status_name(event.status)}'
+            f'status={hci.HCI_Constant.status_name(event.status)}'
         )
-        if event.status == HCI_SUCCESS:
+        if event.status == hci.HCI_SUCCESS:
             self.emit('classic_pairing', event.bd_addr)
         else:
             self.emit('classic_pairing_failure', event.bd_addr, event.status)
@@ -996,11 +1104,11 @@ class Host(AbortableEventEmitter):
                     self.link_key_provider(event.bd_addr),
                 )
             if link_key:
-                response = HCI_Link_Key_Request_Reply_Command(
+                response = hci.HCI_Link_Key_Request_Reply_Command(
                     bd_addr=event.bd_addr, link_key=link_key
                 )
             else:
-                response = HCI_Link_Key_Request_Negative_Reply_Command(
+                response = hci.HCI_Link_Key_Request_Negative_Reply_Command(
                     bd_addr=event.bd_addr
                 )
 
@@ -1057,7 +1165,7 @@ class Host(AbortableEventEmitter):
         )
 
     def on_hci_remote_name_request_complete_event(self, event):
-        if event.status != HCI_SUCCESS:
+        if event.status != hci.HCI_SUCCESS:
             self.emit('remote_name_failure', event.bd_addr, event.status)
         else:
             utf8_name = event.remote_name
@@ -1075,7 +1183,7 @@ class Host(AbortableEventEmitter):
         )
 
     def on_hci_le_read_remote_features_complete_event(self, event):
-        if event.status != HCI_SUCCESS:
+        if event.status != hci.HCI_SUCCESS:
             self.emit(
                 'le_remote_features_failure', event.connection_handle, event.status
             )

bumble/l2cap.py

@@ -173,7 +173,7 @@ L2CAP_MTU_CONFIGURATION_PARAMETER_TYPE = 0x01
 @dataclasses.dataclass
 class ClassicChannelSpec:
     psm: Optional[int] = None
-    mtu: int = L2CAP_MIN_BR_EDR_MTU
+    mtu: int = L2CAP_DEFAULT_MTU
 
 
 @dataclasses.dataclass
@@ -208,7 +208,7 @@ class L2CAP_PDU:
 
     @staticmethod
     def from_bytes(data: bytes) -> L2CAP_PDU:
-        # Sanity check
+        # Check parameters
         if len(data) < 4:
             raise ValueError('not enough data for L2CAP header')
 
@@ -749,6 +749,8 @@ class ClassicChannel(EventEmitter):
     sink: Optional[Callable[[bytes], Any]]
     state: State
     connection: Connection
+    mtu: int
+    peer_mtu: int
 
     def __init__(
         self,
@@ -765,6 +767,7 @@ class ClassicChannel(EventEmitter):
         self.signaling_cid = signaling_cid
         self.state = self.State.CLOSED
         self.mtu = mtu
+        self.peer_mtu = L2CAP_MIN_BR_EDR_MTU
         self.psm = psm
         self.source_cid = source_cid
         self.destination_cid = 0
@@ -861,7 +864,7 @@ class ClassicChannel(EventEmitter):
             [
                 (
                     L2CAP_MAXIMUM_TRANSMISSION_UNIT_CONFIGURATION_OPTION_TYPE,
-                    struct.pack('<H', L2CAP_DEFAULT_MTU),
+                    struct.pack('<H', self.mtu),
                 )
             ]
         )
@@ -926,8 +929,8 @@ class ClassicChannel(EventEmitter):
         options = L2CAP_Control_Frame.decode_configuration_options(request.options)
         for option in options:
             if option[0] == L2CAP_MTU_CONFIGURATION_PARAMETER_TYPE:
-                self.mtu = struct.unpack('<H', option[1])[0]
-                logger.debug(f'MTU = {self.mtu}')
+                self.peer_mtu = struct.unpack('<H', option[1])[0]
+                logger.debug(f'peer MTU = {self.peer_mtu}')
 
         self.send_control_frame(
             L2CAP_Configure_Response(
@@ -1026,7 +1029,7 @@ class ClassicChannel(EventEmitter):
         return (
             f'Channel({self.source_cid}->{self.destination_cid}, '
             f'PSM={self.psm}, '
-            f'MTU={self.mtu}, '
+            f'MTU={self.mtu}/{self.peer_mtu}, '
             f'state={self.state.name})'
         )
 

bumble/profiles/vcp.py

@@ -0,0 +1,228 @@
+# Copyright 2021-2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+from __future__ import annotations
+import enum
+
+from bumble import att
+from bumble import device
+from bumble import gatt
+from bumble import gatt_client
+
+from typing import Optional
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+
+MIN_VOLUME = 0
+MAX_VOLUME = 255
+
+
+class ErrorCode(enum.IntEnum):
+    '''
+    See Volume Control Service 1.6. Application error codes.
+    '''
+
+    INVALID_CHANGE_COUNTER = 0x80
+    OPCODE_NOT_SUPPORTED = 0x81
+
+
+class VolumeFlags(enum.IntFlag):
+    '''
+    See Volume Control Service 3.3. Volume Flags.
+    '''
+
+    VOLUME_SETTING_PERSISTED = 0x01
+    # RFU
+
+
+class VolumeControlPointOpcode(enum.IntEnum):
+    '''
+    See Volume Control Service Table 3.3: Volume Control Point procedure requirements.
+    '''
+
+    # fmt: off
+    RELATIVE_VOLUME_DOWN        = 0x00
+    RELATIVE_VOLUME_UP          = 0x01
+    UNMUTE_RELATIVE_VOLUME_DOWN = 0x02
+    UNMUTE_RELATIVE_VOLUME_UP   = 0x03
+    SET_ABSOLUTE_VOLUME         = 0x04
+    UNMUTE                      = 0x05
+    MUTE                        = 0x06
+
+
+# -----------------------------------------------------------------------------
+# Server
+# -----------------------------------------------------------------------------
+class VolumeControlService(gatt.TemplateService):
+    UUID = gatt.GATT_VOLUME_CONTROL_SERVICE
+
+    volume_state: gatt.Characteristic
+    volume_control_point: gatt.Characteristic
+    volume_flags: gatt.Characteristic
+
+    volume_setting: int
+    muted: int
+    change_counter: int
+
+    def __init__(
+        self,
+        step_size: int = 16,
+        volume_setting: int = 0,
+        muted: int = 0,
+        change_counter: int = 0,
+        volume_flags: int = 0,
+    ) -> None:
+        self.step_size = step_size
+        self.volume_setting = volume_setting
+        self.muted = muted
+        self.change_counter = change_counter
+
+        self.volume_state = gatt.Characteristic(
+            uuid=gatt.GATT_VOLUME_STATE_CHARACTERISTIC,
+            properties=(
+                gatt.Characteristic.Properties.READ
+                | gatt.Characteristic.Properties.NOTIFY
+            ),
+            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
+            value=gatt.CharacteristicValue(read=self._on_read_volume_state),
+        )
+        self.volume_control_point = gatt.Characteristic(
+            uuid=gatt.GATT_VOLUME_CONTROL_POINT_CHARACTERISTIC,
+            properties=gatt.Characteristic.Properties.WRITE,
+            permissions=gatt.Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION,
+            value=gatt.CharacteristicValue(write=self._on_write_volume_control_point),
+        )
+        self.volume_flags = gatt.Characteristic(
+            uuid=gatt.GATT_VOLUME_FLAGS_CHARACTERISTIC,
+            properties=gatt.Characteristic.Properties.READ,
+            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
+            value=bytes([volume_flags]),
+        )
+
+        super().__init__(
+            [
+                self.volume_state,
+                self.volume_control_point,
+                self.volume_flags,
+            ]
+        )
+
+    @property
+    def volume_state_bytes(self) -> bytes:
+        return bytes([self.volume_setting, self.muted, self.change_counter])
+
+    @volume_state_bytes.setter
+    def volume_state_bytes(self, new_value: bytes) -> None:
+        self.volume_setting, self.muted, self.change_counter = new_value
+
+    def _on_read_volume_state(self, _connection: Optional[device.Connection]) -> bytes:
+        return self.volume_state_bytes
+
+    def _on_write_volume_control_point(
+        self, connection: Optional[device.Connection], value: bytes
+    ) -> None:
+        assert connection
+
+        opcode = VolumeControlPointOpcode(value[0])
+        change_counter = value[1]
+
+        if change_counter != self.change_counter:
+            raise att.ATT_Error(ErrorCode.INVALID_CHANGE_COUNTER)
+
+        handler = getattr(self, '_on_' + opcode.name.lower())
+        if handler(*value[2:]):
+            self.change_counter = (self.change_counter + 1) % 256
+            connection.abort_on(
+                'disconnection',
+                connection.device.notify_subscribers(
+                    attribute=self.volume_state,
+                    value=self.volume_state_bytes,
+                ),
+            )
+            self.emit(
+                'volume_state', self.volume_setting, self.muted, self.change_counter
+            )
+
+    def _on_relative_volume_down(self) -> bool:
+        old_volume = self.volume_setting
+        self.volume_setting = max(self.volume_setting - self.step_size, MIN_VOLUME)
+        return self.volume_setting != old_volume
+
+    def _on_relative_volume_up(self) -> bool:
+        old_volume = self.volume_setting
+        self.volume_setting = min(self.volume_setting + self.step_size, MAX_VOLUME)
+        return self.volume_setting != old_volume
+
+    def _on_unmute_relative_volume_down(self) -> bool:
+        old_volume, old_muted_state = self.volume_setting, self.muted
+        self.volume_setting = max(self.volume_setting - self.step_size, MIN_VOLUME)
+        self.muted = 0
+        return (self.volume_setting, self.muted) != (old_volume, old_muted_state)
+
+    def _on_unmute_relative_volume_up(self) -> bool:
+        old_volume, old_muted_state = self.volume_setting, self.muted
+        self.volume_setting = min(self.volume_setting + self.step_size, MAX_VOLUME)
+        self.muted = 0
+        return (self.volume_setting, self.muted) != (old_volume, old_muted_state)
+
+    def _on_set_absolute_volume(self, volume_setting: int) -> bool:
+        old_volume_setting = self.volume_setting
+        self.volume_setting = volume_setting
+        return old_volume_setting != self.volume_setting
+
+    def _on_unmute(self) -> bool:
+        old_muted_state = self.muted
+        self.muted = 0
+        return self.muted != old_muted_state
+
+    def _on_mute(self) -> bool:
+        old_muted_state = self.muted
+        self.muted = 1
+        return self.muted != old_muted_state
+
+
+# -----------------------------------------------------------------------------
+# Client
+# -----------------------------------------------------------------------------
+class VolumeControlServiceProxy(gatt_client.ProfileServiceProxy):
+    SERVICE_CLASS = VolumeControlService
+
+    volume_control_point: gatt_client.CharacteristicProxy
+
+    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
+        self.service_proxy = service_proxy
+
+        self.volume_state = gatt.PackedCharacteristicAdapter(
+            service_proxy.get_characteristics_by_uuid(
+                gatt.GATT_VOLUME_STATE_CHARACTERISTIC
+            )[0],
+            'BBB',
+        )
+
+        self.volume_control_point = service_proxy.get_characteristics_by_uuid(
+            gatt.GATT_VOLUME_CONTROL_POINT_CHARACTERISTIC
+        )[0]
+
+        self.volume_flags = gatt.PackedCharacteristicAdapter(
+            service_proxy.get_characteristics_by_uuid(
+                gatt.GATT_VOLUME_FLAGS_CHARACTERISTIC
+            )[0],
+            'B',
+        )

bumble/rfcomm.py

@@ -22,10 +22,13 @@ import asyncio
 import dataclasses
 import enum
 from typing import Callable, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
+from typing_extensions import Self
 
 from pyee import EventEmitter
 
-from . import core, l2cap
+from bumble import core
+from bumble import l2cap
+from bumble import sdp
 from .colors import color
 from .core import (
     UUID,
@@ -35,15 +38,6 @@ from .core import (
     InvalidStateError,
     ProtocolError,
 )
-from .sdp import (
-    SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-    SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
-    SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-    SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-    SDP_PUBLIC_BROWSE_ROOT,
-    DataElement,
-    ServiceAttribute,
-)
 
 if TYPE_CHECKING:
     from bumble.device import Device, Connection
@@ -110,6 +104,7 @@ CRC_TABLE = bytes([
     0XBA, 0X2B, 0X59, 0XC8, 0XBD, 0X2C, 0X5E, 0XCF
 ])
 
+RFCOMM_DEFAULT_L2CAP_MTU      = 2048
 RFCOMM_DEFAULT_WINDOW_SIZE    = 7
 RFCOMM_DEFAULT_MAX_FRAME_SIZE = 2000
 
@@ -122,29 +117,33 @@ RFCOMM_DYNAMIC_CHANNEL_NUMBER_END   = 30
 # -----------------------------------------------------------------------------
 def make_service_sdp_records(
     service_record_handle: int, channel: int, uuid: Optional[UUID] = None
-) -> List[ServiceAttribute]:
+) -> List[sdp.ServiceAttribute]:
     """
     Create SDP records for an RFComm service given a channel number and an
     optional UUID. A Service Class Attribute is included only if the UUID is not None.
     """
     records = [
-        ServiceAttribute(
-            SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-            DataElement.unsigned_integer_32(service_record_handle),
+        sdp.ServiceAttribute(
+            sdp.SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+            sdp.DataElement.unsigned_integer_32(service_record_handle),
         ),
-        ServiceAttribute(
-            SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
-            DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
+        sdp.ServiceAttribute(
+            sdp.SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
+            sdp.DataElement.sequence(
+                [sdp.DataElement.uuid(sdp.SDP_PUBLIC_BROWSE_ROOT)]
+            ),
         ),
-        ServiceAttribute(
-            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
+        sdp.ServiceAttribute(
+            sdp.SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+            sdp.DataElement.sequence(
                 [
-                    DataElement.sequence([DataElement.uuid(BT_L2CAP_PROTOCOL_ID)]),
-                    DataElement.sequence(
+                    sdp.DataElement.sequence(
+                        [sdp.DataElement.uuid(BT_L2CAP_PROTOCOL_ID)]
+                    ),
+                    sdp.DataElement.sequence(
                         [
-                            DataElement.uuid(BT_RFCOMM_PROTOCOL_ID),
-                            DataElement.unsigned_integer_8(channel),
+                            sdp.DataElement.uuid(BT_RFCOMM_PROTOCOL_ID),
+                            sdp.DataElement.unsigned_integer_8(channel),
                         ]
                     ),
                 ]
@@ -154,15 +153,81 @@ def make_service_sdp_records(
 
     if uuid:
         records.append(
-            ServiceAttribute(
-                SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-                DataElement.sequence([DataElement.uuid(uuid)]),
+            sdp.ServiceAttribute(
+                sdp.SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+                sdp.DataElement.sequence([sdp.DataElement.uuid(uuid)]),
             )
         )
 
     return records
 
 
+# -----------------------------------------------------------------------------
+async def find_rfcomm_channels(connection: Connection) -> Dict[int, List[UUID]]:
+    """Searches all RFCOMM channels and their associated UUID from SDP service records.
+
+    Args:
+        connection: ACL connection to make SDP search.
+
+    Returns:
+        Dictionary mapping from channel number to service class UUID list.
+    """
+    results = {}
+    async with sdp.Client(connection) as sdp_client:
+        search_result = await sdp_client.search_attributes(
+            uuids=[core.BT_RFCOMM_PROTOCOL_ID],
+            attribute_ids=[
+                sdp.SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                sdp.SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+            ],
+        )
+        for attribute_lists in search_result:
+            service_classes: List[UUID] = []
+            channel: Optional[int] = None
+            for attribute in attribute_lists:
+                # The layout is [[L2CAP_PROTOCOL], [RFCOMM_PROTOCOL, RFCOMM_CHANNEL]].
+                if attribute.id == sdp.SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID:
+                    protocol_descriptor_list = attribute.value.value
+                    channel = protocol_descriptor_list[1].value[1].value
+                elif attribute.id == sdp.SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID:
+                    service_class_id_list = attribute.value.value
+                    service_classes = [
+                        service_class.value for service_class in service_class_id_list
+                    ]
+            if not service_classes or not channel:
+                logger.warning(f"Bad result {attribute_lists}.")
+            else:
+                results[channel] = service_classes
+    return results
+
+
+# -----------------------------------------------------------------------------
+async def find_rfcomm_channel_with_uuid(
+    connection: Connection, uuid: str | UUID
+) -> Optional[int]:
+    """Searches an RFCOMM channel associated with given UUID from service records.
+
+    Args:
+        connection: ACL connection to make SDP search.
+        uuid: UUID of service record to search for.
+
+    Returns:
+        RFCOMM channel number if found, otherwise None.
+    """
+    if isinstance(uuid, str):
+        uuid = UUID(uuid)
+    return next(
+        (
+            channel
+            for channel, class_id_list in (
+                await find_rfcomm_channels(connection)
+            ).items()
+            if uuid in class_id_list
+        ),
+        None,
+    )
+
+
 # -----------------------------------------------------------------------------
 def compute_fcs(buffer: bytes) -> int:
     result = 0xFF
@@ -409,7 +474,7 @@ class DLC(EventEmitter):
         # Compute the MTU
         max_overhead = 4 + 1  # header with 2-byte length + fcs
         self.mtu = min(
-            max_frame_size, self.multiplexer.l2cap_channel.mtu - max_overhead
+            max_frame_size, self.multiplexer.l2cap_channel.peer_mtu - max_overhead
         )
 
     def change_state(self, new_state: State) -> None:
@@ -844,8 +909,11 @@ class Client:
     multiplexer: Optional[Multiplexer]
     l2cap_channel: Optional[l2cap.ClassicChannel]
 
-    def __init__(self, connection: Connection) -> None:
+    def __init__(
+        self, connection: Connection, l2cap_mtu: int = RFCOMM_DEFAULT_L2CAP_MTU
+    ) -> None:
         self.connection = connection
+        self.l2cap_mtu = l2cap_mtu
         self.l2cap_channel = None
         self.multiplexer = None
 
@@ -853,7 +921,7 @@ class Client:
         # Create a new L2CAP connection
         try:
             self.l2cap_channel = await self.connection.create_l2cap_channel(
-                spec=l2cap.ClassicChannelSpec(RFCOMM_PSM)
+                spec=l2cap.ClassicChannelSpec(psm=RFCOMM_PSM, mtu=self.l2cap_mtu)
             )
         except ProtocolError as error:
             logger.warning(f'L2CAP connection failed: {error}')
@@ -876,22 +944,33 @@ class Client:
         self.multiplexer = None
 
         # Close the L2CAP channel
-        # TODO
+        if self.l2cap_channel:
+            await self.l2cap_channel.disconnect()
+            self.l2cap_channel = None
+
+    async def __aenter__(self) -> Multiplexer:
+        return await self.start()
+
+    async def __aexit__(self, *args) -> None:
+        await self.shutdown()
 
 
 # -----------------------------------------------------------------------------
 class Server(EventEmitter):
     acceptors: Dict[int, Callable[[DLC], None]]
 
-    def __init__(self, device: Device) -> None:
+    def __init__(
+        self, device: Device, l2cap_mtu: int = RFCOMM_DEFAULT_L2CAP_MTU
+    ) -> None:
         super().__init__()
         self.device = device
         self.multiplexer = None
         self.acceptors = {}
 
         # Register ourselves with the L2CAP channel manager
-        device.create_l2cap_server(
-            spec=l2cap.ClassicChannelSpec(psm=RFCOMM_PSM), handler=self.on_connection
+        self.l2cap_server = device.create_l2cap_server(
+            spec=l2cap.ClassicChannelSpec(psm=RFCOMM_PSM, mtu=l2cap_mtu),
+            handler=self.on_connection,
         )
 
     def listen(self, acceptor: Callable[[DLC], None], channel: int = 0) -> int:
@@ -941,3 +1020,9 @@ class Server(EventEmitter):
         acceptor = self.acceptors.get(dlc.dlci >> 1)
         if acceptor:
             acceptor(dlc)
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.l2cap_server.close()

bumble/sdp.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 import logging
 import struct
 from typing import Dict, List, Type, Optional, Tuple, Union, NewType, TYPE_CHECKING
+from typing_extensions import Self
 
 from . import core, l2cap
 from .colors import color
@@ -920,6 +921,13 @@ class Client:
 
         return ServiceAttribute.list_from_data_elements(attribute_list_sequence.value)
 
+    async def __aenter__(self) -> Self:
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        await self.disconnect()
+
 
 # -----------------------------------------------------------------------------
 class Server:

bumble/utils.py

@@ -226,13 +226,13 @@ class CompositeEventEmitter(AbortableEventEmitter):
         if self._listener:
             # Call the deregistration methods for each base class that has them
             for cls in self._listener.__class__.mro():
-                if hasattr(cls, '_bumble_register_composite'):
-                    cls._bumble_deregister_composite(listener, self)
+                if '_bumble_register_composite' in cls.__dict__:
+                    cls._bumble_deregister_composite(self._listener, self)
         self._listener = listener
         if listener:
             # Call the registration methods for each base class that has them
             for cls in listener.__class__.mro():
-                if hasattr(cls, '_bumble_deregister_composite'):
+                if '_bumble_deregister_composite' in cls.__dict__:
                     cls._bumble_register_composite(listener, self)
 
 

examples/leaudio.json

@@ -2,5 +2,6 @@
     "name": "Bumble-LEA",
     "keystore": "JsonKeyStore",
     "address": "F0:F1:F2:F3:F4:FA",
+    "class_of_device": 2376708,
     "advertising_interval": 100
 }

examples/leaudio_with_classic.json

@@ -0,0 +1,9 @@
+{
+    "name": "Bumble-LEA",
+    "keystore": "JsonKeyStore",
+    "address": "F0:F1:F2:F3:F4:FA",
+    "classic_enabled": true,
+    "cis_enabled": true,
+    "class_of_device": 2376708,
+    "advertising_interval": 100
+}

examples/run_a2dp_source.py

@@ -74,7 +74,7 @@ def codec_capabilities():
 # -----------------------------------------------------------------------------
 def on_avdtp_connection(read_function, protocol):
     packet_source = SbcPacketSource(
-        read_function, protocol.l2cap_channel.mtu, codec_capabilities()
+        read_function, protocol.l2cap_channel.peer_mtu, codec_capabilities()
     )
     packet_pump = MediaPacketPump(packet_source.packets)
     protocol.add_source(packet_source.codec_capabilities, packet_pump)
@@ -98,7 +98,7 @@ async def stream_packets(read_function, protocol):
 
     # Stream the packets
     packet_source = SbcPacketSource(
-        read_function, protocol.l2cap_channel.mtu, codec_capabilities()
+        read_function, protocol.l2cap_channel.peer_mtu, codec_capabilities()
     )
     packet_pump = MediaPacketPump(packet_source.packets)
     source = protocol.add_source(packet_source.codec_capabilities, packet_pump)

examples/run_advertiser.py

@@ -19,9 +19,11 @@ import asyncio
 import logging
 import sys
 import os
+import struct
+
+from bumble.core import AdvertisingData
 from bumble.device import AdvertisingType, Device
 from bumble.hci import Address
-
 from bumble.transport import open_transport_or_link
 
 
@@ -52,6 +54,16 @@ async def main():
         print('<<< connected')
 
         device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
+
+        if advertising_type.is_scannable:
+            device.scan_response_data = bytes(
+                AdvertisingData(
+                    [
+                        (AdvertisingData.APPEARANCE, struct.pack('<H', 0x0340)),
+                    ]
+                )
+            )
+
         await device.power_on()
         await device.start_advertising(advertising_type=advertising_type, target=target)
         await hci_source.wait_for_termination()

examples/run_cig_setup.py

@@ -22,10 +22,11 @@ import os
 from bumble.device import (
     Device,
     Connection,
+    AdvertisingParameters,
+    AdvertisingEventProperties,
 )
 from bumble.hci import (
     OwnAddressType,
-    HCI_LE_Set_Extended_Advertising_Parameters_Command,
 )
 
 from bumble.transport import open_transport_or_link
@@ -61,12 +62,7 @@ async def main() -> None:
     devices[1].cis_enabled = True
 
     await asyncio.gather(*[device.power_on() for device in devices])
-    await devices[0].start_extended_advertising(
-        advertising_properties=(
-            HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties.CONNECTABLE_ADVERTISING
-        ),
-        own_address_type=OwnAddressType.PUBLIC,
-    )
+    advertising_set = await devices[0].create_advertising_set()
 
     connection = await devices[1].connect(
         devices[0].public_address, own_address_type=OwnAddressType.PUBLIC

examples/run_csis_servers.py

@@ -98,13 +98,7 @@ async def main() -> None:
             )
             + csis.get_advertising_data()
         )
-        await device.start_extended_advertising(
-            advertising_properties=(
-                HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties.CONNECTABLE_ADVERTISING
-            ),
-            own_address_type=OwnAddressType.RANDOM,
-            advertising_data=advertising_data,
-        )
+        await device.create_advertising_set(advertising_data=advertising_data)
 
     await asyncio.gather(
         *[hci_transport.source.terminated for hci_transport in hci_transports]

examples/run_extended_advertiser.py

@@ -19,8 +19,13 @@ import asyncio
 import logging
 import sys
 import os
-from bumble.device import AdvertisingType, Device
-from bumble.hci import Address, HCI_LE_Set_Extended_Advertising_Parameters_Command
+from bumble.device import (
+    AdvertisingParameters,
+    AdvertisingEventProperties,
+    AdvertisingType,
+    Device,
+)
+from bumble.hci import Address
 
 from bumble.transport import open_transport_or_link
 
@@ -35,20 +40,16 @@ async def main() -> None:
         return
 
     if len(sys.argv) >= 4:
-        advertising_properties = (
-            HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties(
-                int(sys.argv[3])
-            )
+        advertising_properties = AdvertisingEventProperties.from_advertising_type(
+            AdvertisingType(int(sys.argv[3]))
         )
     else:
-        advertising_properties = (
-            HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties.CONNECTABLE_ADVERTISING
-        )
+        advertising_properties = AdvertisingEventProperties()
 
     if len(sys.argv) >= 5:
-        target = Address(sys.argv[4])
+        peer_address = Address(sys.argv[4])
     else:
-        target = Address.ANY
+        peer_address = Address.ANY
 
     print('<<< connecting to HCI...')
     async with await open_transport_or_link(sys.argv[2]) as hci_transport:
@@ -58,8 +59,11 @@ async def main() -> None:
             sys.argv[1], hci_transport.source, hci_transport.sink
         )
         await device.power_on()
-        await device.start_extended_advertising(
-            advertising_properties=advertising_properties, target=target
+        await device.create_advertising_set(
+            advertising_parameters=AdvertisingParameters(
+                advertising_event_properties=advertising_properties,
+                peer_address=peer_address,
+            )
         )
         await hci_transport.source.terminated
 

examples/run_extended_advertiser_2.py

@@ -0,0 +1,99 @@
+# Copyright 2021-2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import logging
+import sys
+import os
+from bumble.device import AdvertisingParameters, AdvertisingEventProperties, Device
+from bumble.hci import Address
+from bumble.core import AdvertisingData
+from bumble.transport import open_transport_or_link
+
+
+# -----------------------------------------------------------------------------
+async def main() -> None:
+    if len(sys.argv) < 3:
+        print('Usage: run_extended_advertiser_2.py <config-file> <transport-spec>')
+        print('example: run_extended_advertiser_2.py device1.json usb:0')
+        return
+
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+        print('<<< connected')
+
+        device = Device.from_config_file_with_hci(
+            sys.argv[1], hci_transport.source, hci_transport.sink
+        )
+        await device.power_on()
+
+        if not device.supports_le_extended_advertising:
+            print("Device does not support extended advertising")
+            return
+
+        print("Max advertising sets:", device.host.number_of_supported_advertising_sets)
+        print(
+            "Max advertising data length:", device.host.maximum_advertising_data_length
+        )
+
+        if device.host.number_of_supported_advertising_sets >= 1:
+            advertising_data1 = AdvertisingData(
+                [(AdvertisingData.COMPLETE_LOCAL_NAME, "Bumble 1".encode("utf-8"))]
+            )
+
+            set1 = await device.create_advertising_set(
+                advertising_data=bytes(advertising_data1),
+            )
+            print("Selected TX power 1:", set1.selected_tx_power)
+
+            advertising_data2 = AdvertisingData(
+                [(AdvertisingData.COMPLETE_LOCAL_NAME, "Bumble 2".encode("utf-8"))]
+            )
+
+        if device.host.number_of_supported_advertising_sets >= 2:
+            set2 = await device.create_advertising_set(
+                random_address=Address("F0:F0:F0:F0:F0:F1"),
+                advertising_parameters=AdvertisingParameters(),
+                advertising_data=bytes(advertising_data2),
+                auto_start=False,
+                auto_restart=True,
+            )
+            print("Selected TX power 2:", set2.selected_tx_power)
+            await set2.start()
+
+        if device.host.number_of_supported_advertising_sets >= 3:
+            scan_response_data3 = AdvertisingData(
+                [(AdvertisingData.COMPLETE_LOCAL_NAME, "Bumble 3".encode("utf-8"))]
+            )
+
+            set3 = await device.create_advertising_set(
+                random_address=Address("F0:F0:F0:F0:F0:F2"),
+                advertising_parameters=AdvertisingParameters(
+                    advertising_event_properties=AdvertisingEventProperties(
+                        is_connectable=False, is_scannable=True
+                    )
+                ),
+                scan_response_data=bytes(scan_response_data3),
+            )
+            print("Selected TX power 3:", set2.selected_tx_power)
+
+        await hci_transport.source.terminated
+
+
+# -----------------------------------------------------------------------------
+logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'DEBUG').upper())
+asyncio.run(main())

examples/run_hfp_handsfree.py

@@ -21,11 +21,13 @@ import os
 import logging
 import json
 import websockets
+import functools
 from typing import Optional
 
-from bumble.device import Device
+from bumble import rfcomm
+from bumble import hci
+from bumble.device import Device, Connection
 from bumble.transport import open_transport_or_link
-from bumble.rfcomm import Server as RfcommServer
 from bumble import hfp
 from bumble.hfp import HfProtocol
 
@@ -57,12 +59,44 @@ class UiServer:
 
 
 # -----------------------------------------------------------------------------
-def on_dlc(dlc, configuration: hfp.Configuration):
+def on_dlc(dlc: rfcomm.DLC, configuration: hfp.Configuration):
     print('*** DLC connected', dlc)
     protocol = HfProtocol(dlc, configuration)
     UiServer.protocol = protocol
     asyncio.create_task(protocol.run())
 
+    def on_sco_request(connection: Connection, link_type: int, protocol: HfProtocol):
+        if connection == protocol.dlc.multiplexer.l2cap_channel.connection:
+            if link_type == hci.HCI_Connection_Complete_Event.SCO_LINK_TYPE:
+                esco_parameters = hfp.ESCO_PARAMETERS[
+                    hfp.DefaultCodecParameters.SCO_CVSD_D1
+                ]
+            elif protocol.active_codec == hfp.AudioCodec.MSBC:
+                esco_parameters = hfp.ESCO_PARAMETERS[
+                    hfp.DefaultCodecParameters.ESCO_MSBC_T2
+                ]
+            elif protocol.active_codec == hfp.AudioCodec.CVSD:
+                esco_parameters = hfp.ESCO_PARAMETERS[
+                    hfp.DefaultCodecParameters.ESCO_CVSD_S4
+                ]
+            connection.abort_on(
+                'disconnection',
+                connection.device.send_command(
+                    hci.HCI_Enhanced_Accept_Synchronous_Connection_Request_Command(
+                        bd_addr=connection.peer_address, **esco_parameters.asdict()
+                    )
+                ),
+            )
+
+    handler = functools.partial(on_sco_request, protocol=protocol)
+    dlc.multiplexer.l2cap_channel.connection.device.on('sco_request', handler)
+    dlc.multiplexer.l2cap_channel.once(
+        'close',
+        lambda: dlc.multiplexer.l2cap_channel.connection.device.remove_listener(
+            'sco_request', handler
+        ),
+    )
+
 
 # -----------------------------------------------------------------------------
 async def main():
@@ -101,7 +135,7 @@ async def main():
         device.classic_enabled = True
 
         # Create and register a server
-        rfcomm_server = RfcommServer(device)
+        rfcomm_server = rfcomm.Server(device)
 
         # Listen for incoming DLC connections
         channel_number = rfcomm_server.listen(lambda dlc: on_dlc(dlc, configuration))

examples/run_unicast_server.py

@@ -22,13 +22,12 @@ import os
 import struct
 import secrets
 from bumble.core import AdvertisingData
-from bumble.device import Device, CisLink
+from bumble.device import Device, CisLink, AdvertisingParameters
 from bumble.hci import (
     CodecID,
     CodingFormat,
     OwnAddressType,
     HCI_IsoDataPacket,
-    HCI_LE_Set_Extended_Advertising_Parameters_Command,
 )
 from bumble.profiles.bap import (
     CodecSpecificCapabilities,
@@ -99,14 +98,14 @@ async def main() -> None:
                         coding_format=CodingFormat(CodecID.LC3),
                         codec_specific_capabilities=CodecSpecificCapabilities(
                             supported_sampling_frequencies=(
-                                SupportedSamplingFrequency.FREQ_24000
+                                SupportedSamplingFrequency.FREQ_48000
                             ),
                             supported_frame_durations=(
                                 SupportedFrameDuration.DURATION_10000_US_SUPPORTED
                             ),
                             supported_audio_channel_counts=[1],
-                            min_octets_per_codec_frame=60,
-                            max_octets_per_codec_frame=60,
+                            min_octets_per_codec_frame=120,
+                            max_octets_per_codec_frame=120,
                             supported_max_codec_frames_per_sdu=1,
                         ),
                     ),
@@ -159,7 +158,7 @@ async def main() -> None:
             + struct.pack(
                 '<HHHHHHI',
                 18,  # Header length.
-                24000 // 100,  # Sampling Rate(/100Hz).
+                48000 // 100,  # Sampling Rate(/100Hz).
                 0,  # Bitrate(unused).
                 1,  # Channels.
                 10000 // 10,  # Frame duration(/10us).
@@ -179,11 +178,7 @@ async def main() -> None:
 
         device.once('cis_establishment', on_cis)
 
-        await device.start_extended_advertising(
-            advertising_properties=(
-                HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties.CONNECTABLE_ADVERTISING
-            ),
-            own_address_type=OwnAddressType.RANDOM,
+        advertising_set = await device.create_advertising_set(
             advertising_data=advertising_data,
         )
 

examples/run_vcp_renderer.py

@@ -0,0 +1,191 @@
+# Copyright 2021-2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import logging
+import sys
+import os
+import secrets
+import websockets
+import json
+
+from bumble.core import AdvertisingData
+from bumble.device import Device, AdvertisingParameters, AdvertisingEventProperties
+from bumble.hci import (
+    CodecID,
+    CodingFormat,
+    OwnAddressType,
+)
+from bumble.profiles.bap import (
+    CodecSpecificCapabilities,
+    ContextType,
+    AudioLocation,
+    SupportedSamplingFrequency,
+    SupportedFrameDuration,
+    PacRecord,
+    PublishedAudioCapabilitiesService,
+    AudioStreamControlService,
+)
+from bumble.profiles.cap import CommonAudioServiceService
+from bumble.profiles.csip import CoordinatedSetIdentificationService, SirkType
+from bumble.profiles.vcp import VolumeControlService
+
+from bumble.transport import open_transport_or_link
+
+from typing import Optional
+
+
+def dumps_volume_state(volume_setting: int, muted: int, change_counter: int) -> str:
+    return json.dumps(
+        {
+            'volume_setting': volume_setting,
+            'muted': muted,
+            'change_counter': change_counter,
+        }
+    )
+
+
+# -----------------------------------------------------------------------------
+async def main() -> None:
+    if len(sys.argv) < 3:
+        print('Usage: run_vcp_renderer.py <config-file>' '<transport-spec-for-device>')
+        return
+
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+        print('<<< connected')
+
+        device = Device.from_config_file_with_hci(
+            sys.argv[1], hci_transport.source, hci_transport.sink
+        )
+
+        await device.power_on()
+
+        # Add "placeholder" services to enable Android LEA features.
+        csis = CoordinatedSetIdentificationService(
+            set_identity_resolving_key=secrets.token_bytes(16),
+            set_identity_resolving_key_type=SirkType.PLAINTEXT,
+        )
+        device.add_service(CommonAudioServiceService(csis))
+        device.add_service(
+            PublishedAudioCapabilitiesService(
+                supported_source_context=ContextType.PROHIBITED,
+                available_source_context=ContextType.PROHIBITED,
+                supported_sink_context=ContextType.MEDIA,
+                available_sink_context=ContextType.MEDIA,
+                sink_audio_locations=(
+                    AudioLocation.FRONT_LEFT | AudioLocation.FRONT_RIGHT
+                ),
+                sink_pac=[
+                    # Codec Capability Setting 48_4
+                    PacRecord(
+                        coding_format=CodingFormat(CodecID.LC3),
+                        codec_specific_capabilities=CodecSpecificCapabilities(
+                            supported_sampling_frequencies=(
+                                SupportedSamplingFrequency.FREQ_48000
+                            ),
+                            supported_frame_durations=(
+                                SupportedFrameDuration.DURATION_10000_US_SUPPORTED
+                            ),
+                            supported_audio_channel_counts=[1],
+                            min_octets_per_codec_frame=120,
+                            max_octets_per_codec_frame=120,
+                            supported_max_codec_frames_per_sdu=1,
+                        ),
+                    ),
+                ],
+            )
+        )
+        device.add_service(AudioStreamControlService(device, sink_ase_id=[1, 2]))
+
+        vcs = VolumeControlService()
+        device.add_service(vcs)
+
+        ws: Optional[websockets.WebSocketServerProtocol] = None
+
+        def on_volume_state(volume_setting: int, muted: int, change_counter: int):
+            if ws:
+                asyncio.create_task(
+                    ws.send(dumps_volume_state(volume_setting, muted, change_counter))
+                )
+
+        vcs.on('volume_state', on_volume_state)
+
+        advertising_data = (
+            bytes(
+                AdvertisingData(
+                    [
+                        (
+                            AdvertisingData.COMPLETE_LOCAL_NAME,
+                            bytes('Bumble LE Audio', 'utf-8'),
+                        ),
+                        (
+                            AdvertisingData.FLAGS,
+                            bytes(
+                                [
+                                    AdvertisingData.LE_GENERAL_DISCOVERABLE_MODE_FLAG
+                                    | AdvertisingData.BR_EDR_HOST_FLAG
+                                    | AdvertisingData.BR_EDR_CONTROLLER_FLAG
+                                ]
+                            ),
+                        ),
+                        (
+                            AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
+                            bytes(PublishedAudioCapabilitiesService.UUID),
+                        ),
+                    ]
+                )
+            )
+            + csis.get_advertising_data()
+        )
+
+        await device.create_advertising_set(
+            advertising_parameters=AdvertisingParameters(
+                advertising_event_properties=AdvertisingEventProperties(),
+                own_address_type=OwnAddressType.PUBLIC,
+            ),
+            advertising_data=advertising_data,
+        )
+
+        async def serve(websocket: websockets.WebSocketServerProtocol, _path):
+            nonlocal ws
+            await websocket.send(
+                dumps_volume_state(vcs.volume_setting, vcs.muted, vcs.change_counter)
+            )
+            ws = websocket
+            async for message in websocket:
+                volume_state = json.loads(message)
+                vcs.volume_state_bytes = bytes(
+                    [
+                        volume_state['volume_setting'],
+                        volume_state['muted'],
+                        volume_state['change_counter'],
+                    ]
+                )
+                await device.notify_subscribers(
+                    vcs.volume_state, vcs.volume_state_bytes
+                )
+            ws = None
+
+        await websockets.serve(serve, 'localhost', 8989)
+
+        await hci_transport.source.terminated
+
+
+# -----------------------------------------------------------------------------
+logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'DEBUG').upper())
+asyncio.run(main())

examples/vcp_renderer.html

@@ -0,0 +1,103 @@
+<html data-bs-theme="dark">
+
+<head>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
+
+</head>
+
+<body>
+
+    <div class="container">
+
+        <label for="server-port" class="form-label">Server Port</label>
+        <div class="input-group mb-3">
+            <input type="text" class="form-control" aria-label="Port Number" value="8989" id="port">
+            <button class="btn btn-primary" type="button" onclick="connect()">Connect</button>
+        </div>
+
+        <div class="row">
+            <div class="col">
+                <label for="volume_setting" class="form-label">Volume Setting</label>
+                <input type="range" class="form-range" min="0" max="255" id="volume_setting">
+            </div>
+            <div class="col">
+                <label for="change_counter" class="form-label">Change Counter</label>
+                <input type="range" class="form-range" min="0" max="255" id="change_counter">
+            </div>
+            <div class="col">
+                <div class="form-check form-switch">
+                    <input class="form-check-input" type="checkbox" role="switch" id="muted">
+                    <label class="form-check-label" for="muted">Muted</label>
+                </div>
+            </div>
+        </div>
+
+        <button class="btn btn-primary" type="button" onclick="update_state()">Notify New Volume State</button>
+
+
+        <hr>
+        <div id="socketStateContainer" class="bg-body-tertiary p-3 rounded-2">
+            <h3>Log</h3>
+            <code id="socketState">
+            </code>
+        </div>
+    </div>
+
+    <script>
+        let portInput = document.getElementById("port")
+        let volumeSetting = document.getElementById("volume_setting")
+        let muted = document.getElementById("muted")
+        let changeCounter = document.getElementById("change_counter")
+        let socket = null
+
+        function connect() {
+            if (socket != null) {
+                return
+            }
+            socket = new WebSocket(`ws://localhost:${portInput.value}`);
+            socket.onopen = _ => {
+                socketState.innerText += 'OPEN\n'
+            }
+            socket.onclose = _ => {
+                socketState.innerText += 'CLOSED\n'
+                socket = null
+            }
+            socket.onerror = (error) => {
+                socketState.innerText += 'ERROR\n'
+                console.log(`ERROR: ${error}`)
+            }
+            socket.onmessage = (event) => {
+                socketState.innerText += `<- ${event.data}\n`
+                let volume_state = JSON.parse(event.data)
+                volumeSetting.value = volume_state.volume_setting
+                changeCounter.value = volume_state.change_counter
+                muted.checked = volume_state.muted ? true : false
+            }
+        }
+
+        function send(message) {
+            if (socket && socket.readyState == WebSocket.OPEN) {
+                let jsonMessage = JSON.stringify(message)
+                socketState.innerText += `-> ${jsonMessage}\n`
+                socket.send(jsonMessage)
+            } else {
+                socketState.innerText += 'NOT CONNECTED\n'
+            }
+        }
+
+        function update_state() {
+            send({
+                volume_setting: parseInt(volumeSetting.value),
+                change_counter: parseInt(changeCounter.value),
+                muted: muted.checked ? 1 : 0
+            })
+        }
+    </script>
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js"
+        integrity="sha384-C6RzsynM9kWDrMNeT87bh95OGNyZPhcTNXj1NW7RuBCsyN/o0jlpcV8Qyq46cDfL"
+        crossorigin="anonymous"></script>
+
+</body>
+
+</html>

setup.cfg

@@ -52,7 +52,7 @@ install_requires =
     pyserial-asyncio >= 0.5; platform_system!='Emscripten'
     pyserial >= 3.5; platform_system!='Emscripten'
     pyusb >= 1.2; platform_system!='Emscripten'
-    websockets >= 8.1; platform_system!='Emscripten'
+    websockets >= 12.0; platform_system!='Emscripten'
 
 [options.entry_points]
 console_scripts =
@@ -99,7 +99,7 @@ development =
     types-protobuf >= 4.21.0
 avatar =
     pandora-avatar == 0.0.5
-    rootcanal == 1.6.0 ; python_version>='3.10'
+    rootcanal == 1.7.0 ; python_version>='3.10'
 documentation =
     mkdocs >= 1.4.0
     mkdocs-material >= 8.5.6

tests/device_test.py

@@ -28,7 +28,7 @@ from bumble.core import (
     BT_PERIPHERAL_ROLE,
     ConnectionParameters,
 )
-from bumble.device import Connection, Device
+from bumble.device import AdvertisingParameters, Connection, Device
 from bumble.host import AclPacketQueue, Host
 from bumble.hci import (
     HCI_ACCEPT_CONNECTION_REQUEST_COMMAND,
@@ -50,7 +50,8 @@ from bumble.gatt import (
     GATT_APPEARANCE_CHARACTERISTIC,
 )
 
-from .test_utils import TwoDevices
+from .test_utils import TwoDevices, async_barrier
+
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -254,12 +255,12 @@ async def test_legacy_advertising():
     device = Device(host=mock.AsyncMock(Host))
 
     # Start advertising
-    advertiser = await device.start_legacy_advertising()
-    assert device.legacy_advertiser
+    await device.start_advertising()
+    assert device.is_advertising
 
     # Stop advertising
-    await advertiser.stop()
-    assert not device.legacy_advertiser
+    await device.stop_advertising()
+    assert not device.is_advertising
 
 
 # -----------------------------------------------------------------------------
@@ -273,7 +274,7 @@ async def test_legacy_advertising_connection(own_address_type):
     peer_address = Address('F0:F1:F2:F3:F4:F5')
 
     # Start advertising
-    advertiser = await device.start_legacy_advertising()
+    await device.start_advertising()
     device.on_connection(
         0x0001,
         BT_LE_TRANSPORT,
@@ -301,7 +302,7 @@ async def test_legacy_advertising_connection(own_address_type):
 async def test_legacy_advertising_disconnection(auto_restart):
     device = Device(host=mock.AsyncMock(spec=Host))
     peer_address = Address('F0:F1:F2:F3:F4:F5')
-    advertiser = await device.start_legacy_advertising(auto_restart=auto_restart)
+    await device.start_advertising(auto_restart=auto_restart)
     device.on_connection(
         0x0001,
         BT_LE_TRANSPORT,
@@ -310,20 +311,18 @@ async def test_legacy_advertising_disconnection(auto_restart):
         ConnectionParameters(0, 0, 0),
     )
 
-    device.start_legacy_advertising = mock.AsyncMock()
+    device.on_advertising_set_termination(
+        HCI_SUCCESS, device.legacy_advertising_set.advertising_handle, 0x0001, 0
+    )
 
     device.on_disconnection(0x0001, 0)
+    await async_barrier()
+    await async_barrier()
 
     if auto_restart:
-        device.start_legacy_advertising.assert_called_with(
-            advertising_type=advertiser.advertising_type,
-            own_address_type=advertiser.own_address_type,
-            auto_restart=advertiser.auto_restart,
-            advertising_data=advertiser.advertising_data,
-            scan_response_data=advertiser.scan_response_data,
-        )
+        assert device.is_advertising
     else:
-        device.start_legacy_advertising.assert_not_called()
+        assert not device.is_advertising
 
 
 # -----------------------------------------------------------------------------
@@ -332,12 +331,13 @@ async def test_extended_advertising():
     device = Device(host=mock.AsyncMock(Host))
 
     # Start advertising
-    advertiser = await device.start_extended_advertising()
-    assert device.extended_advertisers
+    advertising_set = await device.create_advertising_set()
+    assert device.extended_advertising_sets
+    assert advertising_set.enabled
 
     # Stop advertising
-    await advertiser.stop()
-    assert not device.extended_advertisers
+    await advertising_set.stop()
+    assert not advertising_set.enabled
 
 
 # -----------------------------------------------------------------------------
@@ -349,8 +349,8 @@ async def test_extended_advertising():
 async def test_extended_advertising_connection(own_address_type):
     device = Device(host=mock.AsyncMock(spec=Host))
     peer_address = Address('F0:F1:F2:F3:F4:F5')
-    advertiser = await device.start_extended_advertising(
-        own_address_type=own_address_type
+    advertising_set = await device.create_advertising_set(
+        advertising_parameters=AdvertisingParameters(own_address_type=own_address_type)
     )
     device.on_connection(
         0x0001,
@@ -361,8 +361,9 @@ async def test_extended_advertising_connection(own_address_type):
     )
     device.on_advertising_set_termination(
         HCI_SUCCESS,
-        advertiser.handle,
+        advertising_set.advertising_handle,
         0x0001,
+        0,
     )
 
     if own_address_type == OwnAddressType.PUBLIC:
@@ -375,45 +376,6 @@ async def test_extended_advertising_connection(own_address_type):
     await asyncio.sleep(0.0001)
 
 
-# -----------------------------------------------------------------------------
-@pytest.mark.parametrize(
-    'auto_restart,',
-    (True, False),
-)
-@pytest.mark.asyncio
-async def test_extended_advertising_disconnection(auto_restart):
-    device = Device(host=mock.AsyncMock(spec=Host))
-    peer_address = Address('F0:F1:F2:F3:F4:F5')
-    advertiser = await device.start_extended_advertising(auto_restart=auto_restart)
-    device.on_connection(
-        0x0001,
-        BT_LE_TRANSPORT,
-        peer_address,
-        BT_PERIPHERAL_ROLE,
-        ConnectionParameters(0, 0, 0),
-    )
-    device.on_advertising_set_termination(
-        HCI_SUCCESS,
-        advertiser.handle,
-        0x0001,
-    )
-
-    device.start_extended_advertising = mock.AsyncMock()
-
-    device.on_disconnection(0x0001, 0)
-
-    if auto_restart:
-        device.start_extended_advertising.assert_called_with(
-            advertising_properties=advertiser.advertising_properties,
-            own_address_type=advertiser.own_address_type,
-            auto_restart=advertiser.auto_restart,
-            advertising_data=advertiser.advertising_data,
-            scan_response_data=advertiser.scan_response_data,
-        )
-    else:
-        device.start_extended_advertising.assert_not_called()
-
-
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
 async def test_get_remote_le_features():

tests/gatt_test.py

@@ -50,6 +50,7 @@ from bumble.att import (
     ATT_Error_Response,
     ATT_Read_By_Group_Type_Request,
 )
+from .test_utils import async_barrier
 
 
 # -----------------------------------------------------------------------------
@@ -456,13 +457,6 @@ class LinkedDevices:
         self.paired = [None, None, None]
 
 
-# -----------------------------------------------------------------------------
-async def async_barrier():
-    ready = asyncio.get_running_loop().create_future()
-    asyncio.get_running_loop().call_soon(ready.set_result, None)
-    await ready
-
-
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
 async def test_read_write():

tests/hci_test.py

@@ -23,6 +23,8 @@ from bumble.hci import (
     HCI_LE_READ_BUFFER_SIZE_COMMAND,
     HCI_RESET_COMMAND,
     HCI_SUCCESS,
+    HCI_LE_CONNECTION_COMPLETE_EVENT,
+    HCI_LE_ENHANCED_CONNECTION_COMPLETE_V2_EVENT,
     Address,
     CodingFormat,
     CodecID,
@@ -274,8 +276,14 @@ def test_HCI_Set_Event_Mask_Command():
 # -----------------------------------------------------------------------------
 def test_HCI_LE_Set_Event_Mask_Command():
     command = HCI_LE_Set_Event_Mask_Command(
-        le_event_mask=bytes.fromhex('0011223344556677')
+        le_event_mask=HCI_LE_Set_Event_Mask_Command.mask(
+            [
+                HCI_LE_CONNECTION_COMPLETE_EVENT,
+                HCI_LE_ENHANCED_CONNECTION_COMPLETE_V2_EVENT,
+            ]
+        )
     )
+    assert command.le_event_mask == bytes.fromhex('0100000000010000')
     basic_check(command)
 
 

tests/host_test.py

@@ -0,0 +1,62 @@
+# Copyright 2021-2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+import pytest
+
+from bumble.controller import Controller
+from bumble.host import Host
+from bumble.transport import AsyncPipeSink
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'supported_commands, lmp_features',
+    [
+        (
+            # Default commands
+            '2000800000c000000000e4000000a822000000000000040000f7ffff7f000000'
+            '30f0f9ff01008004000000000000000000000000000000000000000000000000',
+            # Only LE LMP feature
+            '0000000060000000',
+        ),
+        (
+            # All commands
+            'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+            'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+            # 3 pages of LMP features
+            '000102030405060708090A0B0C0D0E0F011112131415161718191A1B1C1D1E1F',
+        ),
+    ],
+)
+async def test_reset(supported_commands: str, lmp_features: str):
+    controller = Controller('C')
+    controller.supported_commands = bytes.fromhex(supported_commands)
+    controller.lmp_features = bytes.fromhex(lmp_features)
+    host = Host(controller, AsyncPipeSink(controller))
+
+    await host.reset()
+
+    assert host.local_lmp_features == int.from_bytes(
+        bytes.fromhex(lmp_features), 'little'
+    )

tests/l2cap_test.py

@@ -227,12 +227,34 @@ async def test_bidirectional_transfer():
     assert server_received_bytes == message_bytes
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_mtu():
+    devices = TwoDevices()
+    await devices.setup_connection()
+
+    def on_channel_open(channel):
+        assert channel.peer_mtu == 456
+
+    def on_channel(channel):
+        channel.on('open', lambda: on_channel_open(channel))
+
+    server = devices.devices[1].create_l2cap_server(
+        spec=ClassicChannelSpec(mtu=345), handler=on_channel
+    )
+    client_channel = await devices.connections[0].create_l2cap_channel(
+        spec=ClassicChannelSpec(server.psm, mtu=456)
+    )
+    assert client_channel.peer_mtu == 345
+
+
 # -----------------------------------------------------------------------------
 async def run():
     test_helpers()
     await test_basic_connection()
     await test_transfer()
     await test_bidirectional_transfer()
+    await test_mtu()
 
 
 # -----------------------------------------------------------------------------

tests/rfcomm_test.py

@@ -17,9 +17,20 @@
 # -----------------------------------------------------------------------------
 import asyncio
 import pytest
+from typing import List
 
 from . import test_utils
-from bumble.rfcomm import RFCOMM_Frame, Server, Client, DLC
+from bumble import core
+from bumble.rfcomm import (
+    RFCOMM_Frame,
+    Server,
+    Client,
+    DLC,
+    make_service_sdp_records,
+    find_rfcomm_channels,
+    find_rfcomm_channel_with_uuid,
+    RFCOMM_PSM,
+)
 
 
 # -----------------------------------------------------------------------------
@@ -49,17 +60,18 @@ def test_frames():
 
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
-async def test_basic_connection():
+async def test_basic_connection() -> None:
     devices = test_utils.TwoDevices()
     await devices.setup_connection()
 
     accept_future: asyncio.Future[DLC] = asyncio.get_running_loop().create_future()
     channel = Server(devices[0]).listen(acceptor=accept_future.set_result)
 
+    assert devices.connections[1]
     multiplexer = await Client(devices.connections[1]).start()
     dlcs = await asyncio.gather(accept_future, multiplexer.open_dlc(channel))
 
-    queues = [asyncio.Queue(), asyncio.Queue()]
+    queues: List[asyncio.Queue] = [asyncio.Queue(), asyncio.Queue()]
     for dlc, queue in zip(dlcs, queues):
         dlc.sink = queue.put_nowait
 
@@ -70,6 +82,45 @@ async def test_basic_connection():
     assert await queues[0].get() == b'Lorem ipsum dolor sit amet'
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_service_record():
+    HANDLE = 2
+    CHANNEL = 1
+    SERVICE_UUID = core.UUID('00000000-0000-0000-0000-000000000001')
+
+    devices = test_utils.TwoDevices()
+    await devices.setup_connection()
+
+    devices[0].sdp_service_records[HANDLE] = make_service_sdp_records(
+        HANDLE, CHANNEL, SERVICE_UUID
+    )
+
+    assert SERVICE_UUID in (await find_rfcomm_channels(devices.connections[1]))[CHANNEL]
+    assert (
+        await find_rfcomm_channel_with_uuid(devices.connections[1], SERVICE_UUID)
+        == CHANNEL
+    )
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_context():
+    devices = test_utils.TwoDevices()
+    await devices.setup_connection()
+
+    server = Server(devices[0])
+    with server:
+        assert server.l2cap_server is not None
+
+        client = Client(devices.connections[1])
+        async with client:
+            assert client.l2cap_channel is not None
+
+        assert client.l2cap_channel is None
+    assert RFCOMM_PSM not in devices[0].l2cap_channel_manager.servers
+
+
 # -----------------------------------------------------------------------------
 if __name__ == '__main__':
     test_frames()

tests/sdp_test.py

@@ -38,6 +38,7 @@ from .test_utils import TwoDevices
 # pylint: disable=invalid-name
 # -----------------------------------------------------------------------------
 
+
 # -----------------------------------------------------------------------------
 def basic_check(x: DataElement) -> None:
     serialized = bytes(x)
@@ -269,6 +270,20 @@ async def test_service_search_attribute():
         assert expect.value == actual.value
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_client_async_context():
+    devices = TwoDevices()
+    await devices.setup_connection()
+
+    client = Client(devices.connections[1])
+
+    async with client:
+        assert client.channel is not None
+
+    assert client.channel is None
+
+
 # -----------------------------------------------------------------------------
 async def run():
     test_data_elements()

tests/test_utils.py

@@ -12,6 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
 from typing import List, Optional
 
 from bumble.controller import Controller
@@ -22,6 +26,7 @@ from bumble.transport import AsyncPipeSink
 from bumble.hci import Address
 
 
+# -----------------------------------------------------------------------------
 class TwoDevices:
     connections: List[Optional[Connection]]
 
@@ -75,3 +80,10 @@ class TwoDevices:
 
     def __getitem__(self, index: int) -> Device:
         return self.devices[index]
+
+
+# -----------------------------------------------------------------------------
+async def async_barrier():
+    ready = asyncio.get_running_loop().create_future()
+    asyncio.get_running_loop().call_soon(ready.set_result, None)
+    await ready

tests/vcp_test.py

@@ -0,0 +1,120 @@
+# Copyright 2021-2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import pytest
+import pytest_asyncio
+import logging
+
+from bumble import device
+from bumble.profiles import vcp
+from .test_utils import TwoDevices
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+@pytest_asyncio.fixture
+async def vcp_client():
+    devices = TwoDevices()
+    devices[0].add_service(
+        vcp.VolumeControlService(volume_setting=32, muted=1, volume_flags=1)
+    )
+
+    await devices.setup_connection()
+
+    # Mock encryption.
+    devices.connections[0].encryption = 1
+    devices.connections[1].encryption = 1
+
+    peer = device.Peer(devices.connections[1])
+    vcp_client = await peer.discover_service_and_create_proxy(
+        vcp.VolumeControlServiceProxy
+    )
+    yield vcp_client
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_init_service(vcp_client: vcp.VolumeControlServiceProxy):
+    assert (await vcp_client.volume_flags.read_value()) == 1
+    assert (await vcp_client.volume_state.read_value()) == (32, 1, 0)
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_relative_volume_down(vcp_client: vcp.VolumeControlServiceProxy):
+    await vcp_client.volume_control_point.write_value(
+        bytes([vcp.VolumeControlPointOpcode.RELATIVE_VOLUME_DOWN, 0])
+    )
+    assert (await vcp_client.volume_state.read_value()) == (16, 1, 1)
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_relative_volume_up(vcp_client: vcp.VolumeControlServiceProxy):
+    await vcp_client.volume_control_point.write_value(
+        bytes([vcp.VolumeControlPointOpcode.RELATIVE_VOLUME_UP, 0])
+    )
+    assert (await vcp_client.volume_state.read_value()) == (48, 1, 1)
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_unmute_relative_volume_down(vcp_client: vcp.VolumeControlServiceProxy):
+    await vcp_client.volume_control_point.write_value(
+        bytes([vcp.VolumeControlPointOpcode.UNMUTE_RELATIVE_VOLUME_DOWN, 0])
+    )
+    assert (await vcp_client.volume_state.read_value()) == (16, 0, 1)
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_unmute_relative_volume_up(vcp_client: vcp.VolumeControlServiceProxy):
+    await vcp_client.volume_control_point.write_value(
+        bytes([vcp.VolumeControlPointOpcode.UNMUTE_RELATIVE_VOLUME_UP, 0])
+    )
+    assert (await vcp_client.volume_state.read_value()) == (48, 0, 1)
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_set_absolute_volume(vcp_client: vcp.VolumeControlServiceProxy):
+    await vcp_client.volume_control_point.write_value(
+        bytes([vcp.VolumeControlPointOpcode.SET_ABSOLUTE_VOLUME, 0, 255])
+    )
+    assert (await vcp_client.volume_state.read_value()) == (255, 1, 1)
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_mute(vcp_client: vcp.VolumeControlServiceProxy):
+    await vcp_client.volume_control_point.write_value(
+        bytes([vcp.VolumeControlPointOpcode.MUTE, 0])
+    )
+    assert (await vcp_client.volume_state.read_value()) == (32, 1, 0)
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_unmute(vcp_client: vcp.VolumeControlServiceProxy):
+    await vcp_client.volume_control_point.write_value(
+        bytes([vcp.VolumeControlPointOpcode.UNMUTE, 0])
+    )
+    assert (await vcp_client.volume_state.read_value()) == (32, 0, 1)