Merge pull request #936 from google/gbg/usb-transport-packet-splitter

usb transport packet splitter

.github/workflows/python-build-test.yml

@@ -69,7 +69,7 @@ jobs:
           components: clippy,rustfmt
           toolchain: ${{ matrix.rust-version }}
       - name: Install Rust dependencies
-        run: cargo install cargo-all-features --version 1.11.0  # allows building/testing combinations of features
+        run: cargo install cargo-all-features --version 1.11.0 --locked  # allows building/testing combinations of features
       - name: Check License Headers
         run: cd rust && cargo run --features dev-tools --bin file-header check-all
       - name: Rust Build

apps/auracast.py

@@ -24,13 +24,18 @@ import dataclasses
 import functools
 import logging
 import secrets
+import sys
 from collections.abc import AsyncGenerator, Awaitable, Callable, Iterable, Sequence
 from typing import (
     Any,
 )
 
 import click
-import tomli
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
 
 try:
     import lc3  # type: ignore  # pylint: disable=E0401
@@ -114,7 +119,7 @@ def parse_broadcast_list(filename: str) -> Sequence[Broadcast]:
     broadcasts: list[Broadcast] = []
 
     with open(filename, "rb") as config_file:
-        config = tomli.load(config_file)
+        config = tomllib.load(config_file)
         for broadcast in config.get("broadcasts", []):
             sources = []
             for source in broadcast.get("sources", []):

apps/bench.py

@@ -489,7 +489,7 @@ class Sender:
                         flags=(
                             Packet.PacketFlags.LAST
                             if tx_i == self.tx_packet_count - 1
-                            else 0
+                            else Packet.PacketFlags(0)
                         ),
                         sequence=tx_i,
                         timestamp=int((time.time() - self.start_time) * 1000000),

apps/controller_info.py

@@ -45,8 +45,10 @@ from bumble.hci import (
     HCI_Read_Local_Supported_Codecs_Command,
     HCI_Read_Local_Supported_Codecs_V2_Command,
     HCI_Read_Local_Version_Information_Command,
+    HCI_Read_Voice_Setting_Command,
     LeFeature,
     SpecificationVersion,
+    VoiceSetting,
     map_null_terminated_utf8_string,
 )
 from bumble.host import Host
@@ -214,6 +216,16 @@ async def get_codecs_info(host: Host) -> None:
         if not response2.vendor_specific_codec_ids:
             print('  No Vendor-specific codecs')
 
+    if host.supports_command(HCI_Read_Voice_Setting_Command.op_code):
+        response3 = await host.send_sync_command(HCI_Read_Voice_Setting_Command())
+        voice_setting = VoiceSetting.from_int(response3.voice_setting)
+        print(color('Voice Setting:', 'yellow'))
+        print(f'  Air Coding Format:       {voice_setting.air_coding_format.name}')
+        print(f'  Linear PCM Bit Position: {voice_setting.linear_pcm_bit_position}')
+        print(f'  Input Sample Size:       {voice_setting.input_sample_size.name}')
+        print(f'  Input Data Format:       {voice_setting.input_data_format.name}')
+        print(f'  Input Coding Format:     {voice_setting.input_coding_format.name}')
+
 
 # -----------------------------------------------------------------------------
 async def async_main(

apps/controller_loopback.py

@@ -16,6 +16,8 @@
 # Imports
 # -----------------------------------------------------------------------------
 import asyncio
+import statistics
+import struct
 import time
 
 import click
@@ -25,7 +27,9 @@ from bumble.colors import color
 from bumble.hci import (
     HCI_READ_LOOPBACK_MODE_COMMAND,
     HCI_WRITE_LOOPBACK_MODE_COMMAND,
+    Address,
     HCI_Read_Loopback_Mode_Command,
+    HCI_SynchronousDataPacket,
     HCI_Write_Loopback_Mode_Command,
     LoopbackMode,
 )
@@ -36,55 +40,121 @@ from bumble.transport import open_transport
 class Loopback:
     """Send and receive ACL data packets in local loopback mode"""
 
-    def __init__(self, packet_size: int, packet_count: int, transport: str):
+    def __init__(
+        self,
+        packet_size: int,
+        packet_count: int,
+        connection_type: str,
+        mode: str,
+        interval: int,
+        transport: str,
+    ):
         self.transport = transport
         self.packet_size = packet_size
         self.packet_count = packet_count
         self.connection_handle: int | None = None
+        self.connection_type = connection_type
         self.connection_event = asyncio.Event()
+        self.mode = mode
+        self.interval = interval
         self.done = asyncio.Event()
-        self.expected_cid = 0
+        self.expected_counter = 0
         self.bytes_received = 0
         self.start_timestamp = 0.0
         self.last_timestamp = 0.0
+        self.send_timestamps: list[float] = []
+        self.rtts: list[float] = []
 
     def on_connection(self, connection_handle: int, *args):
         """Retrieve connection handle from new connection event"""
         if not self.connection_event.is_set():
-            # save first connection handle for ACL
-            # subsequent connections are SCO
+            # The first connection handle is of type ACL,
+            # subsequent connections are of type SCO
+            if self.connection_type == "sco" and self.connection_handle is None:
+                self.connection_handle = connection_handle
+                return
+
             self.connection_handle = connection_handle
             self.connection_event.set()
 
-    def on_l2cap_pdu(self, connection_handle: int, cid: int, pdu: bytes):
+    def on_sco_connection(
+        self,
+        address: Address,
+        connection_handle: int,
+        link_type,
+        rx_packet_length: int,
+        tx_packet_length: int,
+        air_mode: int,
+    ) -> None:
+        self.on_connection(connection_handle)
+
+    def on_packet(self, connection_handle: int, packet: bytes):
         """Calculate packet receive speed"""
         now = time.time()
-        print(f'<<< Received packet {cid}: {len(pdu)} bytes')
+        (counter,) = struct.unpack_from("H", packet, 0)
+        rtt = now - self.send_timestamps[counter]
+        self.rtts.append(rtt)
+        print(f'<<< Received packet {counter}: {len(packet)} bytes, RTT={rtt:.4f}')
         assert connection_handle == self.connection_handle
-        assert cid == self.expected_cid
-        self.expected_cid += 1
-        if cid == 0:
+        assert counter == self.expected_counter
+        self.expected_counter += 1
+        if counter == 0:
             self.start_timestamp = now
         else:
             elapsed_since_start = now - self.start_timestamp
             elapsed_since_last = now - self.last_timestamp
-            self.bytes_received += len(pdu)
-            instant_rx_speed = len(pdu) / elapsed_since_last
+            self.bytes_received += len(packet)
+            instant_rx_speed = len(packet) / elapsed_since_last
             average_rx_speed = self.bytes_received / elapsed_since_start
+            if self.mode == 'throughput':
                 print(
                     color(
                         f'@@@ RX speed: instant={instant_rx_speed:.4f},'
-                    f' average={average_rx_speed:.4f}',
+                        f' average={average_rx_speed:.4f},',
                         'cyan',
                     )
                 )
 
         self.last_timestamp = now
 
-        if self.expected_cid == self.packet_count:
+        if self.expected_counter == self.packet_count:
             print(color('@@@ Received last packet', 'green'))
             self.done.set()
 
+    def on_l2cap_pdu(self, connection_handle: int, cid: int, pdu: bytes):
+        self.on_packet(connection_handle, pdu)
+
+    def on_sco_packet(self, connection_handle: int, packet) -> None:
+        self.on_packet(connection_handle, packet)
+
+    async def send_acl_packet(self, host: Host, packet: bytes) -> None:
+        assert self.connection_handle
+        host.send_l2cap_pdu(self.connection_handle, 0, packet)
+
+    async def send_sco_packet(self, host: Host, packet: bytes) -> None:
+        assert self.connection_handle
+        host.send_hci_packet(
+            HCI_SynchronousDataPacket(
+                connection_handle=self.connection_handle,
+                packet_status=HCI_SynchronousDataPacket.Status.CORRECTLY_RECEIVED_DATA,
+                data_total_length=len(packet),
+                data=packet,
+            )
+        )
+
+    async def send_loop(self, host: Host, sender) -> None:
+        for counter in range(0, self.packet_count):
+            print(
+                color(
+                    f'>>> Sending {self.connection_type.upper()} '
+                    f'packet {counter}: {self.packet_size} bytes',
+                    'yellow',
+                )
+            )
+            self.send_timestamps.append(time.time())
+            await sender(host, struct.pack("H", counter) + bytes(self.packet_size - 2))
+            await asyncio.sleep(self.interval / 1000 if self.mode == "rtt" else 0)
+
     async def run(self) -> None:
         """Run a loopback throughput test"""
         print(color('>>> Connecting to HCI...', 'green'))
@@ -126,8 +196,11 @@ class Loopback:
                 return
 
             # set event callbacks
-            host.on('connection', self.on_connection)
+            host.on('classic_connection', self.on_connection)
+            host.on('le_connection', self.on_connection)
+            host.on('sco_connection', self.on_sco_connection)
             host.on('l2cap_pdu', self.on_l2cap_pdu)
+            host.on('sco_packet', self.on_sco_packet)
 
             loopback_mode = LoopbackMode.LOCAL
 
@@ -148,32 +221,37 @@ class Loopback:
 
             print(color('=== Start sending', 'magenta'))
             start_time = time.time()
-            bytes_sent = 0
-            for cid in range(0, self.packet_count):
-                # using the cid as an incremental index
-                host.send_l2cap_pdu(
-                    self.connection_handle, cid, bytes(self.packet_size)
-                )
-                print(
-                    color(
-                        f'>>> Sending packet {cid}: {self.packet_size} bytes', 'yellow'
-                    )
-                )
-                bytes_sent += self.packet_size  # don't count L2CAP or HCI header sizes
-                await asyncio.sleep(0)  # yield to allow packet receive
+            if self.connection_type == "acl":
+                sender = self.send_acl_packet
+            elif self.connection_type == "sco":
+                sender = self.send_sco_packet
+            else:
+                raise ValueError(f'Unknown connection type: {self.connection_type}')
+            await self.send_loop(host, sender)
 
             await self.done.wait()
             print(color('=== Done!', 'magenta'))
 
+            bytes_sent = self.packet_size * self.packet_count
             elapsed = time.time() - start_time
             average_tx_speed = bytes_sent / elapsed
+            if self.mode == 'throughput':
                 print(
                     color(
-                    f'@@@ TX speed: average={average_tx_speed:.4f} ({bytes_sent} bytes'
-                    f' in {elapsed:.2f} seconds)',
+                        f'@@@ TX speed: average={average_tx_speed:.4f} '
+                        f'({bytes_sent} bytes in {elapsed:.2f} seconds)',
                         'green',
                     )
                 )
+            if self.mode == 'rtt':
+                print(
+                    color(
+                        f'RTTs: min={min(self.rtts):.4f}, '
+                        f'max={max(self.rtts):.4f}, '
+                        f'avg={statistics.mean(self.rtts):.4f}',
+                        'blue',
+                    )
+                )
 
 
 # -----------------------------------------------------------------------------
@@ -194,11 +272,43 @@ class Loopback:
     default=10,
     help='Packet count',
 )
+@click.option(
+    '--connection-type',
+    '-t',
+    metavar='TYPE',
+    type=click.Choice(['acl', 'sco']),
+    default='acl',
+    help='Connection type',
+)
+@click.option(
+    '--mode',
+    '-m',
+    metavar='MODE',
+    type=click.Choice(['throughput', 'rtt']),
+    default='throughput',
+    help='Test mode',
+)
+@click.option(
+    '--interval',
+    type=int,
+    default=100,
+    help='Inter-packet interval (ms) [RTT mode only]',
+)
 @click.argument('transport')
-def main(packet_size, packet_count, transport):
+def main(packet_size, packet_count, connection_type, mode, interval, transport):
     bumble.logging.setup_basic_logging()
-    loopback = Loopback(packet_size, packet_count, transport)
-    asyncio.run(loopback.run())
+
+    if connection_type == "sco" and packet_size > 255:
+        print("ERROR: the maximum packet size for SCO is 255")
+        return
+
+    async def run():
+        loopback = Loopback(
+            packet_size, packet_count, connection_type, mode, interval, transport
+        )
+        await loopback.run()
+
+    asyncio.run(run())
 
 
 # -----------------------------------------------------------------------------

apps/pair.py

@@ -20,11 +20,12 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
+from typing import ClassVar
 
 import click
 from prompt_toolkit.shortcuts import PromptSession
 
-from bumble import data_types
+from bumble import data_types, smp
 from bumble.a2dp import make_audio_sink_service_sdp_records
 from bumble.att import (
     ATT_INSUFFICIENT_AUTHENTICATION_ERROR,
@@ -40,7 +41,7 @@ from bumble.core import (
     PhysicalTransport,
     ProtocolError,
 )
-from bumble.device import Device, Peer
+from bumble.device import Connection, Device, Peer
 from bumble.gatt import (
     GATT_DEVICE_NAME_CHARACTERISTIC,
     GATT_GENERIC_ACCESS_SERVICE,
@@ -53,7 +54,6 @@ from bumble.hci import OwnAddressType
 from bumble.keys import JsonKeyStore
 from bumble.pairing import OobData, PairingConfig, PairingDelegate
 from bumble.smp import OobContext, OobLegacyContext
-from bumble.smp import error_name as smp_error_name
 from bumble.transport import open_transport
 from bumble.utils import AsyncRunner
 
@@ -65,7 +65,7 @@ POST_PAIRING_DELAY = 1
 
 # -----------------------------------------------------------------------------
 class Waiter:
-    instance: Waiter | None = None
+    instance: ClassVar[Waiter | None] = None
 
     def __init__(self, linger=False):
         self.done = asyncio.get_running_loop().create_future()
@@ -319,11 +319,12 @@ async def on_classic_pairing(connection):
 
 # -----------------------------------------------------------------------------
 @AsyncRunner.run_in_task()
-async def on_pairing_failure(connection, reason):
+async def on_pairing_failure(connection: Connection, reason: smp.ErrorCode):
     print(color('***-----------------------------------', 'red'))
-    print(color(f'*** Pairing failed: {smp_error_name(reason)}', 'red'))
+    print(color(f'*** Pairing failed: {reason.name}', 'red'))
     print(color('***-----------------------------------', 'red'))
     await connection.disconnect()
+    if Waiter.instance:
         Waiter.instance.terminate()
 
 

apps/usb_probe.py

@@ -111,9 +111,14 @@ def show_device_details(device):
                         if (endpoint.getAddress() & USB_ENDPOINT_IN == 0)
                         else 'IN'
                     )
+                    endpoint_details = (
+                        f', Max Packet Size = {endpoint.getMaxPacketSize()}'
+                        if endpoint_type == 'ISOCHRONOUS'
+                        else ''
+                    )
                     print(
                         f'        Endpoint 0x{endpoint.getAddress():02X}: '
-                        f'{endpoint_type} {endpoint_direction}'
+                        f'{endpoint_type} {endpoint_direction}{endpoint_details}'
                     )
 
 

bumble/a2dp.py

@@ -88,13 +88,6 @@ SBC_DUAL_CHANNEL_MODE         = 0x01
 SBC_STEREO_CHANNEL_MODE       = 0x02
 SBC_JOINT_STEREO_CHANNEL_MODE = 0x03
 
-SBC_CHANNEL_MODE_NAMES = {
-    SBC_MONO_CHANNEL_MODE:         'SBC_MONO_CHANNEL_MODE',
-    SBC_DUAL_CHANNEL_MODE:         'SBC_DUAL_CHANNEL_MODE',
-    SBC_STEREO_CHANNEL_MODE:       'SBC_STEREO_CHANNEL_MODE',
-    SBC_JOINT_STEREO_CHANNEL_MODE: 'SBC_JOINT_STEREO_CHANNEL_MODE'
-}
-
 SBC_BLOCK_LENGTHS = [4, 8, 12, 16]
 
 SBC_SUBBANDS = [4, 8]
@@ -102,11 +95,6 @@ SBC_SUBBANDS = [4, 8]
 SBC_SNR_ALLOCATION_METHOD      = 0x00
 SBC_LOUDNESS_ALLOCATION_METHOD = 0x01
 
-SBC_ALLOCATION_METHOD_NAMES = {
-    SBC_SNR_ALLOCATION_METHOD:      'SBC_SNR_ALLOCATION_METHOD',
-    SBC_LOUDNESS_ALLOCATION_METHOD: 'SBC_LOUDNESS_ALLOCATION_METHOD'
-}
-
 SBC_MAX_FRAMES_IN_RTP_PAYLOAD = 15
 
 MPEG_2_4_AAC_SAMPLING_FREQUENCIES = [
@@ -129,13 +117,6 @@ MPEG_4_AAC_LC_OBJECT_TYPE       = 0x01
 MPEG_4_AAC_LTP_OBJECT_TYPE      = 0x02
 MPEG_4_AAC_SCALABLE_OBJECT_TYPE = 0x03
 
-MPEG_2_4_OBJECT_TYPE_NAMES = {
-    MPEG_2_AAC_LC_OBJECT_TYPE:       'MPEG_2_AAC_LC_OBJECT_TYPE',
-    MPEG_4_AAC_LC_OBJECT_TYPE:       'MPEG_4_AAC_LC_OBJECT_TYPE',
-    MPEG_4_AAC_LTP_OBJECT_TYPE:      'MPEG_4_AAC_LTP_OBJECT_TYPE',
-    MPEG_4_AAC_SCALABLE_OBJECT_TYPE: 'MPEG_4_AAC_SCALABLE_OBJECT_TYPE'
-}
-
 
 OPUS_MAX_FRAMES_IN_RTP_PAYLOAD = 15
 
@@ -267,11 +248,12 @@ class MediaCodecInformation:
     def create(
         cls, media_codec_type: int, data: bytes
     ) -> MediaCodecInformation | bytes:
-        if media_codec_type == CodecType.SBC:
+        match media_codec_type:
+            case CodecType.SBC:
                 return SbcMediaCodecInformation.from_bytes(data)
-        elif media_codec_type == CodecType.MPEG_2_4_AAC:
+            case CodecType.MPEG_2_4_AAC:
                 return AacMediaCodecInformation.from_bytes(data)
-        elif media_codec_type == CodecType.NON_A2DP:
+            case CodecType.NON_A2DP:
                 vendor_media_codec_information = (
                     VendorSpecificMediaCodecInformation.from_bytes(data)
                 )

bumble/at.py

@@ -27,7 +27,7 @@ def tokenize_parameters(buffer: bytes) -> list[bytes]:
     are ignored [..], unless they are embedded in numeric or string constants"
     Raises AtParsingError in case of invalid input string."""
 
-    tokens = []
+    tokens: list[bytearray] = []
     in_quotes = False
     token = bytearray()
     for b in buffer:
@@ -40,22 +40,23 @@ def tokenize_parameters(buffer: bytes) -> list[bytes]:
                 tokens.append(token[1:-1])
                 token = bytearray()
         else:
-            if char == b' ':
+            match char:
+                case b' ':
                     pass
-            elif char == b',' or char == b')':
+                case b',' | b')':
                     tokens.append(token)
                     tokens.append(char)
                     token = bytearray()
-            elif char == b'(':
+                case b'(':
                     if len(token) > 0:
                         raise AtParsingError("open_paren following regular character")
                     tokens.append(char)
-            elif char == b'"':
+                case b'"':
                     if len(token) > 0:
                         raise AtParsingError("quote following regular character")
                     in_quotes = True
                     token.extend(char)
-            else:
+                case _:
                     token.extend(char)
 
     tokens.append(token)
@@ -71,17 +72,18 @@ def parse_parameters(buffer: bytes) -> list[bytes | list]:
     current: bytes | list = b''
 
     for token in tokens:
-        if token == b',':
+        match token:
+            case b',':
                 accumulator[-1].append(current)
                 current = b''
-        elif token == b'(':
+            case b'(':
                 accumulator.append([])
-        elif token == b')':
+            case b')':
                 if len(accumulator) < 2:
                     raise AtParsingError("close_paren without matching open_paren")
                 accumulator[-1].append(current)
                 current = accumulator.pop()
-        else:
+            case _:
                 current = token
 
     accumulator[-1].append(current)

bumble/att.py

@@ -42,7 +42,7 @@ from typing_extensions import TypeIs
 
 from bumble import hci, l2cap, utils
 from bumble.colors import color
-from bumble.core import UUID, InvalidOperationError, ProtocolError
+from bumble.core import UUID, InvalidOperationError, InvalidPacketError, ProtocolError
 from bumble.hci import HCI_Object
 
 # -----------------------------------------------------------------------------
@@ -249,6 +249,8 @@ class ATT_PDU:
 
     @classmethod
     def from_bytes(cls, pdu: bytes) -> ATT_PDU:
+        if not pdu:
+            raise InvalidPacketError("Empty ATT PDU")
         op_code = pdu[0]
 
         subclass = ATT_PDU.pdu_classes.get(op_code)
@@ -954,11 +956,12 @@ class Attribute(utils.EventEmitter, Generic[_T]):
             self.permissions = permissions
 
         # Convert the type to a UUID object if it isn't already
-        if isinstance(attribute_type, str):
+        match attribute_type:
+            case str():
                 self.type = UUID(attribute_type)
-        elif isinstance(attribute_type, bytes):
+            case bytes():
                 self.type = UUID.from_bytes(attribute_type)
-        else:
+            case _:
                 self.type = attribute_type
 
         self.value = value
@@ -994,7 +997,8 @@ class Attribute(utils.EventEmitter, Generic[_T]):
             )
 
         value: _T | None
-        if isinstance(self.value, AttributeValue):
+        match self.value:
+            case AttributeValue():
                 try:
                     read_value = self.value.read(connection)
                     if inspect.isawaitable(read_value):
@@ -1005,7 +1009,7 @@ class Attribute(utils.EventEmitter, Generic[_T]):
                     raise ATT_Error(
                         error_code=error.error_code, att_handle=self.handle
                     ) from error
-        elif isinstance(self.value, AttributeValueV2):
+            case AttributeValueV2():
                 try:
                     read_value = self.value.read(bearer)
                     if inspect.isawaitable(read_value):
@@ -1016,7 +1020,7 @@ class Attribute(utils.EventEmitter, Generic[_T]):
                     raise ATT_Error(
                         error_code=error.error_code, att_handle=self.handle
                     ) from error
-        else:
+            case _:
                 value = self.value
 
         self.emit(self.EVENT_READ, connection, b'' if value is None else value)
@@ -1049,7 +1053,8 @@ class Attribute(utils.EventEmitter, Generic[_T]):
 
         decoded_value = self.decode_value(value)
 
-        if isinstance(self.value, AttributeValue):
+        match self.value:
+            case AttributeValue():
                 try:
                     result = self.value.write(connection, decoded_value)
                     if inspect.isawaitable(result):
@@ -1058,7 +1063,7 @@ class Attribute(utils.EventEmitter, Generic[_T]):
                     raise ATT_Error(
                         error_code=error.error_code, att_handle=self.handle
                     ) from error
-        elif isinstance(self.value, AttributeValueV2):
+            case AttributeValueV2():
                 try:
                     result = self.value.write(bearer, decoded_value)
                     if inspect.isawaitable(result):
@@ -1067,7 +1072,7 @@ class Attribute(utils.EventEmitter, Generic[_T]):
                     raise ATT_Error(
                         error_code=error.error_code, att_handle=self.handle
                     ) from error
-        else:
+            case _:
                 self.value = decoded_value
 
         self.emit(self.EVENT_WRITE, connection, decoded_value)
@@ -1078,7 +1083,7 @@ class Attribute(utils.EventEmitter, Generic[_T]):
         else:
             value_str = str(self.value)
         if value_str:
-            value_string = f', value={self.value.hex()}'
+            value_string = f', value={value_str}'
         else:
             value_string = ''
         return (

bumble/avdtp.py

@@ -17,6 +17,7 @@
 # -----------------------------------------------------------------------------
 from __future__ import annotations
 
+import abc
 import asyncio
 import enum
 import logging
@@ -311,6 +312,13 @@ class MessageAssembler:
     def on_pdu(self, pdu: bytes) -> None:
         self.packet_count += 1
 
+        # Drop empty PDUs sent by remote — accessing pdu[0] below would
+        # raise IndexError, propagating up to the L2CAP read loop and
+        # tearing down the channel. Same class as #912 (ATT empty PDU).
+        if not pdu:
+            logger.warning('AVDTP message assembler: empty PDU dropped')
+            return
+
         transaction_label = pdu[0] >> 4
         packet_type = Protocol.PacketType((pdu[0] >> 2) & 3)
         message_type = Message.MessageType(pdu[0] & 3)
@@ -324,6 +332,23 @@ class MessageAssembler:
             Protocol.PacketType.SINGLE_PACKET,
             Protocol.PacketType.START_PACKET,
         ):
+            # Both single and start packets carry the signal identifier in
+            # pdu[1]; start packets additionally carry the packet count in
+            # pdu[2]. Guard each access so a malformed remote frame can't
+            # crash the message assembler.
+            if len(pdu) < 2:
+                logger.warning(
+                    'AVDTP %s packet too short (%d bytes); dropped',
+                    packet_type.name,
+                    len(pdu),
+                )
+                return
+            if packet_type == Protocol.PacketType.START_PACKET and len(pdu) < 3:
+                logger.warning(
+                    'AVDTP START packet missing signal-packet count; dropped'
+                )
+                return
+
             if self.message is not None:
                 # The previous message has not been terminated
                 logger.warning(
@@ -1453,8 +1478,23 @@ class Protocol(utils.EventEmitter):
             handler = getattr(self, handler_name, None)
             if handler:
                 try:
-                    response = handler(message)
+                    result = handler(message)
+                    if asyncio.iscoroutine(result):
+
+                        async def wait_and_send() -> None:
+                            try:
+                                response = await result
+                                if response:
                                     self.send_message(transaction_label, response)
+                            except Exception:
+                                logger.exception(
+                                    color("!!! Exception in handler:", "red")
+                                )
+
+                        utils.cancel_on_event(self, self.EVENT_CLOSE, wait_and_send())
+                    else:
+                        if result:
+                            self.send_message(transaction_label, result)
                 except Exception:
                     logger.exception(color("!!! Exception in handler:", "red"))
             else:
@@ -1535,7 +1575,7 @@ class Protocol(utils.EventEmitter):
     async def send_command(self, command: Message):
         # TODO: support timeouts
         # Send the command
-        (transaction_label, transaction_result) = await self.start_transaction()
+        transaction_label, transaction_result = await self.start_transaction()
         self.send_message(transaction_label, command)
 
         # Wait for the response
@@ -1600,14 +1640,14 @@ class Protocol(utils.EventEmitter):
     async def abort(self, seid: int) -> Abort_Response:
         return await self.send_command(Abort_Command(seid))
 
-    def on_discover_command(self, command: Discover_Command) -> Message | None:
+    async def on_discover_command(self, command: Discover_Command) -> Message | None:
         endpoint_infos = [
             EndPointInfo(endpoint.seid, 0, endpoint.media_type, endpoint.tsep)
             for endpoint in self.local_endpoints
         ]
         return Discover_Response(endpoint_infos)
 
-    def on_get_capabilities_command(
+    async def on_get_capabilities_command(
         self, command: Get_Capabilities_Command
     ) -> Message | None:
         endpoint = self.get_local_endpoint_by_seid(command.acp_seid)
@@ -1616,7 +1656,7 @@ class Protocol(utils.EventEmitter):
 
         return Get_Capabilities_Response(endpoint.capabilities)
 
-    def on_get_all_capabilities_command(
+    async def on_get_all_capabilities_command(
         self, command: Get_All_Capabilities_Command
     ) -> Message | None:
         endpoint = self.get_local_endpoint_by_seid(command.acp_seid)
@@ -1625,7 +1665,7 @@ class Protocol(utils.EventEmitter):
 
         return Get_All_Capabilities_Response(endpoint.capabilities)
 
-    def on_set_configuration_command(
+    async def on_set_configuration_command(
         self, command: Set_Configuration_Command
     ) -> Message | None:
         endpoint = self.get_local_endpoint_by_seid(command.acp_seid)
@@ -1640,10 +1680,10 @@ class Protocol(utils.EventEmitter):
         stream = Stream(self, endpoint, StreamEndPointProxy(self, command.int_seid))
         self.streams[command.acp_seid] = stream
 
-        result = stream.on_set_configuration_command(command.capabilities)
+        result = await stream.on_set_configuration_command(command.capabilities)
         return result or Set_Configuration_Response()
 
-    def on_get_configuration_command(
+    async def on_get_configuration_command(
         self, command: Get_Configuration_Command
     ) -> Message | None:
         endpoint = self.get_local_endpoint_by_seid(command.acp_seid)
@@ -1652,29 +1692,31 @@ class Protocol(utils.EventEmitter):
         if endpoint.stream is None:
             return Get_Configuration_Reject(AVDTP_BAD_STATE_ERROR)
 
-        return endpoint.stream.on_get_configuration_command()
+        return await endpoint.stream.on_get_configuration_command()
 
-    def on_reconfigure_command(self, command: Reconfigure_Command) -> Message | None:
+    async def on_reconfigure_command(
+        self, command: Reconfigure_Command
+    ) -> Message | None:
         endpoint = self.get_local_endpoint_by_seid(command.acp_seid)
         if endpoint is None:
             return Reconfigure_Reject(error_code=AVDTP_BAD_ACP_SEID_ERROR)
         if endpoint.stream is None:
             return Reconfigure_Reject(error_code=AVDTP_BAD_STATE_ERROR)
 
-        result = endpoint.stream.on_reconfigure_command(command.capabilities)
+        result = await endpoint.stream.on_reconfigure_command(command.capabilities)
         return result or Reconfigure_Response()
 
-    def on_open_command(self, command: Open_Command) -> Message | None:
+    async def on_open_command(self, command: Open_Command) -> Message | None:
         endpoint = self.get_local_endpoint_by_seid(command.acp_seid)
         if endpoint is None:
             return Open_Reject(AVDTP_BAD_ACP_SEID_ERROR)
         if endpoint.stream is None:
             return Open_Reject(AVDTP_BAD_STATE_ERROR)
 
-        result = endpoint.stream.on_open_command()
+        result = await endpoint.stream.on_open_command()
         return result or Open_Response()
 
-    def on_start_command(self, command: Start_Command) -> Message | None:
+    async def on_start_command(self, command: Start_Command) -> Message | None:
         for seid in command.acp_seids:
             endpoint = self.get_local_endpoint_by_seid(seid)
             if endpoint is None:
@@ -1688,12 +1730,12 @@ class Protocol(utils.EventEmitter):
             endpoint = self.get_local_endpoint_by_seid(seid)
             if not endpoint or not endpoint.stream:
                 raise InvalidStateError("Should already be checked!")
-            if (result := endpoint.stream.on_start_command()) is not None:
+            if (result := await endpoint.stream.on_start_command()) is not None:
                 return result
 
         return Start_Response()
 
-    def on_suspend_command(self, command: Suspend_Command) -> Message | None:
+    async def on_suspend_command(self, command: Suspend_Command) -> Message | None:
         for seid in command.acp_seids:
             endpoint = self.get_local_endpoint_by_seid(seid)
             if endpoint is None:
@@ -1707,45 +1749,47 @@ class Protocol(utils.EventEmitter):
             endpoint = self.get_local_endpoint_by_seid(seid)
             if not endpoint or not endpoint.stream:
                 raise InvalidStateError("Should already be checked!")
-            if (result := endpoint.stream.on_suspend_command()) is not None:
+            if (result := await endpoint.stream.on_suspend_command()) is not None:
                 return result
 
         return Suspend_Response()
 
-    def on_close_command(self, command: Close_Command) -> Message | None:
+    async def on_close_command(self, command: Close_Command) -> Message | None:
         endpoint = self.get_local_endpoint_by_seid(command.acp_seid)
         if endpoint is None:
             return Close_Reject(AVDTP_BAD_ACP_SEID_ERROR)
         if endpoint.stream is None:
             return Close_Reject(AVDTP_BAD_STATE_ERROR)
 
-        result = endpoint.stream.on_close_command()
+        result = await endpoint.stream.on_close_command()
         return result or Close_Response()
 
-    def on_abort_command(self, command: Abort_Command) -> Message | None:
+    async def on_abort_command(self, command: Abort_Command) -> Message | None:
         endpoint = self.get_local_endpoint_by_seid(command.acp_seid)
         if endpoint is None or endpoint.stream is None:
             return Abort_Response()
 
-        endpoint.stream.on_abort_command()
+        await endpoint.stream.on_abort_command()
         return Abort_Response()
 
-    def on_security_control_command(
+    async def on_security_control_command(
         self, command: Security_Control_Command
     ) -> Message | None:
         endpoint = self.get_local_endpoint_by_seid(command.acp_seid)
         if endpoint is None:
             return Security_Control_Reject(AVDTP_BAD_ACP_SEID_ERROR)
 
-        result = endpoint.on_security_control_command(command.data)
+        result = await endpoint.on_security_control_command(command.data)
         return result or Security_Control_Response()
 
-    def on_delayreport_command(self, command: DelayReport_Command) -> Message | None:
+    async def on_delayreport_command(
+        self, command: DelayReport_Command
+    ) -> Message | None:
         endpoint = self.get_local_endpoint_by_seid(command.acp_seid)
         if endpoint is None:
             return DelayReport_Reject(AVDTP_BAD_ACP_SEID_ERROR)
 
-        result = endpoint.on_delayreport_command(command.delay)
+        result = await endpoint.on_delayreport_command(command.delay)
         return result or DelayReport_Response()
 
 
@@ -1903,25 +1947,22 @@ class Stream:
             await self.rtp_channel.disconnect()
             self.rtp_channel = None
 
-        # Release the endpoint
-        self.local_endpoint.in_use = 0
-
         self.change_state(State.IDLE)
 
-    def on_set_configuration_command(
+    async def on_set_configuration_command(
         self, configuration: Iterable[ServiceCapabilities]
     ) -> Message | None:
         if self.state != State.IDLE:
             return Set_Configuration_Reject(error_code=AVDTP_BAD_STATE_ERROR)
 
-        result = self.local_endpoint.on_set_configuration_command(configuration)
+        result = await self.local_endpoint.on_set_configuration_command(configuration)
         if result is not None:
             return result
 
         self.change_state(State.CONFIGURED)
         return None
 
-    def on_get_configuration_command(self) -> Message | None:
+    async def on_get_configuration_command(self) -> Message | None:
         if self.state not in (
             State.CONFIGURED,
             State.OPEN,
@@ -1929,25 +1970,25 @@ class Stream:
         ):
             return Get_Configuration_Reject(error_code=AVDTP_BAD_STATE_ERROR)
 
-        return self.local_endpoint.on_get_configuration_command()
+        return await self.local_endpoint.on_get_configuration_command()
 
-    def on_reconfigure_command(
+    async def on_reconfigure_command(
         self, configuration: Iterable[ServiceCapabilities]
     ) -> Message | None:
         if self.state != State.OPEN:
             return Reconfigure_Reject(error_code=AVDTP_BAD_STATE_ERROR)
 
-        result = self.local_endpoint.on_reconfigure_command(configuration)
+        result = await self.local_endpoint.on_reconfigure_command(configuration)
         if result is not None:
             return result
 
         return None
 
-    def on_open_command(self) -> Message | None:
+    async def on_open_command(self) -> Message | None:
         if self.state != State.CONFIGURED:
             return Open_Reject(AVDTP_BAD_STATE_ERROR)
 
-        result = self.local_endpoint.on_open_command()
+        result = await self.local_endpoint.on_open_command()
         if result is not None:
             return result
 
@@ -1957,7 +1998,7 @@ class Stream:
         self.change_state(State.OPEN)
         return None
 
-    def on_start_command(self) -> Message | None:
+    async def on_start_command(self) -> Message | None:
         if self.state != State.OPEN:
             return Open_Reject(AVDTP_BAD_STATE_ERROR)
 
@@ -1966,29 +2007,29 @@ class Stream:
             logger.warning('received start command before RTP channel establishment')
             return Open_Reject(AVDTP_BAD_STATE_ERROR)
 
-        result = self.local_endpoint.on_start_command()
+        result = await self.local_endpoint.on_start_command()
         if result is not None:
             return result
 
         self.change_state(State.STREAMING)
         return None
 
-    def on_suspend_command(self) -> Message | None:
+    async def on_suspend_command(self) -> Message | None:
         if self.state != State.STREAMING:
             return Open_Reject(AVDTP_BAD_STATE_ERROR)
 
-        result = self.local_endpoint.on_suspend_command()
+        result = await self.local_endpoint.on_suspend_command()
         if result is not None:
             return result
 
         self.change_state(State.OPEN)
         return None
 
-    def on_close_command(self) -> Message | None:
+    async def on_close_command(self) -> Message | None:
         if self.state not in (State.OPEN, State.STREAMING):
             return Open_Reject(AVDTP_BAD_STATE_ERROR)
 
-        result = self.local_endpoint.on_close_command()
+        result = await self.local_endpoint.on_close_command()
         if result is not None:
             return result
 
@@ -2003,7 +2044,8 @@ class Stream:
 
         return None
 
-    def on_abort_command(self) -> Message | None:
+    async def on_abort_command(self) -> Message | None:
+        await self.local_endpoint.on_abort_command()
         if self.rtp_channel is None:
             # No need to wait
             self.change_state(State.IDLE)
@@ -2028,7 +2070,6 @@ class Stream:
     def on_l2cap_channel_close(self) -> None:
         logger.debug(color('<<< stream channel closed', 'magenta'))
         self.local_endpoint.on_rtp_channel_close()
-        self.local_endpoint.in_use = 0
         self.rtp_channel = None
 
         if self.state in (State.CLOSING, State.ABORTING):
@@ -2053,7 +2094,6 @@ class Stream:
         self.state = State.IDLE
 
         local_endpoint.stream = self
-        local_endpoint.in_use = 1
 
     def __str__(self) -> str:
         return (
@@ -2063,14 +2103,16 @@ class Stream:
 
 
 # -----------------------------------------------------------------------------
-@dataclass
-class StreamEndPoint:
+class StreamEndPoint(abc.ABC):
     seid: int
     media_type: MediaType
     tsep: StreamEndPointType
-    in_use: int
     capabilities: Iterable[ServiceCapabilities]
 
+    @property
+    def in_use(self) -> int:
+        raise NotImplementedError()
+
 
 # -----------------------------------------------------------------------------
 class StreamEndPointProxy:
@@ -2110,14 +2152,30 @@ class DiscoveredStreamEndPoint(StreamEndPoint, StreamEndPointProxy):
         in_use: int,
         capabilities: Iterable[ServiceCapabilities],
     ) -> None:
-        StreamEndPoint.__init__(self, seid, media_type, tsep, in_use, capabilities)
-        StreamEndPointProxy.__init__(self, protocol, seid)
+        # StreamEndPoint attributes
+        self.seid = seid
+        self.media_type = media_type
+        self.tsep = tsep
+        self._in_use = in_use
+        self.capabilities = capabilities
+
+        StreamEndPointProxy.__init__(self, protocol=protocol, seid=seid)
+
+    @property
+    def in_use(self) -> int:
+        return self._in_use
 
 
 # -----------------------------------------------------------------------------
 class LocalStreamEndPoint(StreamEndPoint, utils.EventEmitter):
     stream: Stream | None
 
+    @property
+    def in_use(self) -> int:
+        if self.stream and self.stream.state != State.IDLE:
+            return 1
+        return 0
+
     EVENT_CONFIGURATION = "configuration"
     EVENT_OPEN = "open"
     EVENT_START = "start"
@@ -2140,8 +2198,13 @@ class LocalStreamEndPoint(StreamEndPoint, utils.EventEmitter):
         capabilities: Iterable[ServiceCapabilities],
         configuration: Iterable[ServiceCapabilities] | None = None,
     ):
-        StreamEndPoint.__init__(self, seid, media_type, tsep, 0, capabilities)
         utils.EventEmitter.__init__(self)
+        # StreamEndPoint attributes
+        self.seid = seid
+        self.media_type = media_type
+        self.tsep = tsep
+        self.capabilities = capabilities
+
         self.protocol = protocol
         self.configuration = configuration if configuration is not None else []
         self.stream = None
@@ -2155,13 +2218,13 @@ class LocalStreamEndPoint(StreamEndPoint, utils.EventEmitter):
     async def close(self) -> None:
         """[Source Only] Handles when receiving close command."""
 
-    def on_reconfigure_command(
+    async def on_reconfigure_command(
         self, command: Iterable[ServiceCapabilities]
     ) -> Message | None:
         del command  # unused.
         return None
 
-    def on_set_configuration_command(
+    async def on_set_configuration_command(
         self, configuration: Iterable[ServiceCapabilities]
     ) -> Message | None:
         logger.debug(
@@ -2172,34 +2235,34 @@ class LocalStreamEndPoint(StreamEndPoint, utils.EventEmitter):
         self.emit(self.EVENT_CONFIGURATION)
         return None
 
-    def on_get_configuration_command(self) -> Message | None:
+    async def on_get_configuration_command(self) -> Message | None:
         return Get_Configuration_Response(self.configuration)
 
-    def on_open_command(self) -> Message | None:
+    async def on_open_command(self) -> Message | None:
         self.emit(self.EVENT_OPEN)
         return None
 
-    def on_start_command(self) -> Message | None:
+    async def on_start_command(self) -> Message | None:
         self.emit(self.EVENT_START)
         return None
 
-    def on_suspend_command(self) -> Message | None:
+    async def on_suspend_command(self) -> Message | None:
         self.emit(self.EVENT_SUSPEND)
         return None
 
-    def on_close_command(self) -> Message | None:
+    async def on_close_command(self) -> Message | None:
         self.emit(self.EVENT_CLOSE)
         return None
 
-    def on_abort_command(self) -> Message | None:
+    async def on_abort_command(self) -> Message | None:
         self.emit(self.EVENT_ABORT)
         return None
 
-    def on_delayreport_command(self, delay: int) -> Message | None:
+    async def on_delayreport_command(self, delay: int) -> Message | None:
         self.emit(self.EVENT_DELAY_REPORT, delay)
         return None
 
-    def on_security_control_command(self, data: bytes) -> Message | None:
+    async def on_security_control_command(self, data: bytes) -> Message | None:
         self.emit(self.EVENT_SECURITY_CONTROL, data)
         return None
 
@@ -2227,12 +2290,12 @@ class LocalSource(LocalStreamEndPoint):
             codec_capabilities,
         ] + list(other_capabilities)
         super().__init__(
-            protocol,
-            seid,
-            codec_capabilities.media_type,
-            AVDTP_TSEP_SRC,
-            capabilities,
-            capabilities,
+            protocol=protocol,
+            seid=seid,
+            media_type=codec_capabilities.media_type,
+            tsep=AVDTP_TSEP_SRC,
+            capabilities=capabilities,
+            configuration=capabilities,
         )
         self.packet_pump = packet_pump
 
@@ -2251,13 +2314,13 @@ class LocalSource(LocalStreamEndPoint):
         self.emit(self.EVENT_STOP)
 
     @override
-    def on_start_command(self) -> Message | None:
-        asyncio.create_task(self.start())
+    async def on_start_command(self) -> Message | None:
+        await self.start()
         return None
 
     @override
-    def on_suspend_command(self) -> Message | None:
-        asyncio.create_task(self.stop())
+    async def on_suspend_command(self) -> Message | None:
+        await self.stop()
         return None
 
 
@@ -2271,11 +2334,11 @@ class LocalSink(LocalStreamEndPoint):
             codec_capabilities,
         ]
         super().__init__(
-            protocol,
-            seid,
-            codec_capabilities.media_type,
-            AVDTP_TSEP_SNK,
-            capabilities,
+            protocol=protocol,
+            seid=seid,
+            media_type=codec_capabilities.media_type,
+            tsep=AVDTP_TSEP_SNK,
+            capabilities=capabilities,
         )
 
     def on_rtp_channel_open(self) -> None:

bumble/avrcp.py

@@ -22,7 +22,14 @@ import enum
 import functools
 import logging
 import struct
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence
+from collections.abc import (
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Iterable,
+    Mapping,
+    Sequence,
+)
 from dataclasses import dataclass, field
 from typing import ClassVar, SupportsBytes, TypeVar
 
@@ -1049,11 +1056,9 @@ class GetItemAttributesCommand(Command):
     scope: Scope = field(metadata=Scope.type_metadata(1))
     uid: int = field(metadata=_UINT64_BE_METADATA)
     uid_counter: int = field(metadata=hci.metadata('>2'))
-    start_item: int = field(metadata=hci.metadata('>4'))
-    end_item: int = field(metadata=hci.metadata('>4'))
     # When attributes is empty, all attributes will be requested.
     attributes: Sequence[MediaAttributeId] = field(
-        metadata=MediaAttributeId.type_metadata(1, list_begin=True, list_end=True)
+        metadata=MediaAttributeId.type_metadata(4, list_begin=True, list_end=True)
     )
 
 
@@ -1512,7 +1517,9 @@ class PlaybackPositionChangedEvent(Event):
 @dataclass
 class TrackChangedEvent(Event):
     event_id = EventId.TRACK_CHANGED
-    identifier: bytes = field(metadata=hci.metadata('*'))
+    NO_TRACK = 0xFFFFFFFFFFFFFFFF
+
+    uid: int = field(metadata=_UINT64_BE_METADATA)
 
 
 # -----------------------------------------------------------------------------
@@ -1536,15 +1543,18 @@ class PlayerApplicationSettingChangedEvent(Event):
 
         def __post_init__(self) -> None:
             super().__post_init__()
-            if self.attribute_id == ApplicationSetting.AttributeId.EQUALIZER_ON_OFF:
-                self.value_id = ApplicationSetting.EqualizerOnOffStatus(self.value_id)
-            elif self.attribute_id == ApplicationSetting.AttributeId.REPEAT_MODE:
+            match self.attribute_id:
+                case ApplicationSetting.AttributeId.EQUALIZER_ON_OFF:
+                    self.value_id = ApplicationSetting.EqualizerOnOffStatus(
+                        self.value_id
+                    )
+                case ApplicationSetting.AttributeId.REPEAT_MODE:
                     self.value_id = ApplicationSetting.RepeatModeStatus(self.value_id)
-            elif self.attribute_id == ApplicationSetting.AttributeId.SHUFFLE_ON_OFF:
+                case ApplicationSetting.AttributeId.SHUFFLE_ON_OFF:
                     self.value_id = ApplicationSetting.ShuffleOnOffStatus(self.value_id)
-            elif self.attribute_id == ApplicationSetting.AttributeId.SCAN_ON_OFF:
+                case ApplicationSetting.AttributeId.SCAN_ON_OFF:
                     self.value_id = ApplicationSetting.ScanOnOffStatus(self.value_id)
-            else:
+                case _:
                     self.value_id = ApplicationSetting.GenericValue(self.value_id)
 
     player_application_settings: Sequence[Setting] = field(
@@ -1619,6 +1629,8 @@ class Delegate:
 
     supported_events: list[EventId]
     supported_company_ids: list[int]
+    supported_player_app_settings: dict[ApplicationSetting.AttributeId, list[int]]
+    player_app_settings: dict[ApplicationSetting.AttributeId, int]
     volume: int
     playback_status: PlayStatus
 
@@ -1626,11 +1638,23 @@ class Delegate:
         self,
         supported_events: Iterable[EventId] = (),
         supported_company_ids: Iterable[int] = (AVRCP_BLUETOOTH_SIG_COMPANY_ID,),
+        supported_player_app_settings: (
+            Mapping[ApplicationSetting.AttributeId, Sequence[int]] | None
+        ) = None,
     ) -> None:
         self.supported_company_ids = list(supported_company_ids)
         self.supported_events = list(supported_events)
         self.volume = 0
         self.playback_status = PlayStatus.STOPPED
+        self.supported_player_app_settings = (
+            {key: list(value) for key, value in supported_player_app_settings.items()}
+            if supported_player_app_settings
+            else {}
+        )
+        self.player_app_settings = {}
+        self.uid_counter = 0
+        self.addressed_player_id = 0
+        self.current_track_uid = TrackChangedEvent.NO_TRACK
 
     async def get_supported_events(self) -> list[EventId]:
         return self.supported_events
@@ -1663,6 +1687,38 @@ class Delegate:
     async def get_playback_status(self) -> PlayStatus:
         return self.playback_status
 
+    async def get_supported_player_app_settings(
+        self,
+    ) -> dict[ApplicationSetting.AttributeId, list[int]]:
+        return self.supported_player_app_settings
+
+    async def get_current_player_app_settings(
+        self,
+    ) -> dict[ApplicationSetting.AttributeId, int]:
+        return self.player_app_settings
+
+    async def set_player_app_settings(
+        self, attribute: ApplicationSetting.AttributeId, value: int
+    ) -> None:
+        self.player_app_settings[attribute] = value
+
+    async def play_item(self, scope: Scope, uid: int, uid_counter: int) -> None:
+        logger.debug(
+            "@@@ play_item: scope=%s, uid=%s, uid_counter=%s",
+            scope,
+            uid,
+            uid_counter,
+        )
+
+    async def get_uid_counter(self) -> int:
+        return self.uid_counter
+
+    async def get_addressed_player_id(self) -> int:
+        return self.addressed_player_id
+
+    async def get_current_track_uid(self) -> int:
+        return self.current_track_uid
+
     # TODO add other delegate methods
 
 
@@ -1910,6 +1966,51 @@ class Protocol(utils.EventEmitter):
         response = self._check_response(response_context, GetElementAttributesResponse)
         return list(response.attributes)
 
+    async def list_supported_player_app_settings(
+        self, attribute_ids: Sequence[ApplicationSetting.AttributeId] = ()
+    ) -> dict[ApplicationSetting.AttributeId, list[int]]:
+        """Get element attributes from the connected peer."""
+        response_context = await self.send_avrcp_command(
+            avc.CommandFrame.CommandType.STATUS,
+            ListPlayerApplicationSettingAttributesCommand(),
+        )
+        if not attribute_ids:
+            list_attribute_response = self._check_response(
+                response_context, ListPlayerApplicationSettingAttributesResponse
+            )
+            attribute_ids = list_attribute_response.attribute
+
+        supported_settings: dict[ApplicationSetting.AttributeId, list[int]] = {}
+        for attribute_id in attribute_ids:
+            response_context = await self.send_avrcp_command(
+                avc.CommandFrame.CommandType.STATUS,
+                ListPlayerApplicationSettingValuesCommand(attribute_id),
+            )
+            list_value_response = self._check_response(
+                response_context, ListPlayerApplicationSettingValuesResponse
+            )
+            supported_settings[attribute_id] = list(list_value_response.value)
+
+        return supported_settings
+
+    async def get_player_app_settings(
+        self, attribute_ids: Sequence[ApplicationSetting.AttributeId]
+    ) -> dict[ApplicationSetting.AttributeId, int]:
+        """Get element attributes from the connected peer."""
+        response_context = await self.send_avrcp_command(
+            avc.CommandFrame.CommandType.STATUS,
+            GetCurrentPlayerApplicationSettingValueCommand(attribute_ids),
+        )
+        response: GetCurrentPlayerApplicationSettingValueResponse = (
+            self._check_response(
+                response_context, GetCurrentPlayerApplicationSettingValueResponse
+            )
+        )
+        return {
+            attribute_id: value
+            for attribute_id, value in zip(response.attribute, response.value)
+        }
+
     async def monitor_events(
         self, event_id: EventId, playback_interval: int = 0
     ) -> AsyncIterator[Event]:
@@ -1961,13 +2062,13 @@ class Protocol(utils.EventEmitter):
 
     async def monitor_track_changed(
         self,
-    ) -> AsyncIterator[bytes]:
+    ) -> AsyncIterator[int]:
         """Monitor Track changes from the connected peer."""
         async for event in self.monitor_events(EventId.TRACK_CHANGED, 0):
             if not isinstance(event, TrackChangedEvent):
                 logger.warning("unexpected event class")
                 continue
-            yield event.identifier
+            yield event.uid
 
     async def monitor_playback_position(
         self, playback_interval: int
@@ -2060,11 +2161,9 @@ class Protocol(utils.EventEmitter):
         """Notify the connected peer of a Playback Status change."""
         self.notify_event(PlaybackStatusChangedEvent(status))
 
-    def notify_track_changed(self, identifier: bytes) -> None:
+    def notify_track_changed(self, uid: int) -> None:
         """Notify the connected peer of a Track change."""
-        if len(identifier) != 8:
-            raise core.InvalidArgumentError("identifier must be 8 bytes")
-        self.notify_event(TrackChangedEvent(identifier))
+        self.notify_event(TrackChangedEvent(uid))
 
     def notify_playback_position_changed(self, position: int) -> None:
         """Notify the connected peer of a Position change."""
@@ -2280,15 +2379,34 @@ class Protocol(utils.EventEmitter):
         ):
             # TODO: catch exceptions from delegates
             command = Command.from_bytes(pdu_id, pdu)
-            if isinstance(command, GetCapabilitiesCommand):
+            match command:
+                case GetCapabilitiesCommand():
                     self._on_get_capabilities_command(transaction_label, command)
-            elif isinstance(command, SetAbsoluteVolumeCommand):
+                case SetAbsoluteVolumeCommand():
                     self._on_set_absolute_volume_command(transaction_label, command)
-            elif isinstance(command, RegisterNotificationCommand):
+                case RegisterNotificationCommand():
                     self._on_register_notification_command(transaction_label, command)
-            elif isinstance(command, GetPlayStatusCommand):
+                case GetPlayStatusCommand():
                     self._on_get_play_status_command(transaction_label, command)
-            else:
+                case ListPlayerApplicationSettingAttributesCommand():
+                    self._on_list_player_application_setting_attributes_command(
+                        transaction_label, command
+                    )
+                case ListPlayerApplicationSettingValuesCommand():
+                    self._on_list_player_application_setting_values_command(
+                        transaction_label, command
+                    )
+                case SetPlayerApplicationSettingValueCommand():
+                    self._on_set_player_application_setting_value_command(
+                        transaction_label, command
+                    )
+                case GetCurrentPlayerApplicationSettingValueCommand():
+                    self._on_get_current_player_application_setting_value_command(
+                        transaction_label, command
+                    )
+                case PlayItemCommand():
+                    self._on_play_item_command(transaction_label, command)
+                case _:
                     # Not supported.
                     # TODO: check that this is the right way to respond in this case.
                     logger.debug("unsupported PDU ID")
@@ -2322,18 +2440,21 @@ class Protocol(utils.EventEmitter):
         # is Ok, but if/when more responses are supported, a lookup mechanism would be
         # more appropriate.
         response: Response | None = None
-        if response_code == avc.ResponseFrame.ResponseCode.REJECTED:
-            response = RejectedResponse(pdu_id=pdu_id, status_code=StatusCode(pdu[0]))
-        elif response_code == avc.ResponseFrame.ResponseCode.NOT_IMPLEMENTED:
+        match response_code:
+            case avc.ResponseFrame.ResponseCode.REJECTED:
+                response = RejectedResponse(
+                    pdu_id=pdu_id, status_code=StatusCode(pdu[0])
+                )
+            case avc.ResponseFrame.ResponseCode.NOT_IMPLEMENTED:
                 response = NotImplementedResponse(pdu_id=pdu_id, parameters=pdu)
-        elif response_code in (
-            avc.ResponseFrame.ResponseCode.IMPLEMENTED_OR_STABLE,
-            avc.ResponseFrame.ResponseCode.INTERIM,
-            avc.ResponseFrame.ResponseCode.CHANGED,
-            avc.ResponseFrame.ResponseCode.ACCEPTED,
+            case (
+                avc.ResponseFrame.ResponseCode.IMPLEMENTED_OR_STABLE
+                | avc.ResponseFrame.ResponseCode.INTERIM
+                | avc.ResponseFrame.ResponseCode.CHANGED
+                | avc.ResponseFrame.ResponseCode.ACCEPTED
             ):
                 response = Response.from_bytes(pdu=pdu, pdu_id=PduId(pdu_id))
-        else:
+            case _:
                 logger.debug("unexpected response code")
                 pending_command.response.set_exception(
                     core.ProtocolError(
@@ -2512,19 +2633,15 @@ class Protocol(utils.EventEmitter):
 
         async def get_supported_events() -> None:
             capabilities: Sequence[bytes | SupportsBytes]
-            if (
-                command.capability_id
-                == GetCapabilitiesCommand.CapabilityId.EVENTS_SUPPORTED
-            ):
+            match command.capability_id:
+                case GetCapabilitiesCommand.CapabilityId.EVENTS_SUPPORTED:
                     capabilities = await self.delegate.get_supported_events()
-            elif (
-                command.capability_id == GetCapabilitiesCommand.CapabilityId.COMPANY_ID
-            ):
+                case GetCapabilitiesCommand.CapabilityId.EVENTS_SUPPORTED.COMPANY_ID:
                     company_ids = await self.delegate.get_supported_company_ids()
                     capabilities = [
                         company_id.to_bytes(3, 'big') for company_id in company_ids
                     ]
-            else:
+                case _:
                     raise core.InvalidArgumentError(
                         f"Unsupported capability: {command.capability_id}"
                     )
@@ -2572,6 +2689,121 @@ class Protocol(utils.EventEmitter):
 
         self._delegate_command(transaction_label, command, get_playback_status())
 
+    def _on_list_player_application_setting_attributes_command(
+        self,
+        transaction_label: int,
+        command: ListPlayerApplicationSettingAttributesCommand,
+    ) -> None:
+        logger.debug("<<< AVRCP command PDU: %s", command)
+
+        async def get_supported_player_app_settings() -> None:
+            supported_settings = await self.delegate.get_supported_player_app_settings()
+            self.send_avrcp_response(
+                transaction_label,
+                avc.ResponseFrame.ResponseCode.IMPLEMENTED_OR_STABLE,
+                ListPlayerApplicationSettingAttributesResponse(
+                    list(supported_settings.keys())
+                ),
+            )
+
+        self._delegate_command(
+            transaction_label, command, get_supported_player_app_settings()
+        )
+
+    def _on_list_player_application_setting_values_command(
+        self,
+        transaction_label: int,
+        command: ListPlayerApplicationSettingValuesCommand,
+    ) -> None:
+        logger.debug("<<< AVRCP command PDU: %s", command)
+
+        async def get_supported_player_app_settings() -> None:
+            supported_settings = await self.delegate.get_supported_player_app_settings()
+            self.send_avrcp_response(
+                transaction_label,
+                avc.ResponseFrame.ResponseCode.IMPLEMENTED_OR_STABLE,
+                ListPlayerApplicationSettingValuesResponse(
+                    supported_settings.get(command.attribute, [])
+                ),
+            )
+
+        self._delegate_command(
+            transaction_label, command, get_supported_player_app_settings()
+        )
+
+    def _on_get_current_player_application_setting_value_command(
+        self,
+        transaction_label: int,
+        command: GetCurrentPlayerApplicationSettingValueCommand,
+    ) -> None:
+        logger.debug("<<< AVRCP command PDU: %s", command)
+
+        async def get_supported_player_app_settings() -> None:
+            current_settings = await self.delegate.get_current_player_app_settings()
+
+            if not all(
+                attribute in current_settings for attribute in command.attribute
+            ):
+                self.send_not_implemented_avrcp_response(
+                    transaction_label,
+                    PduId.GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE,
+                )
+                return
+
+            self.send_avrcp_response(
+                transaction_label,
+                avc.ResponseFrame.ResponseCode.IMPLEMENTED_OR_STABLE,
+                GetCurrentPlayerApplicationSettingValueResponse(
+                    attribute=command.attribute,
+                    value=[
+                        current_settings[attribute] for attribute in command.attribute
+                    ],
+                ),
+            )
+
+        self._delegate_command(
+            transaction_label, command, get_supported_player_app_settings()
+        )
+
+    def _on_set_player_application_setting_value_command(
+        self,
+        transaction_label: int,
+        command: SetPlayerApplicationSettingValueCommand,
+    ) -> None:
+        logger.debug("<<< AVRCP command PDU: %s", command)
+
+        async def set_player_app_settings() -> None:
+            for attribute, value in zip(command.attribute, command.value):
+                await self.delegate.set_player_app_settings(attribute, value)
+
+            self.send_avrcp_response(
+                transaction_label,
+                avc.ResponseFrame.ResponseCode.IMPLEMENTED_OR_STABLE,
+                SetPlayerApplicationSettingValueResponse(),
+            )
+
+        self._delegate_command(transaction_label, command, set_player_app_settings())
+
+    def _on_play_item_command(
+        self,
+        transaction_label: int,
+        command: PlayItemCommand,
+    ) -> None:
+        logger.debug("<<< AVRCP command PDU: %s", command)
+
+        async def play_item() -> None:
+            await self.delegate.play_item(
+                scope=command.scope, uid=command.uid, uid_counter=command.uid_counter
+            )
+
+            self.send_avrcp_response(
+                transaction_label,
+                avc.ResponseFrame.ResponseCode.IMPLEMENTED_OR_STABLE,
+                PlayItemResponse(status=StatusCode.OPERATION_COMPLETED),
+            )
+
+        self._delegate_command(transaction_label, command, play_item())
+
     def _on_register_notification_command(
         self, transaction_label: int, command: RegisterNotificationCommand
     ) -> None:
@@ -2587,26 +2819,51 @@ class Protocol(utils.EventEmitter):
                 )
                 return
 
-            response: Response
-            if command.event_id == EventId.VOLUME_CHANGED:
+            event: Event
+            match command.event_id:
+                case EventId.VOLUME_CHANGED:
                     volume = await self.delegate.get_absolute_volume()
-                response = RegisterNotificationResponse(VolumeChangedEvent(volume))
-            elif command.event_id == EventId.PLAYBACK_STATUS_CHANGED:
+                    event = VolumeChangedEvent(volume)
+                case EventId.PLAYBACK_STATUS_CHANGED:
                     playback_status = await self.delegate.get_playback_status()
-                response = RegisterNotificationResponse(
-                    PlaybackStatusChangedEvent(play_status=playback_status)
+                    event = PlaybackStatusChangedEvent(play_status=playback_status)
+                case EventId.NOW_PLAYING_CONTENT_CHANGED:
+                    event = NowPlayingContentChangedEvent()
+                case EventId.PLAYER_APPLICATION_SETTING_CHANGED:
+                    settings = await self.delegate.get_current_player_app_settings()
+                    event = PlayerApplicationSettingChangedEvent(
+                        [
+                            PlayerApplicationSettingChangedEvent.Setting(
+                                attribute, value  # type: ignore
+                            )
+                            for attribute, value in settings.items()
+                        ]
+                    )
+                case EventId.AVAILABLE_PLAYERS_CHANGED:
+                    event = AvailablePlayersChangedEvent()
+                case EventId.ADDRESSED_PLAYER_CHANGED:
+                    event = AddressedPlayerChangedEvent(
+                        AddressedPlayerChangedEvent.Player(
+                            player_id=await self.delegate.get_addressed_player_id(),
+                            uid_counter=await self.delegate.get_uid_counter(),
+                        )
+                    )
+                case EventId.UIDS_CHANGED:
+                    event = UidsChangedEvent(await self.delegate.get_uid_counter())
+                case EventId.TRACK_CHANGED:
+                    event = TrackChangedEvent(
+                        await self.delegate.get_current_track_uid()
+                    )
+                case _:
+                    logger.warning(
+                        "Event supported but not handled %s", command.event_id
                     )
-            elif command.event_id == EventId.NOW_PLAYING_CONTENT_CHANGED:
-                playback_status = await self.delegate.get_playback_status()
-                response = RegisterNotificationResponse(NowPlayingContentChangedEvent())
-            else:
-                logger.warning("Event supported but not handled %s", command.event_id)
                     return
 
             self.send_avrcp_response(
                 transaction_label,
                 avc.ResponseFrame.ResponseCode.INTERIM,
-                response,
+                RegisterNotificationResponse(event),
             )
             self._register_notification_listener(transaction_label, command)
 

bumble/core.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import dataclasses
 import enum
+import functools
 import struct
 from collections.abc import Iterable
 from typing import (
@@ -273,6 +274,18 @@ class UUID:
     def parse_uuid_2(cls, uuid_as_bytes: bytes, offset: int) -> tuple[int, UUID]:
         return offset + 2, cls.from_bytes(uuid_as_bytes[offset : offset + 2])
 
+    @functools.cached_property
+    def uuid_128_bytes(self) -> bytes:
+        match len(self.uuid_bytes):
+            case 2:
+                return self.BASE_UUID + self.uuid_bytes + bytes([0, 0])
+            case 4:
+                return self.BASE_UUID + self.uuid_bytes
+            case 16:
+                return self.uuid_bytes
+            case _:
+                assert False, "unreachable"
+
     def to_bytes(self, force_128: bool = False) -> bytes:
         '''
         Serialize UUID in little-endian byte-order
@@ -280,14 +293,7 @@ class UUID:
         if not force_128:
             return self.uuid_bytes
 
-        if len(self.uuid_bytes) == 2:
-            return self.BASE_UUID + self.uuid_bytes + bytes([0, 0])
-        elif len(self.uuid_bytes) == 4:
-            return self.BASE_UUID + self.uuid_bytes
-        elif len(self.uuid_bytes) == 16:
-            return self.uuid_bytes
-        else:
-            assert False, "unreachable"
+        return self.uuid_128_bytes
 
     def to_pdu_bytes(self) -> bytes:
         '''
@@ -317,7 +323,7 @@ class UUID:
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, UUID):
-            return self.to_bytes(force_128=True) == other.to_bytes(force_128=True)
+            return self.uuid_128_bytes == other.uuid_128_bytes
 
         if isinstance(other, str):
             return UUID(other) == self
@@ -325,7 +331,7 @@ class UUID:
         return False
 
     def __hash__(self) -> int:
-        return hash(self.uuid_bytes)
+        return hash(self.uuid_128_bytes)
 
     def __str__(self) -> str:
         result = self.to_hex_str(separator='-')
@@ -1769,64 +1775,69 @@ class AdvertisingData:
 
     @classmethod
     def ad_data_to_string(cls, ad_type: int, ad_data: bytes) -> str:
-        if ad_type == AdvertisingData.FLAGS:
+        match ad_type:
+            case AdvertisingData.FLAGS:
                 ad_type_str = 'Flags'
                 ad_data_str = AdvertisingData.flags_to_string(ad_data[0], short=True)
-        elif ad_type == AdvertisingData.COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
+            case AdvertisingData.COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
                 ad_type_str = 'Complete List of 16-bit Service Class UUIDs'
                 ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 2)
-        elif ad_type == AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
+            case AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
                 ad_type_str = 'Incomplete List of 16-bit Service Class UUIDs'
                 ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 2)
-        elif ad_type == AdvertisingData.COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
+            case AdvertisingData.COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
                 ad_type_str = 'Complete List of 32-bit Service Class UUIDs'
                 ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 4)
-        elif ad_type == AdvertisingData.INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
+            case AdvertisingData.INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
                 ad_type_str = 'Incomplete List of 32-bit Service Class UUIDs'
                 ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 4)
-        elif ad_type == AdvertisingData.COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
+            case AdvertisingData.COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
                 ad_type_str = 'Complete List of 128-bit Service Class UUIDs'
                 ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 16)
-        elif ad_type == AdvertisingData.INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
+            case AdvertisingData.INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
                 ad_type_str = 'Incomplete List of 128-bit Service Class UUIDs'
                 ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 16)
-        elif ad_type == AdvertisingData.SERVICE_DATA_16_BIT_UUID:
+            case AdvertisingData.SERVICE_DATA_16_BIT_UUID:
                 ad_type_str = 'Service Data'
                 uuid = UUID.from_bytes(ad_data[:2])
                 ad_data_str = f'service={uuid}, data={ad_data[2:].hex()}'
-        elif ad_type == AdvertisingData.SERVICE_DATA_32_BIT_UUID:
+            case AdvertisingData.SERVICE_DATA_32_BIT_UUID:
                 ad_type_str = 'Service Data'
                 uuid = UUID.from_bytes(ad_data[:4])
                 ad_data_str = f'service={uuid}, data={ad_data[4:].hex()}'
-        elif ad_type == AdvertisingData.SERVICE_DATA_128_BIT_UUID:
+            case AdvertisingData.SERVICE_DATA_128_BIT_UUID:
                 ad_type_str = 'Service Data'
                 uuid = UUID.from_bytes(ad_data[:16])
                 ad_data_str = f'service={uuid}, data={ad_data[16:].hex()}'
-        elif ad_type == AdvertisingData.SHORTENED_LOCAL_NAME:
+            case AdvertisingData.SHORTENED_LOCAL_NAME:
                 ad_type_str = 'Shortened Local Name'
                 ad_data_str = f'"{ad_data.decode("utf-8")}"'
-        elif ad_type == AdvertisingData.COMPLETE_LOCAL_NAME:
+            case AdvertisingData.COMPLETE_LOCAL_NAME:
                 ad_type_str = 'Complete Local Name'
                 try:
                     ad_data_str = f'"{ad_data.decode("utf-8")}"'
                 except UnicodeDecodeError:
                     ad_data_str = ad_data.hex()
-        elif ad_type == AdvertisingData.TX_POWER_LEVEL:
+            case AdvertisingData.TX_POWER_LEVEL:
                 ad_type_str = 'TX Power Level'
                 ad_data_str = str(ad_data[0])
-        elif ad_type == AdvertisingData.MANUFACTURER_SPECIFIC_DATA:
+            case AdvertisingData.MANUFACTURER_SPECIFIC_DATA:
                 ad_type_str = 'Manufacturer Specific Data'
                 company_id = struct.unpack_from('<H', ad_data, 0)[0]
-            company_name = COMPANY_IDENTIFIERS.get(company_id, f'0x{company_id:04X}')
+                company_name = COMPANY_IDENTIFIERS.get(
+                    company_id, f'0x{company_id:04X}'
+                )
                 ad_data_str = f'company={company_name}, data={ad_data[2:].hex()}'
-        elif ad_type == AdvertisingData.APPEARANCE:
+            case AdvertisingData.APPEARANCE:
                 ad_type_str = 'Appearance'
-            appearance = Appearance.from_int(struct.unpack_from('<H', ad_data, 0)[0])
+                appearance = Appearance.from_int(
+                    struct.unpack_from('<H', ad_data, 0)[0]
+                )
                 ad_data_str = str(appearance)
-        elif ad_type == AdvertisingData.BROADCAST_NAME:
+            case AdvertisingData.BROADCAST_NAME:
                 ad_type_str = 'Broadcast Name'
                 ad_data_str = ad_data.decode('utf-8')
-        else:
+            case _:
                 ad_type_str = AdvertisingData.Type(ad_type).name
                 ad_data_str = ad_data.hex()
 
@@ -2105,13 +2116,10 @@ class AdvertisingData:
 # -----------------------------------------------------------------------------
 # Connection PHY
 # -----------------------------------------------------------------------------
+@dataclasses.dataclass
 class ConnectionPHY:
-    def __init__(self, tx_phy, rx_phy):
-        self.tx_phy = tx_phy
-        self.rx_phy = rx_phy
-
-    def __str__(self):
-        return f'ConnectionPHY(tx_phy={self.tx_phy}, rx_phy={self.rx_phy})'
+    tx_phy: int
+    rx_phy: int
 
 
 # -----------------------------------------------------------------------------

bumble/device.py

@@ -1423,6 +1423,9 @@ class ScoLink(utils.CompositeEventEmitter):
     acl_connection: Connection
     handle: int
     link_type: int
+    rx_packet_length: int
+    tx_packet_length: int
+    air_mode: hci.CodecID
     sink: Callable[[hci.HCI_SynchronousDataPacket], Any] | None = None
 
     EVENT_DISCONNECTION: ClassVar[str] = "disconnection"
@@ -1837,6 +1840,7 @@ class Connection(utils.CompositeEventEmitter):
         self.pairing_peer_io_capability = None
         self.pairing_peer_authentication_requirements = None
         self.peer_le_features = hci.LeFeatureMask(0)
+        self.peer_classic_features = hci.LmpFeatureMask(0)
         self.cs_configs = {}
         self.cs_procedures = {}
 
@@ -2054,6 +2058,15 @@ class Connection(utils.CompositeEventEmitter):
         self.peer_le_features = await self.device.get_remote_le_features(self)
         return self.peer_le_features
 
+    async def get_remote_classic_features(self) -> hci.LmpFeatureMask:
+        """[Classic Only] Reads remote LMP supported features.
+
+        Returns:
+            LMP features supported by the remote device.
+        """
+        self.peer_classic_features = await self.device.get_remote_classic_features(self)
+        return self.peer_classic_features
+
     def on_att_mtu_update(self, mtu: int):
         logger.debug(
             f'*** Connection ATT MTU Update: [0x{self.handle:04X}] '
@@ -2149,6 +2162,7 @@ class DeviceConfiguration:
     )
     eatt_enabled: bool = False
     gatt_services: list[dict[str, Any]] = field(init=False)
+    smp_debug_mode: bool = False
 
     def __post_init__(self) -> None:
         self.gatt_services = []
@@ -2332,6 +2346,9 @@ class Device(utils.CompositeEventEmitter):
     _pending_cis: dict[int, tuple[int, int]]
     gatt_service: gatt_service.GenericAttributeProfileService | None = None
     keystore: KeyStore | None = None
+    inquiry_response: bytes | None = None
+    address_resolver: smp.AddressResolver | None = None
+    connect_own_address_type: hci.OwnAddressType | None = None
 
     EVENT_ADVERTISEMENT = "advertisement"
     EVENT_PERIODIC_ADVERTISING_SYNC_TRANSFER = "periodic_advertising_sync_transfer"
@@ -2450,17 +2467,12 @@ class Device(utils.CompositeEventEmitter):
         self.bis_links = {}
         self.big_syncs = {}
         self.classic_enabled = False
-        self.inquiry_response = None
-        self.address_resolver = None
         self.classic_pending_accepts = {
             hci.Address.ANY: []
         }  # Futures, by BD address OR [Futures] for hci.Address.ANY
 
         self._cis_lock = asyncio.Lock()
 
-        # Own address type cache
-        self.connect_own_address_type = None
-
         self.name = config.name
         self.public_address = hci.Address.ANY
         self.random_address = config.address
@@ -2561,6 +2573,7 @@ class Device(utils.CompositeEventEmitter):
                 ),
             ),
         )
+        self.smp_manager.debug_mode = self.config.smp_debug_mode
 
         self.l2cap_channel_manager.register_fixed_channel(smp.SMP_CID, self.on_smp_pdu)
 
@@ -5281,6 +5294,77 @@ class Device(utils.CompositeEventEmitter):
             )
             return await read_feature_future
 
+    async def get_remote_classic_features(
+        self, connection: Connection
+    ) -> hci.LmpFeatureMask:
+        """[Classic Only] Reads remote LE supported features.
+
+        Args:
+            handle: connection handle to read LMP features.
+
+        Returns:
+            LMP features supported by the remote device.
+        """
+        with closing(utils.EventWatcher()) as watcher:
+            read_feature_future: asyncio.Future[tuple[int, int]] = (
+                asyncio.get_running_loop().create_future()
+            )
+            read_features = hci.LmpFeatureMask(0)
+            current_page_number = 0
+
+            @watcher.on(self.host, 'classic_remote_features')
+            def on_classic_remote_features(
+                handle: int,
+                status: int,
+                features: int,
+                page_number: int,
+                max_page_number: int,
+            ) -> None:
+                if handle != connection.handle:
+                    logger.warning(
+                        "Received classic_remote_features for wrong handle, expected=0x%04X, got=0x%04X",
+                        connection.handle,
+                        handle,
+                    )
+                    return
+                if page_number != current_page_number:
+                    logger.warning(
+                        "Received classic_remote_features for wrong page, expected=%d, got=%d",
+                        current_page_number,
+                        page_number,
+                    )
+                    return
+
+                if status == hci.HCI_ErrorCode.SUCCESS:
+                    read_feature_future.set_result((features, max_page_number))
+                else:
+                    read_feature_future.set_exception(hci.HCI_Error(status))
+
+            await self.send_async_command(
+                hci.HCI_Read_Remote_Supported_Features_Command(
+                    connection_handle=connection.handle
+                )
+            )
+
+            new_features, max_page_number = await read_feature_future
+            read_features |= new_features
+            if not (read_features & hci.LmpFeatureMask.EXTENDED_FEATURES):
+                return read_features
+
+            while current_page_number <= max_page_number:
+                read_feature_future = asyncio.get_running_loop().create_future()
+                await self.send_async_command(
+                    hci.HCI_Read_Remote_Extended_Features_Command(
+                        connection_handle=connection.handle,
+                        page_number=current_page_number,
+                    )
+                )
+                new_features, max_page_number = await read_feature_future
+                read_features |= new_features << (current_page_number * 64)
+                current_page_number += 1
+
+            return read_features
+
     @utils.experimental('Only for testing.')
     async def get_remote_cs_capabilities(
         self, connection: Connection
@@ -5535,8 +5619,8 @@ class Device(utils.CompositeEventEmitter):
     async def notify_subscriber(
         self,
         connection: Connection,
-        attribute: Attribute,
-        value: Any | None = None,
+        attribute: Attribute[_T],
+        value: _T | None = None,
         force: bool = False,
     ) -> None:
         """
@@ -5555,7 +5639,7 @@ class Device(utils.CompositeEventEmitter):
         await self.gatt_server.notify_subscriber(connection, attribute, value, force)
 
     async def notify_subscribers(
-        self, attribute: Attribute, value: Any | None = None, force: bool = False
+        self, attribute: Attribute[_T], value: _T | None = None, force: bool = False
     ) -> None:
         """
         Send a notification to all the subscribers of an attribute.
@@ -5574,8 +5658,8 @@ class Device(utils.CompositeEventEmitter):
     async def indicate_subscriber(
         self,
         connection: Connection,
-        attribute: Attribute,
-        value: Any | None = None,
+        attribute: Attribute[_T],
+        value: _T | None = None,
         force: bool = False,
     ):
         """
@@ -5596,7 +5680,7 @@ class Device(utils.CompositeEventEmitter):
         await self.gatt_server.indicate_subscriber(connection, attribute, value, force)
 
     async def indicate_subscribers(
-        self, attribute: Attribute, value: Any | None = None, force: bool = False
+        self, attribute: Attribute[_T], value: _T | None = None, force: bool = False
     ):
         """
         Send an indication to all the subscribers of an attribute.
@@ -5968,7 +6052,7 @@ class Device(utils.CompositeEventEmitter):
     def on_connection_request(
         self, bd_addr: hci.Address, class_of_device: int, link_type: int
     ):
-        logger.debug(f'*** Connection request: {bd_addr}')
+        logger.debug(f'*** Connection request: {bd_addr} link_type={link_type}')
 
         # Handle SCO request.
         if link_type in (
@@ -5978,6 +6062,7 @@ class Device(utils.CompositeEventEmitter):
             if connection := self.find_connection_by_bd_addr(
                 bd_addr, transport=PhysicalTransport.BR_EDR
             ):
+                connection.emit(self.EVENT_SCO_REQUEST, link_type)
                 self.emit(self.EVENT_SCO_REQUEST, connection, link_type)
             else:
                 logger.error(f'SCO request from a non-connected device {bd_addr}')
@@ -6337,7 +6422,6 @@ class Device(utils.CompositeEventEmitter):
             logger.warning('peer name is not valid UTF-8')
             if connection:
                 connection.emit(connection.EVENT_REMOTE_NAME_FAILURE, error)
-            else:
             self.emit(self.EVENT_REMOTE_NAME_FAILURE, address, error)
 
     # [Classic only]
@@ -6355,7 +6439,13 @@ class Device(utils.CompositeEventEmitter):
     @with_connection_from_address
     @utils.experimental('Only for testing.')
     def on_sco_connection(
-        self, acl_connection: Connection, sco_handle: int, link_type: int
+        self,
+        acl_connection: Connection,
+        sco_handle: int,
+        link_type: int,
+        rx_packet_length: int,
+        tx_packet_length: int,
+        air_mode: int,
     ) -> None:
         logger.debug(
             f'*** SCO connected: {acl_connection.peer_address}, '
@@ -6367,7 +6457,11 @@ class Device(utils.CompositeEventEmitter):
             acl_connection=acl_connection,
             handle=sco_handle,
             link_type=link_type,
+            rx_packet_length=rx_packet_length,
+            tx_packet_length=tx_packet_length,
+            air_mode=hci.CodecID(air_mode),
         )
+        acl_connection.emit(self.EVENT_SCO_CONNECTION, sco_link)
         self.emit(self.EVENT_SCO_CONNECTION, sco_link)
 
     # [Classic only]
@@ -6378,7 +6472,8 @@ class Device(utils.CompositeEventEmitter):
         self, acl_connection: Connection, status: int
     ) -> None:
         logger.debug(f'*** SCO connection failure: {acl_connection.peer_address}***')
-        self.emit(self.EVENT_SCO_CONNECTION_FAILURE)
+        acl_connection.emit(self.EVENT_SCO_CONNECTION_FAILURE, status)
+        self.emit(self.EVENT_SCO_CONNECTION_FAILURE, status)
 
     # [Classic only]
     @host_event_handler
@@ -6841,15 +6936,18 @@ class Device(utils.CompositeEventEmitter):
     @with_connection_from_address
     def on_classic_pairing(self, connection: Connection) -> None:
         connection.emit(connection.EVENT_CLASSIC_PAIRING)
+        self.emit(connection.EVENT_CLASSIC_PAIRING, connection)
 
     # [Classic only]
     @host_event_handler
     @with_connection_from_address
     def on_classic_pairing_failure(self, connection: Connection, status: int) -> None:
         connection.emit(connection.EVENT_CLASSIC_PAIRING_FAILURE, status)
+        self.emit(connection.EVENT_CLASSIC_PAIRING_FAILURE, connection, status)
 
     def on_pairing_start(self, connection: Connection) -> None:
         connection.emit(connection.EVENT_PAIRING_START)
+        self.emit(connection.EVENT_PAIRING_START, connection)
 
     def on_pairing(
         self,

bumble/drivers/intel.py

@@ -201,10 +201,11 @@ def _parse_tlv(data: bytes) -> list[tuple[ValueType, Any]]:
         value = data[2 : 2 + value_length]
         typed_value: Any
 
-        if value_type == ValueType.END:
+        match value_type:
+            case ValueType.END:
                 break
 
-        if value_type in (ValueType.CNVI, ValueType.CNVR):
+            case ValueType.CNVI | ValueType.CNVR:
                 (v,) = struct.unpack("<I", value)
                 typed_value = (
                     (((v >> 0) & 0xF) << 12)
@@ -212,38 +213,38 @@ def _parse_tlv(data: bytes) -> list[tuple[ValueType, Any]]:
                     | (((v >> 8) & 0xF) << 4)
                     | (((v >> 24) & 0xF) << 8)
                 )
-        elif value_type == ValueType.HARDWARE_INFO:
+            case ValueType.HARDWARE_INFO:
                 (v,) = struct.unpack("<I", value)
                 typed_value = HardwareInfo(
                     HardwarePlatform((v >> 8) & 0xFF), HardwareVariant((v >> 16) & 0x3F)
                 )
-        elif value_type in (
-            ValueType.USB_VENDOR_ID,
-            ValueType.USB_PRODUCT_ID,
-            ValueType.DEVICE_REVISION,
+            case (
+                ValueType.USB_VENDOR_ID
+                | ValueType.USB_PRODUCT_ID
+                | ValueType.DEVICE_REVISION
             ):
                 (typed_value,) = struct.unpack("<H", value)
-        elif value_type == ValueType.CURRENT_MODE_OF_OPERATION:
+            case ValueType.CURRENT_MODE_OF_OPERATION:
                 typed_value = ModeOfOperation(value[0])
-        elif value_type in (
-            ValueType.BUILD_TYPE,
-            ValueType.BUILD_NUMBER,
-            ValueType.SECURE_BOOT,
-            ValueType.OTP_LOCK,
-            ValueType.API_LOCK,
-            ValueType.DEBUG_LOCK,
-            ValueType.SECURE_BOOT_ENGINE_TYPE,
+            case (
+                ValueType.BUILD_TYPE
+                | ValueType.BUILD_NUMBER
+                | ValueType.SECURE_BOOT
+                | ValueType.OTP_LOCK
+                | ValueType.API_LOCK
+                | ValueType.DEBUG_LOCK
+                | ValueType.SECURE_BOOT_ENGINE_TYPE
             ):
                 typed_value = value[0]
-        elif value_type == ValueType.TIMESTAMP:
+            case ValueType.TIMESTAMP:
                 typed_value = Timestamp(value[0], value[1])
-        elif value_type == ValueType.FIRMWARE_BUILD:
+            case ValueType.FIRMWARE_BUILD:
                 typed_value = FirmwareBuild(value[0], Timestamp(value[1], value[2]))
-        elif value_type == ValueType.BLUETOOTH_ADDRESS:
+            case ValueType.BLUETOOTH_ADDRESS:
                 typed_value = hci.Address(
                     value, address_type=hci.Address.PUBLIC_DEVICE_ADDRESS
                 )
-        else:
+            case _:
                 typed_value = value
 
         result.append((value_type, typed_value))

bumble/gap.py

@@ -1,60 +0,0 @@
-# Copyright 2021-2022 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 struct
-
-from bumble.gatt import (
-    GATT_APPEARANCE_CHARACTERISTIC,
-    GATT_DEVICE_NAME_CHARACTERISTIC,
-    GATT_GENERIC_ACCESS_SERVICE,
-    Characteristic,
-    Service,
-)
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# Classes
-# -----------------------------------------------------------------------------
-
-
-# -----------------------------------------------------------------------------
-class GenericAccessService(Service):
-    def __init__(self, device_name, appearance=(0, 0)):
-        device_name_characteristic = Characteristic(
-            GATT_DEVICE_NAME_CHARACTERISTIC,
-            Characteristic.Properties.READ,
-            Characteristic.READABLE,
-            device_name.encode('utf-8')[:248],
-        )
-
-        appearance_characteristic = Characteristic(
-            GATT_APPEARANCE_CHARACTERISTIC,
-            Characteristic.Properties.READ,
-            Characteristic.READABLE,
-            struct.pack('<H', (appearance[0] << 6) | appearance[1]),
-        )
-
-        super().__init__(
-            GATT_GENERIC_ACCESS_SERVICE,
-            [device_name_characteristic, appearance_characteristic],
-        )

bumble/gatt_server.py

@@ -67,6 +67,8 @@ GATT_SERVER_DEFAULT_MAX_MTU = 517
 # Helpers
 # -----------------------------------------------------------------------------
 
+_T = TypeVar('_T')
+
 
 def _bearer_id(bearer: att.Bearer) -> str:
     if att.is_enhanced_bearer(bearer):
@@ -369,8 +371,8 @@ class Server(utils.EventEmitter):
     async def notify_subscriber(
         self,
         bearer: att.Bearer,
-        attribute: att.Attribute,
-        value: bytes | None = None,
+        attribute: att.Attribute[_T],
+        value: _T | None = None,
         force: bool = False,
     ) -> None:
         if att.is_enhanced_bearer(bearer) or force:
@@ -390,8 +392,8 @@ class Server(utils.EventEmitter):
     async def _notify_single_subscriber(
         self,
         bearer: att.Bearer,
-        attribute: att.Attribute,
-        value: bytes | None,
+        attribute: att.Attribute[_T],
+        value: _T | None,
         force: bool,
     ) -> None:
         # Check if there's a subscriber
@@ -411,19 +413,19 @@ class Server(utils.EventEmitter):
                 return
 
         # Get or encode the value
-        value = (
+        value_as_bytes = (
             await attribute.read_value(bearer)
             if value is None
             else attribute.encode_value(value)
         )
 
         # Truncate if needed
-        if len(value) > bearer.att_mtu - 3:
-            value = value[: bearer.att_mtu - 3]
+        if len(value_as_bytes) > bearer.att_mtu - 3:
+            value_as_bytes = value_as_bytes[: bearer.att_mtu - 3]
 
         # Notify
         notification = att.ATT_Handle_Value_Notification(
-            attribute_handle=attribute.handle, attribute_value=value
+            attribute_handle=attribute.handle, attribute_value=value_as_bytes
         )
         logger.debug(f'GATT Notify from server: {_bearer_id(bearer)} {notification}')
         self.send_gatt_pdu(bearer, bytes(notification))
@@ -431,8 +433,8 @@ class Server(utils.EventEmitter):
     async def indicate_subscriber(
         self,
         bearer: att.Bearer,
-        attribute: att.Attribute,
-        value: bytes | None = None,
+        attribute: att.Attribute[_T],
+        value: _T | None = None,
         force: bool = False,
     ) -> None:
         if att.is_enhanced_bearer(bearer) or force:
@@ -452,8 +454,8 @@ class Server(utils.EventEmitter):
     async def _indicate_single_bearer(
         self,
         bearer: att.Bearer,
-        attribute: att.Attribute,
-        value: bytes | None,
+        attribute: att.Attribute[_T],
+        value: _T | None,
         force: bool,
     ) -> None:
         # Check if there's a subscriber
@@ -473,19 +475,19 @@ class Server(utils.EventEmitter):
                 return
 
         # Get or encode the value
-        value = (
+        value_as_bytes = (
             await attribute.read_value(bearer)
             if value is None
             else attribute.encode_value(value)
         )
 
         # Truncate if needed
-        if len(value) > bearer.att_mtu - 3:
-            value = value[: bearer.att_mtu - 3]
+        if len(value_as_bytes) > bearer.att_mtu - 3:
+            value_as_bytes = value_as_bytes[: bearer.att_mtu - 3]
 
         # Indicate
         indication = att.ATT_Handle_Value_Indication(
-            attribute_handle=attribute.handle, attribute_value=value
+            attribute_handle=attribute.handle, attribute_value=value_as_bytes
         )
         logger.debug(f'GATT Indicate from server: {_bearer_id(bearer)} {indication}')
 
@@ -510,8 +512,8 @@ class Server(utils.EventEmitter):
     async def _notify_or_indicate_subscribers(
         self,
         indicate: bool,
-        attribute: att.Attribute,
-        value: bytes | None = None,
+        attribute: att.Attribute[_T],
+        value: _T | None = None,
         force: bool = False,
     ) -> None:
         # Get all the bearers for which there's at least one subscription
@@ -537,8 +539,8 @@ class Server(utils.EventEmitter):
 
     async def notify_subscribers(
         self,
-        attribute: att.Attribute,
-        value: bytes | None = None,
+        attribute: att.Attribute[_T],
+        value: _T | None = None,
         force: bool = False,
     ):
         return await self._notify_or_indicate_subscribers(
@@ -547,8 +549,8 @@ class Server(utils.EventEmitter):
 
     async def indicate_subscribers(
         self,
-        attribute: att.Attribute,
-        value: bytes | None = None,
+        attribute: att.Attribute[_T],
+        value: _T | None = None,
         force: bool = False,
     ):
         return await self._notify_or_indicate_subscribers(True, attribute, value, force)

bumble/hci.py

@@ -31,6 +31,7 @@ from typing import (
     ClassVar,
     Generic,
     Literal,
+    SupportsBytes,
     TypeVar,
     cast,
 )
@@ -247,28 +248,6 @@ HCI_VERSION_BLUETOOTH_CORE_6_0     = SpecificationVersion.BLUETOOTH_CORE_6_0
 HCI_VERSION_BLUETOOTH_CORE_6_1     = SpecificationVersion.BLUETOOTH_CORE_6_1
 HCI_VERSION_BLUETOOTH_CORE_6_2     = SpecificationVersion.BLUETOOTH_CORE_6_2
 
-HCI_VERSION_NAMES = {
-    HCI_VERSION_BLUETOOTH_CORE_1_0B:    'HCI_VERSION_BLUETOOTH_CORE_1_0B',
-    HCI_VERSION_BLUETOOTH_CORE_1_1:     'HCI_VERSION_BLUETOOTH_CORE_1_1',
-    HCI_VERSION_BLUETOOTH_CORE_1_2:     'HCI_VERSION_BLUETOOTH_CORE_1_2',
-    HCI_VERSION_BLUETOOTH_CORE_2_0_EDR: 'HCI_VERSION_BLUETOOTH_CORE_2_0_EDR',
-    HCI_VERSION_BLUETOOTH_CORE_2_1_EDR: 'HCI_VERSION_BLUETOOTH_CORE_2_1_EDR',
-    HCI_VERSION_BLUETOOTH_CORE_3_0_HS:  'HCI_VERSION_BLUETOOTH_CORE_3_0_HS',
-    HCI_VERSION_BLUETOOTH_CORE_4_0:     'HCI_VERSION_BLUETOOTH_CORE_4_0',
-    HCI_VERSION_BLUETOOTH_CORE_4_1:     'HCI_VERSION_BLUETOOTH_CORE_4_1',
-    HCI_VERSION_BLUETOOTH_CORE_4_2:     'HCI_VERSION_BLUETOOTH_CORE_4_2',
-    HCI_VERSION_BLUETOOTH_CORE_5_0:     'HCI_VERSION_BLUETOOTH_CORE_5_0',
-    HCI_VERSION_BLUETOOTH_CORE_5_1:     'HCI_VERSION_BLUETOOTH_CORE_5_1',
-    HCI_VERSION_BLUETOOTH_CORE_5_2:     'HCI_VERSION_BLUETOOTH_CORE_5_2',
-    HCI_VERSION_BLUETOOTH_CORE_5_3:     'HCI_VERSION_BLUETOOTH_CORE_5_3',
-    HCI_VERSION_BLUETOOTH_CORE_5_4:     'HCI_VERSION_BLUETOOTH_CORE_5_4',
-    HCI_VERSION_BLUETOOTH_CORE_6_0:     'HCI_VERSION_BLUETOOTH_CORE_6_0',
-    HCI_VERSION_BLUETOOTH_CORE_6_1:     'HCI_VERSION_BLUETOOTH_CORE_6_1',
-    HCI_VERSION_BLUETOOTH_CORE_6_2:     'HCI_VERSION_BLUETOOTH_CORE_6_2',
-}
-
-LMP_VERSION_NAMES = HCI_VERSION_NAMES
-
 # HCI Packet types
 HCI_COMMAND_PACKET          = 0x01
 HCI_ACL_DATA_PACKET         = 0x02
@@ -387,8 +366,8 @@ 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_LE_READ_ALL_REMOTE_FEATURES_COMPLETE_EVENT              = 0x2A
-HCI_LE_CIS_ESTABLISHED_V2_EVENT                             = 0x2B
+HCI_LE_CIS_ESTABLISHED_V2_EVENT                             = 0x2A
+HCI_LE_READ_ALL_REMOTE_FEATURES_COMPLETE_EVENT              = 0x2B
 HCI_LE_CS_READ_REMOTE_SUPPORTED_CAPABILITIES_COMPLETE_EVENT = 0x2C
 HCI_LE_CS_READ_REMOTE_FAE_TABLE_COMPLETE_EVENT              = 0x2D
 HCI_LE_CS_SECURITY_ENABLE_COMPLETE_EVENT                    = 0x2E
@@ -1742,6 +1721,15 @@ class CodecID(SpecableEnum):
     VENDOR_SPECIFIC = 0xFF
 
 
+# From Bluetooth Assigned Numbers, 2.10 PCM_Data_Format
+class PcmDataFormat(SpecableEnum):
+    NA = 0x00
+    ONES_COMPLEMENT = 0x01
+    TWOS_COMPLEMENT = 0x02
+    SIGN_MAGNITUDE = 0x03
+    UNSIGNED = 0x04
+
+
 @dataclasses.dataclass(frozen=True)
 class CodingFormat:
     codec_id: CodecID
@@ -1750,7 +1738,7 @@ class CodingFormat:
 
     @classmethod
     def parse_from_bytes(cls, data: bytes, offset: int) -> tuple[int, CodingFormat]:
-        (codec_id, company_id, vendor_specific_codec_id) = struct.unpack_from(
+        codec_id, company_id, vendor_specific_codec_id = struct.unpack_from(
             '<BHH', data, offset
         )
         return offset + 5, cls(
@@ -1769,6 +1757,61 @@ class CodingFormat:
         )
 
 
+@dataclasses.dataclass(frozen=True)
+class VoiceSetting:
+    class AirCodingFormat(enum.IntEnum):
+        CVSD = 0
+        U_LAW = 1
+        A_LAW = 2
+        TRANSPARENT_DATA = 3
+
+    class InputSampleSize(enum.IntEnum):
+        SIZE_8_BITS = 0
+        SIZE_16_BITS = 1
+
+    class InputDataFormat(enum.IntEnum):
+        ONES_COMPLEMENT = 0
+        TWOS_COMPLEMENT = 1
+        SIGN_AND_MAGNITUDE = 2
+        UNSIGNED = 3
+
+    class InputCodingFormat(enum.IntEnum):
+        LINEAR = 0
+        U_LAW = 1
+        A_LAW = 2
+        RESERVED = 3
+
+    air_coding_format: AirCodingFormat = AirCodingFormat.CVSD
+    linear_pcm_bit_position: int = 0
+    input_sample_size: InputSampleSize = InputSampleSize.SIZE_8_BITS
+    input_data_format: InputDataFormat = InputDataFormat.ONES_COMPLEMENT
+    input_coding_format: InputCodingFormat = InputCodingFormat.LINEAR
+
+    @classmethod
+    def from_int(cls, value: int) -> VoiceSetting:
+        air_coding_format = cls.AirCodingFormat(value & 0b11)
+        linear_pcm_bit_position = (value >> 2) & 0b111
+        input_sample_size = cls.InputSampleSize((value >> 5) & 0b1)
+        input_data_format = cls.InputDataFormat((value >> 6) & 0b11)
+        input_coding_format = cls.InputCodingFormat((value >> 8) & 0b11)
+        return cls(
+            air_coding_format=air_coding_format,
+            linear_pcm_bit_position=linear_pcm_bit_position,
+            input_sample_size=input_sample_size,
+            input_data_format=input_data_format,
+            input_coding_format=input_coding_format,
+        )
+
+    def __int__(self) -> int:
+        return (
+            self.air_coding_format
+            | (self.linear_pcm_bit_position << 2)
+            | (self.input_sample_size << 5)
+            | (self.input_data_format << 6)
+            | (self.input_coding_format << 8)
+        )
+
+
 # -----------------------------------------------------------------------------
 class HCI_Constant:
     @staticmethod
@@ -1860,44 +1903,46 @@ class HCI_Object:
                 field_type = field_type['parser']
 
         # Parse the field
-        if field_type == '*':
+        match field_type:
+            case '*':
                 # The rest of the bytes
                 field_value = data[offset:]
                 return (field_value, len(field_value))
-        if field_type == 'v':
+            case 'v':
                 # Variable-length bytes field, with 1-byte length at the beginning
                 field_length = data[offset]
                 offset += 1
                 field_value = data[offset : offset + field_length]
                 return (field_value, field_length + 1)
-        if field_type == 1:
+            case 1:
                 # 8-bit unsigned
                 return (data[offset], 1)
-        if field_type == -1:
+            case -1:
                 # 8-bit signed
                 return (struct.unpack_from('b', data, offset)[0], 1)
-        if field_type == 2:
+            case 2:
                 # 16-bit unsigned
                 return (struct.unpack_from('<H', data, offset)[0], 2)
-        if field_type == '>2':
+            case '>2':
                 # 16-bit unsigned big-endian
                 return (struct.unpack_from('>H', data, offset)[0], 2)
-        if field_type == -2:
+            case -2:
                 # 16-bit signed
                 return (struct.unpack_from('<h', data, offset)[0], 2)
-        if field_type == 3:
+            case 3:
                 # 24-bit unsigned
                 padded = data[offset : offset + 3] + bytes([0])
                 return (struct.unpack('<I', padded)[0], 3)
-        if field_type == 4:
+            case 4:
                 # 32-bit unsigned
                 return (struct.unpack_from('<I', data, offset)[0], 4)
-        if field_type == '>4':
+            case '>4':
                 # 32-bit unsigned big-endian
                 return (struct.unpack_from('>I', data, offset)[0], 4)
-        if isinstance(field_type, int) and 4 < field_type <= 256:
+            case int() if 4 < field_type <= 256:
                 # Byte array (from 5 up to 256 bytes)
                 return (data[offset : offset + field_type], field_type)
+
         if callable(field_type):
             new_offset, field_value = field_type(data, offset)
             return (field_value, new_offset - offset)
@@ -1954,61 +1999,59 @@ class HCI_Object:
 
         # Serialize the field
         if serializer:
-            field_bytes = serializer(field_value)
-        elif field_type == 1:
+            return serializer(field_value)
+        match field_type:
+            case 1:
                 # 8-bit unsigned
-            field_bytes = bytes([field_value])
-        elif field_type == -1:
+                return bytes([field_value])
+            case -1:
                 # 8-bit signed
-            field_bytes = struct.pack('b', field_value)
-        elif field_type == 2:
+                return struct.pack('b', field_value)
+            case 2:
                 # 16-bit unsigned
-            field_bytes = struct.pack('<H', field_value)
-        elif field_type == '>2':
+                return struct.pack('<H', field_value)
+            case '>2':
                 # 16-bit unsigned big-endian
-            field_bytes = struct.pack('>H', field_value)
-        elif field_type == -2:
+                return struct.pack('>H', field_value)
+            case -2:
                 # 16-bit signed
-            field_bytes = struct.pack('<h', field_value)
-        elif field_type == 3:
+                return struct.pack('<h', field_value)
+            case 3:
                 # 24-bit unsigned
-            field_bytes = struct.pack('<I', field_value)[0:3]
-        elif field_type == 4:
+                return struct.pack('<I', field_value)[0:3]
+            case 4:
                 # 32-bit unsigned
-            field_bytes = struct.pack('<I', field_value)
-        elif field_type == '>4':
+                return struct.pack('<I', field_value)
+            case '>4':
                 # 32-bit unsigned big-endian
-            field_bytes = struct.pack('>I', field_value)
-        elif field_type == '*':
+                return struct.pack('>I', field_value)
+            case '*':
                 if isinstance(field_value, int):
                     if 0 <= field_value <= 255:
-                    field_bytes = bytes([field_value])
+                        return bytes([field_value])
                     else:
                         raise InvalidArgumentError('value too large for *-typed field')
                 else:
-                field_bytes = bytes(field_value)
-        elif field_type == 'v':
+                    return bytes(field_value)
+            case 'v':
                 # Variable-length bytes field, with 1-byte length at the beginning
                 field_bytes = bytes(field_value)
                 field_length = len(field_bytes)
-            field_bytes = bytes([field_length]) + field_bytes
-        elif isinstance(field_value, (bytes, bytearray)) or hasattr(
-            field_value, '__bytes__'
-        ):
+                return bytes([field_length]) + field_bytes
+        if isinstance(field_value, (bytes, bytearray, SupportsBytes)):
             field_bytes = bytes(field_value)
             if isinstance(field_type, int) and 4 < field_type <= 256:
                 # Truncate or pad with zeros if the field is too long or too short
                 if len(field_bytes) < field_type:
-                    field_bytes += bytes(field_type - len(field_bytes))
+                    return field_bytes + bytes(field_type - len(field_bytes))
                 elif len(field_bytes) > field_type:
-                    field_bytes = field_bytes[:field_type]
-        else:
+                    return field_bytes[:field_type]
+            return field_bytes
+
         raise InvalidArgumentError(
             f"don't know how to serialize type {type(field_value)}"
         )
 
-        return field_bytes
-
     @staticmethod
     def dict_to_bytes(hci_object, object_fields):
         result = bytearray()
@@ -2029,7 +2072,7 @@ class HCI_Object:
                 )
                 continue
 
-            (field_name, field_type) = object_field
+            field_name, field_type = object_field
             result += HCI_Object.serialize_field(hci_object[field_name], field_type)
 
         return bytes(result)
@@ -2907,6 +2950,23 @@ class HCI_Read_Clock_Offset_Command(HCI_AsyncCommand):
     connection_handle: int = field(metadata=metadata(2))
 
 
+# -----------------------------------------------------------------------------
+@HCI_Command.command
+@dataclasses.dataclass
+class HCI_Accept_Synchronous_Connection_Request_Command(HCI_AsyncCommand):
+    '''
+    See Bluetooth spec @ 7.1.27 Accept Synchronous Connection Request Command
+    '''
+
+    bd_addr: Address = field(metadata=metadata(Address.parse_address))
+    transmit_bandwidth: int = field(metadata=metadata(4))
+    receive_bandwidth: int = field(metadata=metadata(4))
+    max_latency: int = field(metadata=metadata(2))
+    voice_setting: int = field(metadata=metadata(2))
+    retransmission_effort: int = field(metadata=metadata(1))
+    packet_type: int = field(metadata=metadata(2))
+
+
 # -----------------------------------------------------------------------------
 @HCI_Command.command
 @dataclasses.dataclass
@@ -3055,8 +3115,8 @@ class HCI_Enhanced_Setup_Synchronous_Connection_Command(HCI_AsyncCommand):
     output_coding_format: int = field(metadata=metadata(CodingFormat.parse_from_bytes))
     input_coded_data_size: int = field(metadata=metadata(2))
     output_coded_data_size: int = field(metadata=metadata(2))
-    input_pcm_data_format: int = field(metadata=metadata(1))
-    output_pcm_data_format: int = field(metadata=metadata(1))
+    input_pcm_data_format: int = field(metadata=PcmDataFormat.type_metadata(1))
+    output_pcm_data_format: int = field(metadata=PcmDataFormat.type_metadata(1))
     input_pcm_sample_payload_msb_position: int = field(metadata=metadata(1))
     output_pcm_sample_payload_msb_position: int = field(metadata=metadata(1))
     input_data_path: int = field(metadata=metadata(1))
@@ -3067,13 +3127,6 @@ class HCI_Enhanced_Setup_Synchronous_Connection_Command(HCI_AsyncCommand):
     packet_type: int = field(metadata=metadata(2))
     retransmission_effort: int = field(metadata=metadata(1))
 
-    class PcmDataFormat(SpecableEnum):
-        NA = 0x00
-        ONES_COMPLEMENT = 0x01
-        TWOS_COMPLEMENT = 0x02
-        SIGN_MAGNITUDE = 0x03
-        UNSIGNED = 0x04
-
     class DataPath(SpecableEnum):
         HCI = 0x00
         PCM = 0x01
@@ -3120,8 +3173,8 @@ class HCI_Enhanced_Accept_Synchronous_Connection_Request_Command(HCI_AsyncComman
     output_coding_format: int = field(metadata=metadata(CodingFormat.parse_from_bytes))
     input_coded_data_size: int = field(metadata=metadata(2))
     output_coded_data_size: int = field(metadata=metadata(2))
-    input_pcm_data_format: int = field(metadata=metadata(1))
-    output_pcm_data_format: int = field(metadata=metadata(1))
+    input_pcm_data_format: int = field(metadata=PcmDataFormat.type_metadata(1))
+    output_pcm_data_format: int = field(metadata=PcmDataFormat.type_metadata(1))
     input_pcm_sample_payload_msb_position: int = field(metadata=metadata(1))
     output_pcm_sample_payload_msb_position: int = field(metadata=metadata(1))
     input_data_path: int = field(metadata=metadata(1))
@@ -3965,6 +4018,23 @@ class HCI_Read_Local_OOB_Extended_Data_Command(
     '''
 
 
+# -----------------------------------------------------------------------------
+@HCI_SyncCommand.sync_command(HCI_StatusReturnParameters)
+@dataclasses.dataclass
+class HCI_Configure_Data_Path_Command(HCI_SyncCommand[HCI_StatusReturnParameters]):
+    '''
+    See Bluetooth spec @ 7.3.101 Configure Data Path Command
+    '''
+
+    class DataPathDirection(SpecableEnum):
+        INPUT = 0x00
+        OUTPUT = 0x01
+
+    data_path_direction: DataPathDirection = field(metadata=metadata(1))
+    data_path_id: int = field(metadata=metadata(1))
+    vendor_specific_config: bytes = field(metadata=metadata('*'))
+
+
 # -----------------------------------------------------------------------------
 @dataclasses.dataclass
 class HCI_Read_Local_Version_Information_ReturnParameters(HCI_StatusReturnParameters):
@@ -4736,7 +4806,7 @@ class HCI_LE_Clear_Resolving_List_Command(HCI_SyncCommand[HCI_StatusReturnParame
 # -----------------------------------------------------------------------------
 @dataclasses.dataclass
 class HCI_LE_Read_Resolving_List_Size_ReturnParameters(HCI_StatusReturnParameters):
-    resolving_list_size: bytes = field(metadata=metadata(1))
+    resolving_list_size: int = field(metadata=metadata(1))
 
 
 @HCI_SyncCommand.sync_command(HCI_LE_Read_Resolving_List_Size_ReturnParameters)
@@ -7355,7 +7425,7 @@ class HCI_Connection_Complete_Event(HCI_Event):
     status: int = field(metadata=metadata(STATUS_SPEC))
     connection_handle: int = field(metadata=metadata(2))
     bd_addr: Address = field(metadata=metadata(Address.parse_address))
-    link_type: int = field(metadata=LinkType.type_metadata(1))
+    link_type: LinkType = field(metadata=LinkType.type_metadata(1))
     encryption_enabled: int = field(metadata=metadata(1))
 
 
@@ -7751,12 +7821,6 @@ class HCI_Synchronous_Connection_Complete_Event(HCI_Event):
         SCO = 0x00
         ESCO = 0x02
 
-    class AirMode(SpecableEnum):
-        U_LAW_LOG = 0x00
-        A_LAW_LOG_AIR_MORE = 0x01
-        CVSD = 0x02
-        TRANSPARENT_DATA = 0x03
-
     status: int = field(metadata=metadata(STATUS_SPEC))
     connection_handle: int = field(metadata=metadata(2))
     bd_addr: Address = field(metadata=metadata(Address.parse_address))
@@ -7765,7 +7829,7 @@ class HCI_Synchronous_Connection_Complete_Event(HCI_Event):
     retransmission_window: int = field(metadata=metadata(1))
     rx_packet_length: int = field(metadata=metadata(2))
     tx_packet_length: int = field(metadata=metadata(2))
-    air_mode: int = field(metadata=AirMode.type_metadata(1))
+    air_mode: int = field(metadata=CodecID.type_metadata(1))
 
 
 # -----------------------------------------------------------------------------
@@ -7997,7 +8061,9 @@ class HCI_AclDataPacket(HCI_Packet):
         bc_flag = (h >> 14) & 3
         data = packet[5:]
         if len(data) != data_total_length:
-            raise InvalidPacketError('invalid packet length')
+            raise InvalidPacketError(
+                f'invalid packet length {len(data)} != {data_total_length}'
+            )
         return cls(
             connection_handle=connection_handle,
             pb_flag=pb_flag,
@@ -8030,10 +8096,16 @@ class HCI_SynchronousDataPacket(HCI_Packet):
     See Bluetooth spec @ 5.4.3 HCI SCO Data Packets
     '''
 
+    class Status(enum.IntEnum):
+        CORRECTLY_RECEIVED_DATA = 0b00
+        POSSIBLY_INVALID_DATA = 0b01
+        NO_DATA = 0b10
+        DATA_PARTIALLY_LOST = 0b11
+
     hci_packet_type = HCI_SYNCHRONOUS_DATA_PACKET
 
     connection_handle: int
-    packet_status: int
+    packet_status: Status
     data_total_length: int
     data: bytes
 
@@ -8042,7 +8114,7 @@ class HCI_SynchronousDataPacket(HCI_Packet):
         # Read the header
         h, data_total_length = struct.unpack_from('<HB', packet, 1)
         connection_handle = h & 0xFFF
-        packet_status = (h >> 12) & 0b11
+        packet_status = cls.Status((h >> 12) & 0b11)
         data = packet[4:]
         if len(data) != data_total_length:
             raise InvalidPacketError(
@@ -8066,7 +8138,7 @@ class HCI_SynchronousDataPacket(HCI_Packet):
         return (
             f'{color("SCO", "blue")}: '
             f'handle=0x{self.connection_handle:04x}, '
-            f'ps={self.packet_status}, '
+            f'ps={self.packet_status.name}, '
             f'data_total_length={self.data_total_length}, '
             f'data={self.data.hex()}'
         )
@@ -8094,8 +8166,8 @@ class HCI_IsoDataPacket(HCI_Packet):
     def __post_init__(self) -> None:
         self.ts_flag = self.time_stamp is not None
 
-    @staticmethod
-    def from_bytes(packet: bytes) -> HCI_IsoDataPacket:
+    @classmethod
+    def from_bytes(cls, packet: bytes) -> HCI_IsoDataPacket:
         time_stamp: int | None = None
         packet_sequence_number: int | None = None
         iso_sdu_length: int | None = None
@@ -8124,7 +8196,7 @@ class HCI_IsoDataPacket(HCI_Packet):
             pos += 4
 
         iso_sdu_fragment = packet[pos:]
-        return HCI_IsoDataPacket(
+        return cls(
             connection_handle=connection_handle,
             pb_flag=pb_flag,
             ts_flag=ts_flag,

bumble/hfp.py

@@ -26,7 +26,7 @@ import logging
 import re
 import traceback
 from collections.abc import Iterable
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import Any, ClassVar, Literal, overload
 
 from typing_extensions import Self
 
@@ -44,6 +44,7 @@ from bumble.hci import (
     CodecID,
     CodingFormat,
     HCI_Enhanced_Setup_Synchronous_Connection_Command,
+    PcmDataFormat,
 )
 
 # -----------------------------------------------------------------------------
@@ -68,6 +69,8 @@ class HfpProtocolError(ProtocolError):
 
 # -----------------------------------------------------------------------------
 class HfpProtocol:
+    MAX_BUFFER_SIZE: ClassVar[int] = 65536
+
     dlc: rfcomm.DLC
     buffer: str
     lines: collections.deque
@@ -84,10 +87,19 @@ class HfpProtocol:
     def feed(self, data: bytes | str) -> None:
         # Convert the data to a string if needed
         if isinstance(data, bytes):
-            data = data.decode('utf-8')
+            data = data.decode('utf-8', errors='replace')
 
         logger.debug(f'<<< Data received: {data}')
 
+        # Drop incoming data if it would overflow the buffer; keep existing
+        # partial packet state intact so a future clean packet can still parse.
+        if len(self.buffer) + len(data) > self.MAX_BUFFER_SIZE:
+            logger.warning(
+                'HFP buffer overflow (>%d bytes), dropping incoming data',
+                self.MAX_BUFFER_SIZE,
+            )
+            return
+
         # Add to the buffer and look for lines
         self.buffer += data
         while (separator := self.buffer.find('\r')) >= 0:
@@ -166,7 +178,7 @@ class AgFeature(enum.IntFlag):
     VOICE_RECOGNITION_TEXT = 0x2000
 
 
-class AudioCodec(enum.IntEnum):
+class AudioCodec(utils.OpenIntEnum):
     """
     Audio Codec IDs (normative).
 
@@ -178,7 +190,7 @@ class AudioCodec(enum.IntEnum):
     LC3_SWB = 0x03  # Support for LC3-SWB audio codec
 
 
-class HfIndicator(enum.IntEnum):
+class HfIndicator(utils.OpenIntEnum):
     """
     HF Indicators (normative).
 
@@ -207,7 +219,7 @@ class CallHoldOperation(enum.Enum):
     )
 
 
-class ResponseHoldStatus(enum.IntEnum):
+class ResponseHoldStatus(utils.OpenIntEnum):
     """
     Response Hold status (normative).
 
@@ -235,7 +247,7 @@ class AgIndicator(enum.Enum):
     BATTERY_CHARGE = 'battchg'
 
 
-class CallSetupAgIndicator(enum.IntEnum):
+class CallSetupAgIndicator(utils.OpenIntEnum):
     """
     Values for the Call Setup AG indicator (normative).
 
@@ -248,7 +260,7 @@ class CallSetupAgIndicator(enum.IntEnum):
     REMOTE_ALERTED = 3  # Remote party alerted in an outgoing call
 
 
-class CallHeldAgIndicator(enum.IntEnum):
+class CallHeldAgIndicator(utils.OpenIntEnum):
     """
     Values for the Call Held AG indicator (normative).
 
@@ -262,7 +274,7 @@ class CallHeldAgIndicator(enum.IntEnum):
     CALL_ON_HOLD_NO_ACTIVE_CALL = 2  # Call on hold, no active call
 
 
-class CallInfoDirection(enum.IntEnum):
+class CallInfoDirection(utils.OpenIntEnum):
     """
     Call Info direction (normative).
 
@@ -273,7 +285,7 @@ class CallInfoDirection(enum.IntEnum):
     MOBILE_TERMINATED_CALL = 1
 
 
-class CallInfoStatus(enum.IntEnum):
+class CallInfoStatus(utils.OpenIntEnum):
     """
     Call Info status (normative).
 
@@ -288,7 +300,7 @@ class CallInfoStatus(enum.IntEnum):
     WAITING = 5
 
 
-class CallInfoMode(enum.IntEnum):
+class CallInfoMode(utils.OpenIntEnum):
     """
     Call Info mode (normative).
 
@@ -301,7 +313,7 @@ class CallInfoMode(enum.IntEnum):
     UNKNOWN = 9
 
 
-class CallInfoMultiParty(enum.IntEnum):
+class CallInfoMultiParty(utils.OpenIntEnum):
     """
     Call Info Multi-Party state (normative).
 
@@ -388,7 +400,7 @@ class CallLineIdentification:
         )
 
 
-class VoiceRecognitionState(enum.IntEnum):
+class VoiceRecognitionState(utils.OpenIntEnum):
     """
     vrec values provided in AT+BVRA command.
 
@@ -401,7 +413,7 @@ class VoiceRecognitionState(enum.IntEnum):
     ENHANCED_READY = 2
 
 
-class CmeError(enum.IntEnum):
+class CmeError(utils.OpenIntEnum):
     """
     CME ERROR codes (partial listed).
 
@@ -420,61 +432,6 @@ class CmeError(enum.IntEnum):
 # Hands-Free Control Interoperability Requirements
 # -----------------------------------------------------------------------------
 
-# Response codes.
-RESPONSE_CODES = {
-    "+APLSIRI",
-    "+BAC",
-    "+BCC",
-    "+BCS",
-    "+BIA",
-    "+BIEV",
-    "+BIND",
-    "+BINP",
-    "+BLDN",
-    "+BRSF",
-    "+BTRH",
-    "+BVRA",
-    "+CCWA",
-    "+CHLD",
-    "+CHUP",
-    "+CIND",
-    "+CLCC",
-    "+CLIP",
-    "+CMEE",
-    "+CMER",
-    "+CNUM",
-    "+COPS",
-    "+IPHONEACCEV",
-    "+NREC",
-    "+VGM",
-    "+VGS",
-    "+VTS",
-    "+XAPL",
-    "A",
-    "D",
-}
-
-# Unsolicited responses and statuses.
-UNSOLICITED_CODES = {
-    "+APLSIRI",
-    "+BCS",
-    "+BIND",
-    "+BSIR",
-    "+BTRH",
-    "+BVRA",
-    "+CCWA",
-    "+CIEV",
-    "+CLIP",
-    "+VGM",
-    "+VGS",
-    "BLACKLISTED",
-    "BUSY",
-    "DELAYED",
-    "NO ANSWER",
-    "NO CARRIER",
-    "RING",
-}
-
 # Status codes
 STATUS_CODES = {
     "+CME ERROR",
@@ -727,12 +684,9 @@ class HfProtocol(utils.EventEmitter):
 
     dlc: rfcomm.DLC
     command_lock: asyncio.Lock
-    if TYPE_CHECKING:
+    pending_command: str | None = None
     response_queue: asyncio.Queue[AtResponse]
     unsolicited_queue: asyncio.Queue[AtResponse | None]
-    else:
-        response_queue: asyncio.Queue
-        unsolicited_queue: asyncio.Queue
     read_buffer: bytearray
     active_codec: AudioCodec
 
@@ -805,16 +759,39 @@ class HfProtocol(utils.EventEmitter):
             self.read_buffer = self.read_buffer[trailer + 2 :]
 
             # Forward the received code to the correct queue.
-            if self.command_lock.locked() and (
-                response.code in STATUS_CODES or response.code in RESPONSE_CODES
+            if self.pending_command and (
+                response.code in STATUS_CODES or response.code in self.pending_command
             ):
                 self.response_queue.put_nowait(response)
-            elif response.code in UNSOLICITED_CODES:
-                self.unsolicited_queue.put_nowait(response)
             else:
-                logger.warning(
-                    f"dropping unexpected response with code '{response.code}'"
-                )
+                self.unsolicited_queue.put_nowait(response)
+
+    @overload
+    async def execute_command(
+        self,
+        cmd: str,
+        timeout: float = 1.0,
+        *,
+        response_type: Literal[AtResponseType.NONE] = AtResponseType.NONE,
+    ) -> None: ...
+
+    @overload
+    async def execute_command(
+        self,
+        cmd: str,
+        timeout: float = 1.0,
+        *,
+        response_type: Literal[AtResponseType.SINGLE],
+    ) -> AtResponse: ...
+
+    @overload
+    async def execute_command(
+        self,
+        cmd: str,
+        timeout: float = 1.0,
+        *,
+        response_type: Literal[AtResponseType.MULTIPLE],
+    ) -> list[AtResponse]: ...
 
     async def execute_command(
         self,
@@ -835,7 +812,9 @@ class HfProtocol(utils.EventEmitter):
             asyncio.TimeoutError: the status is not received after a timeout (default 1 second).
             ProtocolError: the status is not OK.
         """
+        try:
             async with self.command_lock:
+                self.pending_command = cmd
                 logger.debug(f">>> {cmd}")
                 self.dlc.write(cmd + '\r')
                 responses: list[AtResponse] = []
@@ -845,7 +824,10 @@ class HfProtocol(utils.EventEmitter):
                         self.response_queue.get(), timeout=timeout
                     )
                     if result.code == 'OK':
-                    if response_type == AtResponseType.SINGLE and len(responses) != 1:
+                        if (
+                            response_type == AtResponseType.SINGLE
+                            and len(responses) != 1
+                        ):
                             raise HfpProtocolError("NO ANSWER")
 
                         if response_type == AtResponseType.MULTIPLE:
@@ -856,6 +838,8 @@ class HfProtocol(utils.EventEmitter):
                     if result.code in STATUS_CODES:
                         raise HfpProtocolError(result.code)
                     responses.append(result)
+        finally:
+            self.pending_command = None
 
     async def initiate_slc(self):
         """4.2.1 Service Level Connection Initialization."""
@@ -1067,7 +1051,6 @@ class HfProtocol(utils.EventEmitter):
         responses = await self.execute_command(
             "AT+CLCC", response_type=AtResponseType.MULTIPLE
         )
-        assert isinstance(responses, list)
 
         calls = []
         for response in responses:
@@ -1624,7 +1607,7 @@ class AgProtocol(utils.EventEmitter):
 # -----------------------------------------------------------------------------
 
 
-class ProfileVersion(enum.IntEnum):
+class ProfileVersion(utils.OpenIntEnum):
     """
     Profile version (normative).
 
@@ -1972,12 +1955,8 @@ class EscoParameters:
     output_coding_format: CodingFormat = CodingFormat(CodecID.LINEAR_PCM)
     input_coded_data_size: int = 16
     output_coded_data_size: int = 16
-    input_pcm_data_format: (
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.PcmDataFormat
-    ) = HCI_Enhanced_Setup_Synchronous_Connection_Command.PcmDataFormat.TWOS_COMPLEMENT
-    output_pcm_data_format: (
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.PcmDataFormat
-    ) = HCI_Enhanced_Setup_Synchronous_Connection_Command.PcmDataFormat.TWOS_COMPLEMENT
+    input_pcm_data_format: PcmDataFormat = PcmDataFormat.TWOS_COMPLEMENT
+    output_pcm_data_format: PcmDataFormat = PcmDataFormat.TWOS_COMPLEMENT
     input_pcm_sample_payload_msb_position: int = 0
     output_pcm_sample_payload_msb_position: int = 0
     input_data_path: HCI_Enhanced_Setup_Synchronous_Connection_Command.DataPath = (
@@ -2076,6 +2055,7 @@ _ESCO_PARAMETERS_MSBC_T1 = EscoParameters(
     max_latency=0x0008,
     packet_type=(
         HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.EV3
+        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV3
         | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV3
         | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV5
         | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV5
@@ -2091,7 +2071,6 @@ _ESCO_PARAMETERS_MSBC_T2 = EscoParameters(
     max_latency=0x000D,
     packet_type=(
         HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV3
         | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV3
         | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV5
         | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV5

bumble/host.py

@@ -22,7 +22,7 @@ import collections
 import dataclasses
 import logging
 from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING, Any, TypeVar, cast, overload
+from typing import TYPE_CHECKING, Any, TypeVar, overload
 
 from bumble import drivers, hci, utils
 from bumble.colors import color
@@ -247,6 +247,7 @@ class Host(utils.EventEmitter):
     bis_links: dict[int, IsoLink]
     sco_links: dict[int, ScoLink]
     bigs: dict[int, set[int]]
+    link_ts_flags: dict[int, int]
     acl_packet_queue: DataPacketQueue | None = None
     le_acl_packet_queue: DataPacketQueue | None = None
     iso_packet_queue: DataPacketQueue | None = None
@@ -269,6 +270,7 @@ class Host(utils.EventEmitter):
         self.bis_links = {}  # BIS links, by connection handle
         self.sco_links = {}  # SCO links, by connection handle
         self.bigs = {}  # BIG Handle to BIS Handles
+        self.link_ts_flags = {}  # TS_Flag for ISO links, by handle
         self.pending_command: hci.HCI_SyncCommand | hci.HCI_AsyncCommand | None = None
         self.pending_response: (
             asyncio.Future[
@@ -486,6 +488,7 @@ class Host(utils.EventEmitter):
                     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_SYNC_ESTABLISHED_V2_EVENT,
                     hci.HCI_LE_PERIODIC_ADVERTISING_REPORT_EVENT,
                     hci.HCI_LE_PERIODIC_ADVERTISING_SYNC_LOST_EVENT,
                     hci.HCI_LE_SCAN_TIMEOUT_EVENT,
@@ -686,16 +689,16 @@ class Host(utils.EventEmitter):
                 self.pending_response, timeout=response_timeout
             )
             return response
+        except asyncio.TimeoutError:
+            raise
         except Exception:
             logger.exception(color("!!! Exception while sending command:", "red"))
             raise
         finally:
             self.pending_command = None
             self.pending_response = None
-            if (
-                response is not None
-                and response.num_hci_command_packets
-                and self.command_semaphore.locked()
+            if response is None or (
+                response.num_hci_command_packets and self.command_semaphore.locked()
             ):
                 self.command_semaphore.release()
 
@@ -866,7 +869,7 @@ class Host(utils.EventEmitter):
         self.send_hci_packet(
             hci.HCI_SynchronousDataPacket(
                 connection_handle=connection_handle,
-                packet_status=0,
+                packet_status=hci.HCI_SynchronousDataPacket.Status.CORRECTLY_RECEIVED_DATA,
                 data_total_length=len(sdu),
                 data=sdu,
             )
@@ -1002,17 +1005,18 @@ class Host(utils.EventEmitter):
             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.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:
+        match packet:
+            case hci.HCI_Command():
+                self.on_hci_command_packet(packet)
+            case hci.HCI_Event():
+                self.on_hci_event_packet(packet)
+            case hci.HCI_AclDataPacket():
+                self.on_hci_acl_data_packet(packet)
+            case hci.HCI_SynchronousDataPacket():
+                self.on_hci_sco_data_packet(packet)
+            case hci.HCI_IsoDataPacket():
+                self.on_hci_iso_data_packet(packet)
+            case _:
                 logger.warning(f'!!! unknown packet type {packet.hci_packet_type}')
 
     def on_hci_command_packet(self, command: hci.HCI_Command) -> None:
@@ -1027,6 +1031,82 @@ class Host(utils.EventEmitter):
         # Look for the connection to which this data belongs
         if connection := self.connections.get(packet.connection_handle):
             connection.on_hci_acl_data_packet(packet)
+            return
+
+        # WORKAROUND: Some controllers (e.g. Intel BE200) send ISO data wrapped in ACL packets
+        # using the CIS handle.
+        is_cis = packet.connection_handle in self.cis_links
+        is_bis = packet.connection_handle in self.bis_links
+
+        if is_cis or is_bis:
+            logger.debug(
+                f"Received ISO data wrapped in ACL packet for handle 0x{packet.connection_handle:04X}"
+            )
+            payload = packet.data
+
+            ts_flag = self.link_ts_flags.get(packet.connection_handle)
+            if ts_flag is None:
+                # Learn TS flag from the first packet on this link
+                if is_bis:
+                    # BIS packets always have Timestamp according to spec
+                    ts_flag = 1
+                elif len(payload) < 8:
+                    # Too short to have 8-byte header (TS), must be No TS
+                    ts_flag = 0
+                else:
+                    psn_no_ts = int.from_bytes(payload[0:2], 'little')
+                    psn_has_ts = int.from_bytes(payload[4:6], 'little')
+                    if psn_has_ts == 0:
+                        ts_flag = 1
+                    elif psn_no_ts == 0:
+                        ts_flag = 0
+                    else:
+                        # Fallback heuristic
+                        ts_flag = 1 if psn_has_ts < psn_no_ts else 0
+                self.link_ts_flags[packet.connection_handle] = ts_flag
+                logger.info(
+                    f"Learned TS_Flag = {ts_flag} for handle 0x{packet.connection_handle:04X}"
+                )
+
+            if ts_flag:
+                header_size = 8
+                sdu_length_offset = 6
+            else:
+                header_size = 4
+                sdu_length_offset = 2
+
+            pb_flag = 0b10
+            if len(payload) >= header_size:
+                sdu_length = int.from_bytes(
+                    payload[sdu_length_offset : sdu_length_offset + 2], 'little'
+                )
+                if sdu_length == len(payload) - header_size:
+                    pb_flag = 0b10  # Complete SDU
+                else:
+                    pb_flag = 0b00  # First fragment
+            else:
+                pb_flag = 0b01  # Continuation
+                ts_flag = 0
+
+            # Reconstruct the raw ISO packet (excluding packet indicator 0x05)
+            pdu_info = packet.connection_handle | (pb_flag << 12) | (ts_flag << 14)
+            header = bytes(
+                [
+                    pdu_info & 0xFF,
+                    (pdu_info >> 8) & 0xFF,
+                    len(payload) & 0xFF,
+                    (len(payload) >> 8) & 0xFF,
+                ]
+            )
+            raw_iso_packet = header + payload
+
+            try:
+                iso_packet = hci.HCI_IsoDataPacket.from_bytes(
+                    bytes([hci.HCI_ISO_DATA_PACKET]) + raw_iso_packet
+                )
+                self.on_hci_iso_data_packet(iso_packet)
+            except Exception as e:
+                logger.warning(f"Failed to reconstruct ISO packet from ACL: {e}")
 
     def on_hci_sco_data_packet(self, packet: hci.HCI_SynchronousDataPacket) -> None:
         # Experimental
@@ -1177,11 +1257,28 @@ class Host(utils.EventEmitter):
     def on_hci_connection_complete_event(
         self, event: hci.HCI_Connection_Complete_Event
     ):
+        if event.link_type == hci.HCI_Connection_Complete_Event.LinkType.SCO:
+            # Pass this on to the synchronous connection handler
+            forwarded_event = hci.HCI_Synchronous_Connection_Complete_Event(
+                status=event.status,
+                connection_handle=event.connection_handle,
+                bd_addr=event.bd_addr,
+                link_type=event.link_type,
+                transmission_interval=0,
+                retransmission_window=0,
+                rx_packet_length=0,
+                tx_packet_length=0,
+                air_mode=0,
+            )
+            self.on_hci_synchronous_connection_complete_event(forwarded_event)
+            return
+
         if event.status == hci.HCI_SUCCESS:
             # Create/update the connection
             logger.debug(
-                f'### BR/EDR CONNECTION: [0x{event.connection_handle:04X}] '
-                f'{event.bd_addr}'
+                f'### BR/EDR ACL CONNECTION: [0x{event.connection_handle:04X}] '
+                f'{event.bd_addr} '
+                f'{event.link_type.name}'
             )
 
             connection = self.connections.get(event.connection_handle)
@@ -1233,6 +1330,7 @@ class Host(utils.EventEmitter):
             self.emit('disconnection', handle, event.reason)
 
             # Remove the handle reference
+            self.link_ts_flags.pop(handle, None)
             _ = (
                 self.connections.pop(handle, 0)
                 or self.cis_links.pop(handle, 0)
@@ -1353,6 +1451,20 @@ class Host(utils.EventEmitter):
             event.advertiser_clock_accuracy,
         )
 
+    def on_hci_le_periodic_advertising_sync_established_v2_event(
+        self, event: hci.HCI_LE_Periodic_Advertising_Sync_Established_V2_Event
+    ):
+        self.emit(
+            'periodic_advertising_sync_establishment',
+            event.status,
+            event.sync_handle,
+            event.advertising_sid,
+            event.advertiser_address,
+            event.advertiser_phy,
+            event.periodic_advertising_interval,
+            event.advertiser_clock_accuracy,
+        )
+
     def on_hci_le_periodic_advertising_sync_lost_event(
         self, event: hci.HCI_LE_Periodic_Advertising_Sync_Lost_Event
     ):
@@ -1581,6 +1693,9 @@ class Host(utils.EventEmitter):
                 event.bd_addr,
                 event.connection_handle,
                 event.link_type,
+                event.rx_packet_length,
+                event.tx_packet_length,
+                event.air_mode,
             )
         else:
             logger.debug(f'### SCO CONNECTION FAILED: {event.status}')
@@ -1659,6 +1774,19 @@ class Host(utils.EventEmitter):
                 'connection_encryption_failure', event.connection_handle, event.status
             )
 
+    def on_hci_read_remote_supported_features_complete_event(
+        self, event: hci.HCI_Read_Remote_Supported_Features_Complete_Event
+    ) -> None:
+        # Notify the client
+        self.emit(
+            'classic_remote_features',
+            event.connection_handle,
+            event.status,
+            int.from_bytes(event.lmp_features, 'little'),
+            0,  # page number
+            0,  # max page number
+        )
+
     def on_hci_encryption_change_v2_event(
         self, event: hci.HCI_Encryption_Change_V2_Event
     ):
@@ -1815,6 +1943,18 @@ class Host(utils.EventEmitter):
                 rssi,
             )
 
+    def on_hci_read_remote_extended_features_complete_event(
+        self, event: hci.HCI_Read_Remote_Extended_Features_Complete_Event
+    ):
+        self.emit(
+            'classic_remote_features',
+            event.connection_handle,
+            event.status,
+            int.from_bytes(event.extended_lmp_features, 'little'),
+            event.page_number,
+            event.maximum_page_number,
+        )
+
     def on_hci_extended_inquiry_result_event(
         self, event: hci.HCI_Extended_Inquiry_Result_Event
     ):

bumble/keys.py

@@ -27,6 +27,7 @@ import dataclasses
 import json
 import logging
 import os
+import pathlib
 from typing import TYPE_CHECKING, Any
 
 from typing_extensions import Self
@@ -248,29 +249,26 @@ class JsonKeyStore(KeyStore):
     DEFAULT_NAMESPACE = '__DEFAULT__'
     DEFAULT_BASE_NAME = "keys"
 
-    def __init__(self, namespace, filename=None):
-        self.namespace = namespace if namespace is not None else self.DEFAULT_NAMESPACE
+    def __init__(
+        self, namespace: str | None = None, filename: str | None = None
+    ) -> None:
+        self.namespace = namespace or self.DEFAULT_NAMESPACE
 
-        if filename is None:
-            # Use a default for the current user
-
-            # Import here because this may not exist on all platforms
-            # pylint: disable=import-outside-toplevel
-            import appdirs
-
-            self.directory_name = os.path.join(
-                appdirs.user_data_dir(self.APP_NAME, self.APP_AUTHOR), self.KEYS_DIR
-            )
-            base_name = self.DEFAULT_BASE_NAME if namespace is None else self.namespace
-            json_filename = (
-                f'{base_name}.json'.lower().replace(':', '-').replace('/p', '-p')
-            )
-            self.filename = os.path.join(self.directory_name, json_filename)
+        if filename:
+            self.filename = pathlib.Path(filename).resolve()
+            self.directory_name = self.filename.parent
         else:
-            self.filename = filename
-            self.directory_name = os.path.dirname(os.path.abspath(self.filename))
+            import platformdirs  # Deferred import
 
-        logger.debug(f'JSON keystore: {self.filename}')
+            base_dir = platformdirs.user_data_path(self.APP_NAME, self.APP_AUTHOR)
+            self.directory_name = base_dir / self.KEYS_DIR
+
+            base_name = self.namespace if namespace else self.DEFAULT_BASE_NAME
+            safe_name = base_name.lower().replace(':', '-').replace('/', '-')
+
+            self.filename = self.directory_name / f"{safe_name}.json"
+
+        logger.debug('JSON keystore: %s', self.filename)
 
     @classmethod
     def from_device(
@@ -293,7 +291,9 @@ class JsonKeyStore(KeyStore):
 
         return cls(namespace, filename)
 
-    async def load(self):
+    async def load(
+        self,
+    ) -> tuple[dict[str, dict[str, dict[str, Any]]], dict[str, dict[str, Any]]]:
         # Try to open the file, without failing. If the file does not exist, it
         # will be created upon saving.
         try:
@@ -312,17 +312,17 @@ class JsonKeyStore(KeyStore):
             return next(iter(db.items()))
 
         # Finally, just create an empty key map for the namespace
-        key_map = {}
+        key_map: dict[str, dict[str, Any]] = {}
         db[self.namespace] = key_map
         return (db, key_map)
 
-    async def save(self, db):
+    async def save(self, db: dict[str, dict[str, dict[str, Any]]]) -> None:
         # Create the directory if it doesn't exist
-        if not os.path.exists(self.directory_name):
-            os.makedirs(self.directory_name, exist_ok=True)
+        if not self.directory_name.exists():
+            self.directory_name.mkdir(parents=True, exist_ok=True)
 
         # Save to a temporary file
-        temp_filename = self.filename + '.tmp'
+        temp_filename = self.filename.with_name(self.filename.name + ".tmp")
         with open(temp_filename, 'w', encoding='utf-8') as output:
             json.dump(db, output, sort_keys=True, indent=4)
 
@@ -334,16 +334,16 @@ class JsonKeyStore(KeyStore):
         del key_map[name]
         await self.save(db)
 
-    async def update(self, name, keys):
+    async def update(self, name: str, keys: PairingKeys) -> None:
         db, key_map = await self.load()
         key_map.setdefault(name, {}).update(keys.to_dict())
         await self.save(db)
 
-    async def get_all(self):
+    async def get_all(self) -> list[tuple[str, PairingKeys]]:
         _, key_map = await self.load()
         return [(name, PairingKeys.from_dict(keys)) for (name, keys) in key_map.items()]
 
-    async def delete_all(self):
+    async def delete_all(self) -> None:
         db, key_map = await self.load()
         key_map.clear()
         await self.save(db)

bumble/ll.py

@@ -198,3 +198,24 @@ class CisTerminateInd(ControlPdu):
     cig_id: int
     cis_id: int
     error_code: int
+
+
+@dataclasses.dataclass
+class FeatureReq(ControlPdu):
+    opcode = ControlPdu.Opcode.LL_FEATURE_REQ
+
+    feature_set: bytes
+
+
+@dataclasses.dataclass
+class FeatureRsp(ControlPdu):
+    opcode = ControlPdu.Opcode.LL_FEATURE_RSP
+
+    feature_set: bytes
+
+
+@dataclasses.dataclass
+class PeripheralFeatureReq(ControlPdu):
+    opcode = ControlPdu.Opcode.LL_PERIPHERAL_FEATURE_REQ
+
+    feature_set: bytes

bumble/lmp.py

@@ -322,3 +322,38 @@ class LmpNameRes(Packet):
     name_offset: int = field(metadata=hci.metadata(2))
     name_length: int = field(metadata=hci.metadata(3))
     name_fregment: bytes = field(metadata=hci.metadata('*'))
+
+
+@Packet.subclass
+@dataclass
+class LmpFeaturesReq(Packet):
+    opcode = Opcode.LMP_FEATURES_REQ
+
+    features: bytes = field(metadata=hci.metadata(8))
+
+
+@Packet.subclass
+@dataclass
+class LmpFeaturesRes(Packet):
+    opcode = Opcode.LMP_FEATURES_RES
+
+    features: bytes = field(metadata=hci.metadata(8))
+
+
+@Packet.subclass
+@dataclass
+class LmpFeaturesReqExt(Packet):
+    opcode = Opcode.LMP_FEATURES_REQ_EXT
+
+    features_page: int = field(metadata=hci.metadata(1))
+    features: bytes = field(metadata=hci.metadata(8))
+
+
+@Packet.subclass
+@dataclass
+class LmpFeaturesResExt(Packet):
+    opcode = Opcode.LMP_FEATURES_RES_EXT
+
+    features_page: int = field(metadata=hci.metadata(1))
+    max_features_page: int = field(metadata=hci.metadata(1))
+    features: bytes = field(metadata=hci.metadata(8))

bumble/pairing.py

@@ -21,18 +21,9 @@ import enum
 import secrets
 from dataclasses import dataclass
 
-from bumble import hci
+from bumble import hci, smp
 from bumble.core import AdvertisingData, LeRole
 from bumble.smp import (
-    SMP_DISPLAY_ONLY_IO_CAPABILITY,
-    SMP_DISPLAY_YES_NO_IO_CAPABILITY,
-    SMP_ENC_KEY_DISTRIBUTION_FLAG,
-    SMP_ID_KEY_DISTRIBUTION_FLAG,
-    SMP_KEYBOARD_DISPLAY_IO_CAPABILITY,
-    SMP_KEYBOARD_ONLY_IO_CAPABILITY,
-    SMP_LINK_KEY_DISTRIBUTION_FLAG,
-    SMP_NO_INPUT_NO_OUTPUT_IO_CAPABILITY,
-    SMP_SIGN_KEY_DISTRIBUTION_FLAG,
     OobContext,
     OobLegacyContext,
     OobSharedData,
@@ -96,11 +87,11 @@ class PairingDelegate:
     # These are defined abstractly, and can be mapped to specific Classic pairing
     # and/or SMP constants.
     class IoCapability(enum.IntEnum):
-        NO_OUTPUT_NO_INPUT = SMP_NO_INPUT_NO_OUTPUT_IO_CAPABILITY
-        KEYBOARD_INPUT_ONLY = SMP_KEYBOARD_ONLY_IO_CAPABILITY
-        DISPLAY_OUTPUT_ONLY = SMP_DISPLAY_ONLY_IO_CAPABILITY
-        DISPLAY_OUTPUT_AND_YES_NO_INPUT = SMP_DISPLAY_YES_NO_IO_CAPABILITY
-        DISPLAY_OUTPUT_AND_KEYBOARD_INPUT = SMP_KEYBOARD_DISPLAY_IO_CAPABILITY
+        NO_OUTPUT_NO_INPUT = smp.IoCapability.NO_INPUT_NO_OUTPUT
+        KEYBOARD_INPUT_ONLY = smp.IoCapability.KEYBOARD_ONLY
+        DISPLAY_OUTPUT_ONLY = smp.IoCapability.DISPLAY_ONLY
+        DISPLAY_OUTPUT_AND_YES_NO_INPUT = smp.IoCapability.DISPLAY_YES_NO
+        DISPLAY_OUTPUT_AND_KEYBOARD_INPUT = smp.IoCapability.KEYBOARD_DISPLAY
 
     # Direct names for backward compatibility.
     NO_OUTPUT_NO_INPUT = IoCapability.NO_OUTPUT_NO_INPUT
@@ -111,10 +102,10 @@ class PairingDelegate:
 
     # Key Distribution [LE only]
     class KeyDistribution(enum.IntFlag):
-        DISTRIBUTE_ENCRYPTION_KEY = SMP_ENC_KEY_DISTRIBUTION_FLAG
-        DISTRIBUTE_IDENTITY_KEY = SMP_ID_KEY_DISTRIBUTION_FLAG
-        DISTRIBUTE_SIGNING_KEY = SMP_SIGN_KEY_DISTRIBUTION_FLAG
-        DISTRIBUTE_LINK_KEY = SMP_LINK_KEY_DISTRIBUTION_FLAG
+        DISTRIBUTE_ENCRYPTION_KEY = smp.KeyDistribution.ENC_KEY
+        DISTRIBUTE_IDENTITY_KEY = smp.KeyDistribution.ID_KEY
+        DISTRIBUTE_SIGNING_KEY = smp.KeyDistribution.SIGN_KEY
+        DISTRIBUTE_LINK_KEY = smp.KeyDistribution.LINK_KEY
 
     DEFAULT_KEY_DISTRIBUTION: KeyDistribution = (
         KeyDistribution.DISTRIBUTE_ENCRYPTION_KEY

bumble/profiles/ascs.py

@@ -664,7 +664,8 @@ class AudioStreamControlService(gatt.TemplateService):
         responses = []
         logger.debug(f'*** ASCS Write {operation} ***')
 
-        if isinstance(operation, ASE_Config_Codec):
+        match operation:
+            case ASE_Config_Codec():
                 for ase_id, *args in zip(
                     operation.ase_id,
                     operation.target_latency,
@@ -673,7 +674,7 @@ class AudioStreamControlService(gatt.TemplateService):
                     operation.codec_specific_configuration,
                 ):
                     responses.append(self.on_operation(operation.op_code, ase_id, args))
-        elif isinstance(operation, ASE_Config_QOS):
+            case ASE_Config_QOS():
                 for ase_id, *args in zip(
                     operation.ase_id,
                     operation.cig_id,
@@ -687,20 +688,17 @@ class AudioStreamControlService(gatt.TemplateService):
                     operation.presentation_delay,
                 ):
                     responses.append(self.on_operation(operation.op_code, ase_id, args))
-        elif isinstance(operation, (ASE_Enable, ASE_Update_Metadata)):
+            case ASE_Enable() | ASE_Update_Metadata():
                 for ase_id, *args in zip(
                     operation.ase_id,
                     operation.metadata,
                 ):
                     responses.append(self.on_operation(operation.op_code, ase_id, args))
-        elif isinstance(
-            operation,
-            (
-                ASE_Receiver_Start_Ready,
-                ASE_Disable,
-                ASE_Receiver_Stop_Ready,
-                ASE_Release,
-            ),
+            case (
+                ASE_Receiver_Start_Ready()
+                | ASE_Disable()
+                | ASE_Receiver_Stop_Ready()
+                | ASE_Release()
             ):
                 for ase_id in operation.ase_id:
                     responses.append(self.on_operation(operation.op_code, ase_id, []))

bumble/profiles/bap.py

@@ -333,16 +333,17 @@ class CodecSpecificCapabilities:
             value = int.from_bytes(data[offset : offset + length - 1], 'little')
             offset += length - 1
 
-            if type == CodecSpecificCapabilities.Type.SAMPLING_FREQUENCY:
+            match type:
+                case CodecSpecificCapabilities.Type.SAMPLING_FREQUENCY:
                     supported_sampling_frequencies = SupportedSamplingFrequency(value)
-            elif type == CodecSpecificCapabilities.Type.FRAME_DURATION:
+                case CodecSpecificCapabilities.Type.FRAME_DURATION:
                     supported_frame_durations = SupportedFrameDuration(value)
-            elif type == CodecSpecificCapabilities.Type.AUDIO_CHANNEL_COUNT:
+                case CodecSpecificCapabilities.Type.AUDIO_CHANNEL_COUNT:
                     supported_audio_channel_count = bits_to_channel_counts(value)
-            elif type == CodecSpecificCapabilities.Type.OCTETS_PER_FRAME:
+                case CodecSpecificCapabilities.Type.OCTETS_PER_FRAME:
                     min_octets_per_sample = value & 0xFFFF
                     max_octets_per_sample = value >> 16
-            elif type == CodecSpecificCapabilities.Type.CODEC_FRAMES_PER_SDU:
+                case CodecSpecificCapabilities.Type.CODEC_FRAMES_PER_SDU:
                     supported_max_codec_frames_per_sdu = value
 
         # It is expected here that if some fields are missing, an error should be raised.

bumble/profiles/gap.py

@@ -55,13 +55,14 @@ class GenericAccessService(TemplateService):
     def __init__(
         self, device_name: str, appearance: Appearance | tuple[int, int] | int = 0
     ):
-        if isinstance(appearance, int):
+        match appearance:
+            case int():
                 appearance_int = appearance
-        elif isinstance(appearance, tuple):
+            case tuple():
                 appearance_int = (appearance[0] << 6) | appearance[1]
-        elif isinstance(appearance, Appearance):
+            case Appearance():
                 appearance_int = int(appearance)
-        else:
+            case _:
                 raise TypeError()
 
         self.device_name_characteristic = Characteristic(

bumble/rfcomm.py

@@ -110,7 +110,7 @@ RFCOMM_DEFAULT_L2CAP_MTU        = 2048
 RFCOMM_DEFAULT_INITIAL_CREDITS  = 7
 RFCOMM_DEFAULT_MAX_CREDITS      = 32
 RFCOMM_DEFAULT_CREDIT_THRESHOLD = RFCOMM_DEFAULT_MAX_CREDITS // 2
-RFCOMM_DEFAULT_MAX_FRAME_SIZE   = 2000
+RFCOMM_DEFAULT_MAX_FRAME_SIZE   = 1000
 
 RFCOMM_DYNAMIC_CHANNEL_NUMBER_START = 1
 RFCOMM_DYNAMIC_CHANNEL_NUMBER_END   = 30

bumble/smp.py

@@ -31,14 +31,14 @@ from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, ClassVar, TypeVar, cast
 
-from bumble import crypto, utils
+from bumble import crypto, hci, utils
 from bumble.colors import color
 from bumble.core import (
     AdvertisingData,
     InvalidArgumentError,
+    InvalidPacketError,
     PhysicalTransport,
     ProtocolError,
-    name_or_number,
 )
 from bumble.hci import (
     Address,
@@ -46,7 +46,6 @@ from bumble.hci import (
     HCI_LE_Enable_Encryption_Command,
     HCI_Object,
     Role,
-    key_with_value,
     metadata,
 )
 from bumble.keys import PairingKeys
@@ -71,115 +70,125 @@ logger = logging.getLogger(__name__)
 SMP_CID = 0x06
 SMP_BR_CID = 0x07
 
-SMP_PAIRING_REQUEST_COMMAND               = 0x01
-SMP_PAIRING_RESPONSE_COMMAND              = 0x02
-SMP_PAIRING_CONFIRM_COMMAND               = 0x03
-SMP_PAIRING_RANDOM_COMMAND                = 0x04
-SMP_PAIRING_FAILED_COMMAND                = 0x05
-SMP_ENCRYPTION_INFORMATION_COMMAND        = 0x06
-SMP_MASTER_IDENTIFICATION_COMMAND         = 0x07
-SMP_IDENTITY_INFORMATION_COMMAND          = 0x08
-SMP_IDENTITY_ADDRESS_INFORMATION_COMMAND  = 0x09
-SMP_SIGNING_INFORMATION_COMMAND           = 0x0A
-SMP_SECURITY_REQUEST_COMMAND              = 0x0B
-SMP_PAIRING_PUBLIC_KEY_COMMAND            = 0x0C
-SMP_PAIRING_DHKEY_CHECK_COMMAND           = 0x0D
-SMP_PAIRING_KEYPRESS_NOTIFICATION_COMMAND = 0x0E
+class CommandCode(hci.SpecableEnum):
+    PAIRING_REQUEST               = 0x01
+    PAIRING_RESPONSE              = 0x02
+    PAIRING_CONFIRM               = 0x03
+    PAIRING_RANDOM                = 0x04
+    PAIRING_FAILED                = 0x05
+    ENCRYPTION_INFORMATION        = 0x06
+    MASTER_IDENTIFICATION         = 0x07
+    IDENTITY_INFORMATION          = 0x08
+    IDENTITY_ADDRESS_INFORMATION  = 0x09
+    SIGNING_INFORMATION           = 0x0A
+    SECURITY_REQUEST              = 0x0B
+    PAIRING_PUBLIC_KEY            = 0x0C
+    PAIRING_DHKEY_CHECK           = 0x0D
+    PAIRING_KEYPRESS_NOTIFICATION = 0x0E
 
-SMP_COMMAND_NAMES = {
-    SMP_PAIRING_REQUEST_COMMAND:               'SMP_PAIRING_REQUEST_COMMAND',
-    SMP_PAIRING_RESPONSE_COMMAND:              'SMP_PAIRING_RESPONSE_COMMAND',
-    SMP_PAIRING_CONFIRM_COMMAND:               'SMP_PAIRING_CONFIRM_COMMAND',
-    SMP_PAIRING_RANDOM_COMMAND:                'SMP_PAIRING_RANDOM_COMMAND',
-    SMP_PAIRING_FAILED_COMMAND:                'SMP_PAIRING_FAILED_COMMAND',
-    SMP_ENCRYPTION_INFORMATION_COMMAND:        'SMP_ENCRYPTION_INFORMATION_COMMAND',
-    SMP_MASTER_IDENTIFICATION_COMMAND:         'SMP_MASTER_IDENTIFICATION_COMMAND',
-    SMP_IDENTITY_INFORMATION_COMMAND:          'SMP_IDENTITY_INFORMATION_COMMAND',
-    SMP_IDENTITY_ADDRESS_INFORMATION_COMMAND:  'SMP_IDENTITY_ADDRESS_INFORMATION_COMMAND',
-    SMP_SIGNING_INFORMATION_COMMAND:           'SMP_SIGNING_INFORMATION_COMMAND',
-    SMP_SECURITY_REQUEST_COMMAND:              'SMP_SECURITY_REQUEST_COMMAND',
-    SMP_PAIRING_PUBLIC_KEY_COMMAND:            'SMP_PAIRING_PUBLIC_KEY_COMMAND',
-    SMP_PAIRING_DHKEY_CHECK_COMMAND:           'SMP_PAIRING_DHKEY_CHECK_COMMAND',
-    SMP_PAIRING_KEYPRESS_NOTIFICATION_COMMAND: 'SMP_PAIRING_KEYPRESS_NOTIFICATION_COMMAND'
-}
 
-SMP_DISPLAY_ONLY_IO_CAPABILITY       = 0x00
-SMP_DISPLAY_YES_NO_IO_CAPABILITY     = 0x01
-SMP_KEYBOARD_ONLY_IO_CAPABILITY      = 0x02
-SMP_NO_INPUT_NO_OUTPUT_IO_CAPABILITY = 0x03
-SMP_KEYBOARD_DISPLAY_IO_CAPABILITY   = 0x04
+class IoCapability(hci.SpecableEnum):
+    DISPLAY_ONLY       = 0x00
+    DISPLAY_YES_NO     = 0x01
+    KEYBOARD_ONLY      = 0x02
+    NO_INPUT_NO_OUTPUT = 0x03
+    KEYBOARD_DISPLAY   = 0x04
 
-SMP_IO_CAPABILITY_NAMES = {
-    SMP_DISPLAY_ONLY_IO_CAPABILITY:       'SMP_DISPLAY_ONLY_IO_CAPABILITY',
-    SMP_DISPLAY_YES_NO_IO_CAPABILITY:     'SMP_DISPLAY_YES_NO_IO_CAPABILITY',
-    SMP_KEYBOARD_ONLY_IO_CAPABILITY:      'SMP_KEYBOARD_ONLY_IO_CAPABILITY',
-    SMP_NO_INPUT_NO_OUTPUT_IO_CAPABILITY: 'SMP_NO_INPUT_NO_OUTPUT_IO_CAPABILITY',
-    SMP_KEYBOARD_DISPLAY_IO_CAPABILITY:   'SMP_KEYBOARD_DISPLAY_IO_CAPABILITY'
-}
+SMP_DISPLAY_ONLY_IO_CAPABILITY       = IoCapability.DISPLAY_ONLY
+SMP_DISPLAY_YES_NO_IO_CAPABILITY     = IoCapability.DISPLAY_YES_NO
+SMP_KEYBOARD_ONLY_IO_CAPABILITY      = IoCapability.KEYBOARD_ONLY
+SMP_NO_INPUT_NO_OUTPUT_IO_CAPABILITY = IoCapability.NO_INPUT_NO_OUTPUT
+SMP_KEYBOARD_DISPLAY_IO_CAPABILITY   = IoCapability.KEYBOARD_DISPLAY
 
-SMP_PASSKEY_ENTRY_FAILED_ERROR                       = 0x01
-SMP_OOB_NOT_AVAILABLE_ERROR                          = 0x02
-SMP_AUTHENTICATION_REQUIREMENTS_ERROR                = 0x03
-SMP_CONFIRM_VALUE_FAILED_ERROR                       = 0x04
-SMP_PAIRING_NOT_SUPPORTED_ERROR                      = 0x05
-SMP_ENCRYPTION_KEY_SIZE_ERROR                        = 0x06
-SMP_COMMAND_NOT_SUPPORTED_ERROR                      = 0x07
-SMP_UNSPECIFIED_REASON_ERROR                         = 0x08
-SMP_REPEATED_ATTEMPTS_ERROR                          = 0x09
-SMP_INVALID_PARAMETERS_ERROR                         = 0x0A
-SMP_DHKEY_CHECK_FAILED_ERROR                         = 0x0B
-SMP_NUMERIC_COMPARISON_FAILED_ERROR                  = 0x0C
-SMP_BD_EDR_PAIRING_IN_PROGRESS_ERROR                 = 0x0D
-SMP_CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED_ERROR = 0x0E
+class ErrorCode(hci.SpecableEnum):
+    PASSKEY_ENTRY_FAILED                       = 0x01
+    OOB_NOT_AVAILABLE                          = 0x02
+    AUTHENTICATION_REQUIREMENTS                = 0x03
+    CONFIRM_VALUE_FAILED                       = 0x04
+    PAIRING_NOT_SUPPORTED                      = 0x05
+    ENCRYPTION_KEY_SIZE                        = 0x06
+    COMMAND_NOT_SUPPORTED                      = 0x07
+    UNSPECIFIED_REASON                         = 0x08
+    REPEATED_ATTEMPTS                          = 0x09
+    INVALID_PARAMETERS                         = 0x0A
+    DHKEY_CHECK_FAILED                         = 0x0B
+    NUMERIC_COMPARISON_FAILED                  = 0x0C
+    BD_EDR_PAIRING_IN_PROGRESS                 = 0x0D
+    CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED = 0x0E
 
-SMP_ERROR_NAMES = {
-    SMP_PASSKEY_ENTRY_FAILED_ERROR:                       'SMP_PASSKEY_ENTRY_FAILED_ERROR',
-    SMP_OOB_NOT_AVAILABLE_ERROR:                          'SMP_OOB_NOT_AVAILABLE_ERROR',
-    SMP_AUTHENTICATION_REQUIREMENTS_ERROR:                'SMP_AUTHENTICATION_REQUIREMENTS_ERROR',
-    SMP_CONFIRM_VALUE_FAILED_ERROR:                       'SMP_CONFIRM_VALUE_FAILED_ERROR',
-    SMP_PAIRING_NOT_SUPPORTED_ERROR:                      'SMP_PAIRING_NOT_SUPPORTED_ERROR',
-    SMP_ENCRYPTION_KEY_SIZE_ERROR:                        'SMP_ENCRYPTION_KEY_SIZE_ERROR',
-    SMP_COMMAND_NOT_SUPPORTED_ERROR:                      'SMP_COMMAND_NOT_SUPPORTED_ERROR',
-    SMP_UNSPECIFIED_REASON_ERROR:                         'SMP_UNSPECIFIED_REASON_ERROR',
-    SMP_REPEATED_ATTEMPTS_ERROR:                          'SMP_REPEATED_ATTEMPTS_ERROR',
-    SMP_INVALID_PARAMETERS_ERROR:                         'SMP_INVALID_PARAMETERS_ERROR',
-    SMP_DHKEY_CHECK_FAILED_ERROR:                         'SMP_DHKEY_CHECK_FAILED_ERROR',
-    SMP_NUMERIC_COMPARISON_FAILED_ERROR:                  'SMP_NUMERIC_COMPARISON_FAILED_ERROR',
-    SMP_BD_EDR_PAIRING_IN_PROGRESS_ERROR:                 'SMP_BD_EDR_PAIRING_IN_PROGRESS_ERROR',
-    SMP_CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED_ERROR: 'SMP_CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED_ERROR'
-}
+SMP_PASSKEY_ENTRY_FAILED_ERROR                       = ErrorCode.PASSKEY_ENTRY_FAILED
+SMP_OOB_NOT_AVAILABLE_ERROR                          = ErrorCode.OOB_NOT_AVAILABLE
+SMP_AUTHENTICATION_REQUIREMENTS_ERROR                = ErrorCode.AUTHENTICATION_REQUIREMENTS
+SMP_CONFIRM_VALUE_FAILED_ERROR                       = ErrorCode.CONFIRM_VALUE_FAILED
+SMP_PAIRING_NOT_SUPPORTED_ERROR                      = ErrorCode.PAIRING_NOT_SUPPORTED
+SMP_ENCRYPTION_KEY_SIZE_ERROR                        = ErrorCode.ENCRYPTION_KEY_SIZE
+SMP_COMMAND_NOT_SUPPORTED_ERROR                      = ErrorCode.COMMAND_NOT_SUPPORTED
+SMP_UNSPECIFIED_REASON_ERROR                         = ErrorCode.UNSPECIFIED_REASON
+SMP_REPEATED_ATTEMPTS_ERROR                          = ErrorCode.REPEATED_ATTEMPTS
+SMP_INVALID_PARAMETERS_ERROR                         = ErrorCode.INVALID_PARAMETERS
+SMP_DHKEY_CHECK_FAILED_ERROR                         = ErrorCode.DHKEY_CHECK_FAILED
+SMP_NUMERIC_COMPARISON_FAILED_ERROR                  = ErrorCode.NUMERIC_COMPARISON_FAILED
+SMP_BD_EDR_PAIRING_IN_PROGRESS_ERROR                 = ErrorCode.BD_EDR_PAIRING_IN_PROGRESS
+SMP_CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED_ERROR = ErrorCode.CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED
 
-SMP_PASSKEY_ENTRY_STARTED_KEYPRESS_NOTIFICATION_TYPE   = 0
-SMP_PASSKEY_DIGIT_ENTERED_KEYPRESS_NOTIFICATION_TYPE   = 1
-SMP_PASSKEY_DIGIT_ERASED_KEYPRESS_NOTIFICATION_TYPE    = 2
-SMP_PASSKEY_CLEARED_KEYPRESS_NOTIFICATION_TYPE         = 3
-SMP_PASSKEY_ENTRY_COMPLETED_KEYPRESS_NOTIFICATION_TYPE = 4
-
-SMP_KEYPRESS_NOTIFICATION_TYPE_NAMES = {
-    SMP_PASSKEY_ENTRY_STARTED_KEYPRESS_NOTIFICATION_TYPE:   'SMP_PASSKEY_ENTRY_STARTED_KEYPRESS_NOTIFICATION_TYPE',
-    SMP_PASSKEY_DIGIT_ENTERED_KEYPRESS_NOTIFICATION_TYPE:   'SMP_PASSKEY_DIGIT_ENTERED_KEYPRESS_NOTIFICATION_TYPE',
-    SMP_PASSKEY_DIGIT_ERASED_KEYPRESS_NOTIFICATION_TYPE:    'SMP_PASSKEY_DIGIT_ERASED_KEYPRESS_NOTIFICATION_TYPE',
-    SMP_PASSKEY_CLEARED_KEYPRESS_NOTIFICATION_TYPE:         'SMP_PASSKEY_CLEARED_KEYPRESS_NOTIFICATION_TYPE',
-    SMP_PASSKEY_ENTRY_COMPLETED_KEYPRESS_NOTIFICATION_TYPE: 'SMP_PASSKEY_ENTRY_COMPLETED_KEYPRESS_NOTIFICATION_TYPE'
-}
+class KeypressNotificationType(hci.SpecableEnum):
+    PASSKEY_ENTRY_STARTED   = 0
+    PASSKEY_DIGIT_ENTERED   = 1
+    PASSKEY_DIGIT_ERASED    = 2
+    PASSKEY_CLEARED         = 3
+    PASSKEY_ENTRY_COMPLETED = 4
 
 # Bit flags for key distribution/generation
-SMP_ENC_KEY_DISTRIBUTION_FLAG  = 0b0001
-SMP_ID_KEY_DISTRIBUTION_FLAG   = 0b0010
-SMP_SIGN_KEY_DISTRIBUTION_FLAG = 0b0100
-SMP_LINK_KEY_DISTRIBUTION_FLAG = 0b1000
+class KeyDistribution(hci.SpecableFlag):
+    ENC_KEY  = 0b0001
+    ID_KEY   = 0b0010
+    SIGN_KEY = 0b0100
+    LINK_KEY = 0b1000
 
 # AuthReq fields
-SMP_BONDING_AUTHREQ  = 0b00000001
-SMP_MITM_AUTHREQ     = 0b00000100
-SMP_SC_AUTHREQ       = 0b00001000
-SMP_KEYPRESS_AUTHREQ = 0b00010000
-SMP_CT2_AUTHREQ      = 0b00100000
+class AuthReq(hci.SpecableFlag):
+    BONDING  = 0b00000001
+    MITM     = 0b00000100
+    SC       = 0b00001000
+    KEYPRESS = 0b00010000
+    CT2      = 0b00100000
+
+    @classmethod
+    def from_booleans(
+        cls,
+        bonding: bool = False,
+        sc: bool = False,
+        mitm: bool = False,
+        keypress: bool = False,
+        ct2: bool = False,
+    ) -> AuthReq:
+        auth_req = AuthReq(0)
+        if bonding:
+            auth_req |= AuthReq.BONDING
+        if sc:
+            auth_req |= AuthReq.SC
+        if mitm:
+            auth_req |= AuthReq.MITM
+        if keypress:
+            auth_req |= AuthReq.KEYPRESS
+        if ct2:
+            auth_req |= AuthReq.CT2
+        return auth_req
 
 # Crypto salt
 SMP_CTKD_H7_LEBR_SALT = bytes.fromhex('000000000000000000000000746D7031')
 SMP_CTKD_H7_BRLE_SALT = bytes.fromhex('000000000000000000000000746D7032')
 
+# Diffie-Hellman private / public key pair in Debug Mode (Core - Vol. 3, Part H)
+SMP_DEBUG_KEY_PRIVATE = bytes.fromhex(
+        '3f49f6d4 a3c55f38 74c9b3e3 d2103f50 4aff607b eb40b799 5899b8a6 cd3c1abd'
+    )
+SMP_DEBUG_KEY_PUBLIC_X = bytes.fromhex(
+        '20b003d2 f297be2c 5e2c83a7 e9f9a5b9 eff49111 acf4fddb cc030148 0e359de6'
+    )
+SMP_DEBUG_KEY_PUBLIC_Y= bytes.fromhex(
+        'dc809c49 652aeb6d 63329abf 5a52155c 766345c2 8fed3024 741c8ed0 1589d28b'
+    )
 # fmt: on
 # pylint: enable=line-too-long
 # pylint: disable=invalid-name
@@ -188,8 +197,6 @@ SMP_CTKD_H7_BRLE_SALT = bytes.fromhex('000000000000000000000000746D7032')
 # -----------------------------------------------------------------------------
 # Utils
 # -----------------------------------------------------------------------------
-def error_name(error_code: int) -> str:
-    return name_or_number(SMP_ERROR_NAMES, error_code)
 
 
 # -----------------------------------------------------------------------------
@@ -201,20 +208,22 @@ class SMP_Command:
     See Bluetooth spec @ Vol 3, Part H - 3 SECURITY MANAGER PROTOCOL
     '''
 
-    smp_classes: ClassVar[dict[int, type[SMP_Command]]] = {}
+    smp_classes: ClassVar[dict[CommandCode, type[SMP_Command]]] = {}
     fields: ClassVar[Fields]
-    code: int = field(default=0, init=False)
+    code: CommandCode = field(default=CommandCode(0), init=False)
     name: str = field(default='', init=False)
     _payload: bytes | None = field(default=None, init=False)
 
     @classmethod
     def from_bytes(cls, pdu: bytes) -> SMP_Command:
-        code = pdu[0]
+        if not pdu:
+            raise InvalidPacketError("Empty SMP PDU")
+        code = CommandCode(pdu[0])
 
         subclass = SMP_Command.smp_classes.get(code)
         if subclass is None:
             instance = SMP_Command()
-            instance.name = SMP_Command.command_name(code)
+            instance.name = code.name
             instance.code = code
             instance.payload = pdu
             return instance
@@ -222,59 +231,14 @@ class SMP_Command:
         instance.payload = pdu[1:]
         return instance
 
-    @staticmethod
-    def command_name(code: int) -> str:
-        return name_or_number(SMP_COMMAND_NAMES, code)
-
-    @staticmethod
-    def auth_req_str(value: int) -> str:
-        bonding_flags = value & 3
-        mitm = (value >> 2) & 1
-        sc = (value >> 3) & 1
-        keypress = (value >> 4) & 1
-        ct2 = (value >> 5) & 1
-
-        return (
-            f'bonding_flags={bonding_flags}, '
-            f'MITM={mitm}, sc={sc}, keypress={keypress}, ct2={ct2}'
-        )
-
-    @staticmethod
-    def io_capability_name(io_capability: int) -> str:
-        return name_or_number(SMP_IO_CAPABILITY_NAMES, io_capability)
-
-    @staticmethod
-    def key_distribution_str(value: int) -> str:
-        key_types: list[str] = []
-        if value & SMP_ENC_KEY_DISTRIBUTION_FLAG:
-            key_types.append('ENC')
-        if value & SMP_ID_KEY_DISTRIBUTION_FLAG:
-            key_types.append('ID')
-        if value & SMP_SIGN_KEY_DISTRIBUTION_FLAG:
-            key_types.append('SIGN')
-        if value & SMP_LINK_KEY_DISTRIBUTION_FLAG:
-            key_types.append('LINK')
-        return ','.join(key_types)
-
-    @staticmethod
-    def keypress_notification_type_name(notification_type: int) -> str:
-        return name_or_number(SMP_KEYPRESS_NOTIFICATION_TYPE_NAMES, notification_type)
-
     _Command = TypeVar("_Command", bound="SMP_Command")
 
     @classmethod
     def subclass(cls, subclass: type[_Command]) -> type[_Command]:
-        subclass.name = subclass.__name__.upper()
-        subclass.code = key_with_value(SMP_COMMAND_NAMES, subclass.name)
-        if subclass.code is None:
-            raise KeyError(
-                f'Command name {subclass.name} not found in SMP_COMMAND_NAMES'
-            )
         subclass.fields = HCI_Object.fields_from_dataclass(subclass)
-
+        subclass.name = subclass.__name__.upper()
         # Register a factory for this class
         SMP_Command.smp_classes[subclass.code] = subclass
-
         return subclass
 
     @property
@@ -308,19 +272,17 @@ class SMP_Pairing_Request_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.5.1 Pairing Request
     '''
 
-    io_capability: int = field(
-        metadata=metadata({'size': 1, 'mapper': SMP_Command.io_capability_name})
-    )
+    code = CommandCode.PAIRING_REQUEST
+
+    io_capability: IoCapability = field(metadata=IoCapability.type_metadata(1))
     oob_data_flag: int = field(metadata=metadata(1))
-    auth_req: int = field(
-        metadata=metadata({'size': 1, 'mapper': SMP_Command.auth_req_str})
-    )
+    auth_req: AuthReq = field(metadata=AuthReq.type_metadata(1))
     maximum_encryption_key_size: int = field(metadata=metadata(1))
-    initiator_key_distribution: int = field(
-        metadata=metadata({'size': 1, 'mapper': SMP_Command.key_distribution_str})
+    initiator_key_distribution: KeyDistribution = field(
+        metadata=KeyDistribution.type_metadata(1)
     )
-    responder_key_distribution: int = field(
-        metadata=metadata({'size': 1, 'mapper': SMP_Command.key_distribution_str})
+    responder_key_distribution: KeyDistribution = field(
+        metadata=KeyDistribution.type_metadata(1)
     )
 
 
@@ -332,19 +294,17 @@ class SMP_Pairing_Response_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.5.2 Pairing Response
     '''
 
-    io_capability: int = field(
-        metadata=metadata({'size': 1, 'mapper': SMP_Command.io_capability_name})
-    )
+    code = CommandCode.PAIRING_RESPONSE
+
+    io_capability: IoCapability = field(metadata=IoCapability.type_metadata(1))
     oob_data_flag: int = field(metadata=metadata(1))
-    auth_req: int = field(
-        metadata=metadata({'size': 1, 'mapper': SMP_Command.auth_req_str})
-    )
+    auth_req: AuthReq = field(metadata=AuthReq.type_metadata(1))
     maximum_encryption_key_size: int = field(metadata=metadata(1))
-    initiator_key_distribution: int = field(
-        metadata=metadata({'size': 1, 'mapper': SMP_Command.key_distribution_str})
+    initiator_key_distribution: KeyDistribution = field(
+        metadata=KeyDistribution.type_metadata(1)
     )
-    responder_key_distribution: int = field(
-        metadata=metadata({'size': 1, 'mapper': SMP_Command.key_distribution_str})
+    responder_key_distribution: KeyDistribution = field(
+        metadata=KeyDistribution.type_metadata(1)
     )
 
 
@@ -356,6 +316,8 @@ class SMP_Pairing_Confirm_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.5.3 Pairing Confirm
     '''
 
+    code = CommandCode.PAIRING_CONFIRM
+
     confirm_value: bytes = field(metadata=metadata(16))
 
 
@@ -367,6 +329,8 @@ class SMP_Pairing_Random_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.5.4 Pairing Random
     '''
 
+    code = CommandCode.PAIRING_RANDOM
+
     random_value: bytes = field(metadata=metadata(16))
 
 
@@ -378,7 +342,9 @@ class SMP_Pairing_Failed_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.5.5 Pairing Failed
     '''
 
-    reason: int = field(metadata=metadata({'size': 1, 'mapper': error_name}))
+    code = CommandCode.PAIRING_FAILED
+
+    reason: ErrorCode = field(metadata=ErrorCode.type_metadata(1))
 
 
 # -----------------------------------------------------------------------------
@@ -389,6 +355,8 @@ class SMP_Pairing_Public_Key_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.5.6 Pairing Public Key
     '''
 
+    code = CommandCode.PAIRING_PUBLIC_KEY
+
     public_key_x: bytes = field(metadata=metadata(32))
     public_key_y: bytes = field(metadata=metadata(32))
 
@@ -401,6 +369,8 @@ class SMP_Pairing_DHKey_Check_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.5.7 Pairing DHKey Check
     '''
 
+    code = CommandCode.PAIRING_DHKEY_CHECK
+
     dhkey_check: bytes = field(metadata=metadata(16))
 
 
@@ -412,10 +382,10 @@ class SMP_Pairing_Keypress_Notification_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.5.8 Keypress Notification
     '''
 
-    notification_type: int = field(
-        metadata=metadata(
-            {'size': 1, 'mapper': SMP_Command.keypress_notification_type_name}
-        )
+    code = CommandCode.PAIRING_KEYPRESS_NOTIFICATION
+
+    notification_type: KeypressNotificationType = field(
+        metadata=KeypressNotificationType.type_metadata(1)
     )
 
 
@@ -427,6 +397,8 @@ class SMP_Encryption_Information_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.6.2 Encryption Information
     '''
 
+    code = CommandCode.ENCRYPTION_INFORMATION
+
     long_term_key: bytes = field(metadata=metadata(16))
 
 
@@ -438,6 +410,8 @@ class SMP_Master_Identification_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.6.3 Master Identification
     '''
 
+    code = CommandCode.MASTER_IDENTIFICATION
+
     ediv: int = field(metadata=metadata(2))
     rand: bytes = field(metadata=metadata(8))
 
@@ -450,6 +424,8 @@ class SMP_Identity_Information_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.6.4 Identity Information
     '''
 
+    code = CommandCode.IDENTITY_INFORMATION
+
     identity_resolving_key: bytes = field(metadata=metadata(16))
 
 
@@ -461,6 +437,8 @@ class SMP_Identity_Address_Information_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.6.5 Identity Address Information
     '''
 
+    code = CommandCode.IDENTITY_ADDRESS_INFORMATION
+
     addr_type: int = field(metadata=metadata(Address.ADDRESS_TYPE_SPEC))
     bd_addr: Address = field(metadata=metadata(Address.parse_address_preceded_by_type))
 
@@ -473,6 +451,8 @@ class SMP_Signing_Information_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.6.6 Signing Information
     '''
 
+    code = CommandCode.SIGNING_INFORMATION
+
     signature_key: bytes = field(metadata=metadata(16))
 
 
@@ -484,25 +464,9 @@ class SMP_Security_Request_Command(SMP_Command):
     See Bluetooth spec @ Vol 3, Part H - 3.6.7 Security Request
     '''
 
-    auth_req: int = field(
-        metadata=metadata({'size': 1, 'mapper': SMP_Command.auth_req_str})
-    )
+    code = CommandCode.SECURITY_REQUEST
 
-
-# -----------------------------------------------------------------------------
-def smp_auth_req(bonding: bool, mitm: bool, sc: bool, keypress: bool, ct2: bool) -> int:
-    value = 0
-    if bonding:
-        value |= SMP_BONDING_AUTHREQ
-    if mitm:
-        value |= SMP_MITM_AUTHREQ
-    if sc:
-        value |= SMP_SC_AUTHREQ
-    if keypress:
-        value |= SMP_KEYPRESS_AUTHREQ
-    if ct2:
-        value |= SMP_CT2_AUTHREQ
-    return value
+    auth_req: AuthReq = field(metadata=AuthReq.type_metadata(1))
 
 
 # -----------------------------------------------------------------------------
@@ -676,8 +640,8 @@ class Session:
         self.ltk_rand = bytes(8)
         self.link_key: bytes | None = None
         self.maximum_encryption_key_size: int = 0
-        self.initiator_key_distribution: int = 0
-        self.responder_key_distribution: int = 0
+        self.initiator_key_distribution: KeyDistribution = KeyDistribution(0)
+        self.responder_key_distribution: KeyDistribution = KeyDistribution(0)
         self.peer_random_value: bytes | None = None
         self.peer_public_key_x: bytes = bytes(32)
         self.peer_public_key_y = bytes(32)
@@ -728,10 +692,10 @@ class Session:
         )
 
         # Key Distribution (default values before negotiation)
-        self.initiator_key_distribution = (
+        self.initiator_key_distribution = KeyDistribution(
             pairing_config.delegate.local_initiator_key_distribution
         )
-        self.responder_key_distribution = (
+        self.responder_key_distribution = KeyDistribution(
             pairing_config.delegate.local_responder_key_distribution
         )
 
@@ -743,7 +707,7 @@ class Session:
         self.ct2: bool = False
 
         # I/O Capabilities
-        self.io_capability = pairing_config.delegate.io_capability
+        self.io_capability = IoCapability(pairing_config.delegate.io_capability)
         self.peer_io_capability = SMP_NO_INPUT_NO_OUTPUT_IO_CAPABILITY
 
         # OOB
@@ -822,8 +786,14 @@ class Session:
         return self.nx[0 if self.is_responder else 1]
 
     @property
-    def auth_req(self) -> int:
-        return smp_auth_req(self.bonding, self.mitm, self.sc, self.keypress, self.ct2)
+    def auth_req(self) -> AuthReq:
+        return AuthReq.from_booleans(
+            bonding=self.bonding,
+            sc=self.sc,
+            mitm=self.mitm,
+            keypress=self.keypress,
+            ct2=self.ct2,
+        )
 
     def get_long_term_key(self, rand: bytes, ediv: int) -> bytes | None:
         if not self.sc and not self.completed:
@@ -843,7 +813,7 @@ class Session:
         if self.connection.transport == PhysicalTransport.BR_EDR:
             self.pairing_method = PairingMethod.CTKD_OVER_CLASSIC
             return
-        if (not self.mitm) and (auth_req & SMP_MITM_AUTHREQ == 0):
+        if (not self.mitm) and (auth_req & AuthReq.MITM == 0):
             self.pairing_method = PairingMethod.JUST_WORKS
             return
 
@@ -861,7 +831,7 @@ class Session:
             self.passkey_display = details[1 if self.is_initiator else 2]
 
     def check_expected_value(
-        self, expected: bytes, received: bytes, error: int
+        self, expected: bytes, received: bytes, error: ErrorCode
     ) -> bool:
         logger.debug(f'expected={expected.hex()} got={received.hex()}')
         if expected != received:
@@ -881,7 +851,7 @@ class Session:
             except Exception:
                 logger.exception('exception while confirm')
 
-            self.send_pairing_failed(SMP_CONFIRM_VALUE_FAILED_ERROR)
+            self.send_pairing_failed(ErrorCode.CONFIRM_VALUE_FAILED)
 
         self.connection.cancel_on_disconnection(prompt())
 
@@ -900,7 +870,7 @@ class Session:
             except Exception:
                 logger.exception('exception while prompting')
 
-            self.send_pairing_failed(SMP_CONFIRM_VALUE_FAILED_ERROR)
+            self.send_pairing_failed(ErrorCode.CONFIRM_VALUE_FAILED)
 
         self.connection.cancel_on_disconnection(prompt())
 
@@ -911,13 +881,13 @@ class Session:
                 passkey = await self.pairing_config.delegate.get_number()
                 if passkey is None:
                     logger.debug('Passkey request rejected')
-                    self.send_pairing_failed(SMP_PASSKEY_ENTRY_FAILED_ERROR)
+                    self.send_pairing_failed(ErrorCode.PASSKEY_ENTRY_FAILED)
                     return
                 logger.debug(f'user input: {passkey}')
                 next_steps(passkey)
             except Exception:
                 logger.exception('exception while prompting')
-                self.send_pairing_failed(SMP_PASSKEY_ENTRY_FAILED_ERROR)
+                self.send_pairing_failed(ErrorCode.PASSKEY_ENTRY_FAILED)
 
         self.connection.cancel_on_disconnection(prompt())
 
@@ -972,7 +942,7 @@ class Session:
     def send_command(self, command: SMP_Command) -> None:
         self.manager.send_command(self.connection, command)
 
-    def send_pairing_failed(self, error: int) -> None:
+    def send_pairing_failed(self, error: ErrorCode) -> None:
         self.send_command(SMP_Pairing_Failed_Command(reason=error))
         self.on_pairing_failure(error)
 
@@ -1144,7 +1114,7 @@ class Session:
                 'Try to derive LTK but host does not have the LK. Send a SMP_PAIRING_FAILED but the procedure will not be paused!'
             )
             self.send_pairing_failed(
-                SMP_CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED_ERROR
+                ErrorCode.CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED
             )
         else:
             self.ltk = self.derive_ltk(self.link_key, self.ct2)
@@ -1155,14 +1125,14 @@ class Session:
             # CTKD: Derive LTK from LinkKey
             if (
                 self.connection.transport == PhysicalTransport.BR_EDR
-                and self.initiator_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG
+                and self.initiator_key_distribution & KeyDistribution.ENC_KEY
             ):
                 self.ctkd_task = self.connection.cancel_on_disconnection(
                     self.get_link_key_and_derive_ltk()
                 )
             elif not self.sc:
                 # Distribute the LTK, EDIV and RAND
-                if self.initiator_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG:
+                if self.initiator_key_distribution & KeyDistribution.ENC_KEY:
                     self.send_command(
                         SMP_Encryption_Information_Command(long_term_key=self.ltk)
                     )
@@ -1173,7 +1143,7 @@ class Session:
                     )
 
             # Distribute IRK & BD ADDR
-            if self.initiator_key_distribution & SMP_ID_KEY_DISTRIBUTION_FLAG:
+            if self.initiator_key_distribution & KeyDistribution.ID_KEY:
                 self.send_command(
                     SMP_Identity_Information_Command(
                         identity_resolving_key=self.manager.device.irk
@@ -1183,25 +1153,25 @@ class Session:
 
             # Distribute CSRK
             csrk = bytes(16)  # FIXME: testing
-            if self.initiator_key_distribution & SMP_SIGN_KEY_DISTRIBUTION_FLAG:
+            if self.initiator_key_distribution & KeyDistribution.SIGN_KEY:
                 self.send_command(SMP_Signing_Information_Command(signature_key=csrk))
 
             # CTKD, calculate BR/EDR link key
-            if self.initiator_key_distribution & SMP_LINK_KEY_DISTRIBUTION_FLAG:
+            if self.initiator_key_distribution & KeyDistribution.LINK_KEY:
                 self.link_key = self.derive_link_key(self.ltk, self.ct2)
 
         else:
             # CTKD: Derive LTK from LinkKey
             if (
                 self.connection.transport == PhysicalTransport.BR_EDR
-                and self.responder_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG
+                and self.responder_key_distribution & KeyDistribution.ENC_KEY
             ):
                 self.ctkd_task = self.connection.cancel_on_disconnection(
                     self.get_link_key_and_derive_ltk()
                 )
             # Distribute the LTK, EDIV and RAND
             elif not self.sc:
-                if self.responder_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG:
+                if self.responder_key_distribution & KeyDistribution.ENC_KEY:
                     self.send_command(
                         SMP_Encryption_Information_Command(long_term_key=self.ltk)
                     )
@@ -1212,7 +1182,7 @@ class Session:
                     )
 
             # Distribute IRK & BD ADDR
-            if self.responder_key_distribution & SMP_ID_KEY_DISTRIBUTION_FLAG:
+            if self.responder_key_distribution & KeyDistribution.ID_KEY:
                 self.send_command(
                     SMP_Identity_Information_Command(
                         identity_resolving_key=self.manager.device.irk
@@ -1222,30 +1192,30 @@ class Session:
 
             # Distribute CSRK
             csrk = bytes(16)  # FIXME: testing
-            if self.responder_key_distribution & SMP_SIGN_KEY_DISTRIBUTION_FLAG:
+            if self.responder_key_distribution & KeyDistribution.SIGN_KEY:
                 self.send_command(SMP_Signing_Information_Command(signature_key=csrk))
 
             # CTKD, calculate BR/EDR link key
-            if self.responder_key_distribution & SMP_LINK_KEY_DISTRIBUTION_FLAG:
+            if self.responder_key_distribution & KeyDistribution.LINK_KEY:
                 self.link_key = self.derive_link_key(self.ltk, self.ct2)
 
     def compute_peer_expected_distributions(self, key_distribution_flags: int) -> None:
         # Set our expectations for what to wait for in the key distribution phase
         self.peer_expected_distributions = []
         if not self.sc and self.connection.transport == PhysicalTransport.LE:
-            if key_distribution_flags & SMP_ENC_KEY_DISTRIBUTION_FLAG != 0:
+            if key_distribution_flags & KeyDistribution.ENC_KEY != 0:
                 self.peer_expected_distributions.append(
                     SMP_Encryption_Information_Command
                 )
                 self.peer_expected_distributions.append(
                     SMP_Master_Identification_Command
                 )
-        if key_distribution_flags & SMP_ID_KEY_DISTRIBUTION_FLAG != 0:
+        if key_distribution_flags & KeyDistribution.ID_KEY != 0:
             self.peer_expected_distributions.append(SMP_Identity_Information_Command)
             self.peer_expected_distributions.append(
                 SMP_Identity_Address_Information_Command
             )
-        if key_distribution_flags & SMP_SIGN_KEY_DISTRIBUTION_FLAG != 0:
+        if key_distribution_flags & KeyDistribution.SIGN_KEY != 0:
             self.peer_expected_distributions.append(SMP_Signing_Information_Command)
         logger.debug(
             'expecting distributions: '
@@ -1258,7 +1228,7 @@ class Session:
             logger.warning(
                 color('received key distribution on a non-encrypted connection', 'red')
             )
-            self.send_pairing_failed(SMP_UNSPECIFIED_REASON_ERROR)
+            self.send_pairing_failed(ErrorCode.UNSPECIFIED_REASON)
             return
 
         # Check that this command class is expected
@@ -1278,7 +1248,7 @@ class Session:
                     'red',
                 )
             )
-            self.send_pairing_failed(SMP_UNSPECIFIED_REASON_ERROR)
+            self.send_pairing_failed(ErrorCode.UNSPECIFIED_REASON)
 
     async def pair(self) -> None:
         # Start pairing as an initiator
@@ -1389,34 +1359,56 @@ class Session:
             )
         await self.manager.on_pairing(self, peer_address, keys)
 
-    def on_pairing_failure(self, reason: int) -> None:
-        logger.warning(f'pairing failure ({error_name(reason)})')
+    def on_pairing_failure(self, reason: ErrorCode) -> None:
+        logger.warning('pairing failure (%s)', reason.name)
 
         if self.completed:
             return
 
         self.completed = True
 
-        error = ProtocolError(reason, 'smp', error_name(reason))
+        error = ProtocolError(reason, 'smp', reason.name)
         if self.pairing_result is not None and not self.pairing_result.done():
             self.pairing_result.set_exception(error)
         self.manager.on_pairing_failure(self, reason)
 
     def on_smp_command(self, command: SMP_Command) -> None:
-        # Find the handler method
-        handler_name = f'on_{command.name.lower()}'
-        handler = getattr(self, handler_name, None)
-        if handler is not None:
         try:
-                handler(command)
+            match command:
+                case SMP_Pairing_Request_Command():
+                    self.on_smp_pairing_request_command(command)
+                case SMP_Pairing_Response_Command():
+                    self.on_smp_pairing_response_command(command)
+                case SMP_Pairing_Confirm_Command():
+                    self.on_smp_pairing_confirm_command(command)
+                case SMP_Pairing_Random_Command():
+                    self.on_smp_pairing_random_command(command)
+                case SMP_Pairing_Failed_Command():
+                    self.on_smp_pairing_failed_command(command)
+                case SMP_Encryption_Information_Command():
+                    self.on_smp_encryption_information_command(command)
+                case SMP_Master_Identification_Command():
+                    self.on_smp_master_identification_command(command)
+                case SMP_Identity_Information_Command():
+                    self.on_smp_identity_information_command(command)
+                case SMP_Identity_Address_Information_Command():
+                    self.on_smp_identity_address_information_command(command)
+                case SMP_Signing_Information_Command():
+                    self.on_smp_signing_information_command(command)
+                case SMP_Pairing_Public_Key_Command():
+                    self.on_smp_pairing_public_key_command(command)
+                case SMP_Pairing_DHKey_Check_Command():
+                    self.on_smp_pairing_dhkey_check_command(command)
+                # case SMP_Security_Request_Command():
+                #     self.on_smp_security_request_command(command)
+                # case SMP_Pairing_Keypress_Notification_Command():
+                #     self.on_smp_pairing_keypress_notification_command(command)
+                case _:
+                    logger.error(color('SMP command not handled', 'red'))
         except Exception:
             logger.exception(color("!!! Exception in handler:", "red"))
-                response = SMP_Pairing_Failed_Command(
-                    reason=SMP_UNSPECIFIED_REASON_ERROR
-                )
+            response = SMP_Pairing_Failed_Command(reason=ErrorCode.UNSPECIFIED_REASON)
             self.send_command(response)
-        else:
-            logger.error(color('SMP command not handled???', 'red'))
 
     def on_smp_pairing_request_command(
         self, command: SMP_Pairing_Request_Command
@@ -1436,16 +1428,16 @@ class Session:
             accepted = False
         if not accepted:
             logger.debug('pairing rejected by delegate')
-            self.send_pairing_failed(SMP_PAIRING_NOT_SUPPORTED_ERROR)
+            self.send_pairing_failed(ErrorCode.PAIRING_NOT_SUPPORTED)
             return
 
         # Save the request
         self.preq = bytes(command)
 
         # Bonding and SC require both sides to request/support it
-        self.bonding = self.bonding and (command.auth_req & SMP_BONDING_AUTHREQ != 0)
-        self.sc = self.sc and (command.auth_req & SMP_SC_AUTHREQ != 0)
-        self.ct2 = self.ct2 and (command.auth_req & SMP_CT2_AUTHREQ != 0)
+        self.bonding = self.bonding and (command.auth_req & AuthReq.BONDING != 0)
+        self.sc = self.sc and (command.auth_req & AuthReq.SC != 0)
+        self.ct2 = self.ct2 and (command.auth_req & AuthReq.CT2 != 0)
 
         # Infer the pairing method
         if (self.sc and (self.oob_data_flag != 0 or command.oob_data_flag != 0)) or (
@@ -1456,7 +1448,7 @@ class Session:
             if not self.sc and self.tk is None:
                 # For legacy OOB, TK is required.
                 logger.warning("legacy OOB without TK")
-                self.send_pairing_failed(SMP_OOB_NOT_AVAILABLE_ERROR)
+                self.send_pairing_failed(ErrorCode.OOB_NOT_AVAILABLE)
                 return
             if command.oob_data_flag == 0:
                 # The peer doesn't have OOB data, use r=0
@@ -1475,8 +1467,11 @@ class Session:
         (
             self.initiator_key_distribution,
             self.responder_key_distribution,
-        ) = await self.pairing_config.delegate.key_distribution_response(
+        ) = map(
+            KeyDistribution,
+            await self.pairing_config.delegate.key_distribution_response(
                 command.initiator_key_distribution, command.responder_key_distribution
+            ),
         )
         self.compute_peer_expected_distributions(self.initiator_key_distribution)
 
@@ -1514,8 +1509,8 @@ class Session:
         self.peer_io_capability = command.io_capability
 
         # Bonding and SC require both sides to request/support it
-        self.bonding = self.bonding and (command.auth_req & SMP_BONDING_AUTHREQ != 0)
-        self.sc = self.sc and (command.auth_req & SMP_SC_AUTHREQ != 0)
+        self.bonding = self.bonding and (command.auth_req & AuthReq.BONDING != 0)
+        self.sc = self.sc and (command.auth_req & AuthReq.SC != 0)
 
         # Infer the pairing method
         if (self.sc and (self.oob_data_flag != 0 or command.oob_data_flag != 0)) or (
@@ -1526,7 +1521,7 @@ class Session:
             if not self.sc and self.tk is None:
                 # For legacy OOB, TK is required.
                 logger.warning("legacy OOB without TK")
-                self.send_pairing_failed(SMP_OOB_NOT_AVAILABLE_ERROR)
+                self.send_pairing_failed(ErrorCode.OOB_NOT_AVAILABLE)
                 return
             if command.oob_data_flag == 0:
                 # The peer doesn't have OOB data, use r=0
@@ -1546,7 +1541,7 @@ class Session:
             command.responder_key_distribution & ~self.responder_key_distribution != 0
         ):
             # The response isn't a subset of the request
-            self.send_pairing_failed(SMP_INVALID_PARAMETERS_ERROR)
+            self.send_pairing_failed(ErrorCode.INVALID_PARAMETERS)
             return
         self.initiator_key_distribution = command.initiator_key_distribution
         self.responder_key_distribution = command.responder_key_distribution
@@ -1624,7 +1619,7 @@ class Session:
         )
         assert self.confirm_value
         if not self.check_expected_value(
-            self.confirm_value, confirm_verifier, SMP_CONFIRM_VALUE_FAILED_ERROR
+            self.confirm_value, confirm_verifier, ErrorCode.CONFIRM_VALUE_FAILED
         ):
             return
 
@@ -1665,7 +1660,7 @@ class Session:
                     self.pkb, self.pka, command.random_value, bytes([0])
                 )
                 if not self.check_expected_value(
-                    self.confirm_value, confirm_verifier, SMP_CONFIRM_VALUE_FAILED_ERROR
+                    self.confirm_value, confirm_verifier, ErrorCode.CONFIRM_VALUE_FAILED
                 ):
                     return
             elif self.pairing_method == PairingMethod.PASSKEY:
@@ -1678,7 +1673,7 @@ class Session:
                     bytes([0x80 + ((self.passkey >> self.passkey_step) & 1)]),
                 )
                 if not self.check_expected_value(
-                    self.confirm_value, confirm_verifier, SMP_CONFIRM_VALUE_FAILED_ERROR
+                    self.confirm_value, confirm_verifier, ErrorCode.CONFIRM_VALUE_FAILED
                 ):
                     return
 
@@ -1707,7 +1702,7 @@ class Session:
                     bytes([0x80 + ((self.passkey >> self.passkey_step) & 1)]),
                 )
                 if not self.check_expected_value(
-                    self.confirm_value, confirm_verifier, SMP_CONFIRM_VALUE_FAILED_ERROR
+                    self.confirm_value, confirm_verifier, ErrorCode.CONFIRM_VALUE_FAILED
                 ):
                     return
 
@@ -1824,7 +1819,7 @@ class Session:
                 if not self.check_expected_value(
                     self.peer_oob_data.c,
                     confirm_verifier,
-                    SMP_CONFIRM_VALUE_FAILED_ERROR,
+                    ErrorCode.CONFIRM_VALUE_FAILED,
                 ):
                     return
 
@@ -1858,7 +1853,7 @@ class Session:
         expected = self.eb if self.is_initiator else self.ea
         assert expected
         if not self.check_expected_value(
-            expected, command.dhkey_check, SMP_DHKEY_CHECK_FAILED_ERROR
+            expected, command.dhkey_check, ErrorCode.DHKEY_CHECK_FAILED
         ):
             return
 
@@ -1937,6 +1932,7 @@ class Manager(utils.EventEmitter):
         self._ecc_key = None
         self.pairing_config_factory = pairing_config_factory
         self.session_proxy = Session
+        self.debug_mode = False
 
     def send_command(self, connection: Connection, command: SMP_Command) -> None:
         logger.debug(
@@ -1962,7 +1958,7 @@ class Manager(utils.EventEmitter):
         )
 
         # Security request is more than just pairing, so let applications handle them
-        if command.code == SMP_SECURITY_REQUEST_COMMAND:
+        if command.code == CommandCode.SECURITY_REQUEST:
             self.on_smp_security_request_command(
                 connection, cast(SMP_Security_Request_Command, command)
             )
@@ -1983,6 +1979,13 @@ class Manager(utils.EventEmitter):
 
     @property
     def ecc_key(self) -> crypto.EccKey:
+        if self.debug_mode:
+            # Core - Vol 3, Part H:
+            # When the Security Manager is placed in a Debug mode it shall use the
+            # following Diffie-Hellman private / public key pair:
+            debug_key = crypto.EccKey.from_private_key_bytes(SMP_DEBUG_KEY_PRIVATE)
+            return debug_key
+
         if self._ecc_key is None:
             self._ecc_key = crypto.EccKey.generate()
         assert self._ecc_key
@@ -2002,15 +2005,13 @@ class Manager(utils.EventEmitter):
     def request_pairing(self, connection: Connection) -> None:
         pairing_config = self.pairing_config_factory(connection)
         if pairing_config:
-            auth_req = smp_auth_req(
-                pairing_config.bonding,
-                pairing_config.mitm,
-                pairing_config.sc,
-                False,
-                False,
+            auth_req = AuthReq.from_booleans(
+                bonding=pairing_config.bonding,
+                sc=pairing_config.sc,
+                mitm=pairing_config.mitm,
             )
         else:
-            auth_req = 0
+            auth_req = AuthReq(0)
         self.send_command(connection, SMP_Security_Request_Command(auth_req=auth_req))
 
     def on_session_start(self, session: Session) -> None:
@@ -2026,7 +2027,7 @@ class Manager(utils.EventEmitter):
         # Notify the device
         self.device.on_pairing(session.connection, identity_address, keys, session.sc)
 
-    def on_pairing_failure(self, session: Session, reason: int) -> None:
+    def on_pairing_failure(self, session: Session, reason: ErrorCode) -> None:
         self.device.on_pairing_failure(session.connection, reason)
 
     def on_session_end(self, session: Session) -> None:

bumble/transport/pyusb.py

@@ -104,6 +104,9 @@ async def open_pyusb_transport(spec: str) -> Transport:
                         0,
                         packet[1:],
                     )
+                elif packet_type == hci.HCI_ISO_DATA_PACKET:
+                    # Workaround: Send ISO packets over Bulk Out
+                    self.device.write(USB_ENDPOINT_ACL_OUT, packet[1:])
                 else:
                     logger.warning(
                         color(f'unsupported packet type {packet_type}', 'red')

bumble/transport/usb.py

@@ -22,6 +22,8 @@ import ctypes
 import logging
 import platform
 import threading
+from collections.abc import Callable
+from typing import Any
 
 import usb1
 
@@ -35,6 +37,32 @@ from bumble.transport.common import BaseSource, Transport, TransportInitError
 logger = logging.getLogger(__name__)
 
 
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+# pylint: disable=invalid-name
+USB_RECIPIENT_DEVICE = 0x00
+USB_REQUEST_TYPE_CLASS = 0x01 << 5
+USB_DEVICE_CLASS_DEVICE = 0x00
+USB_DEVICE_CLASS_WIRELESS_CONTROLLER = 0xE0
+USB_DEVICE_SUBCLASS_RF_CONTROLLER = 0x01
+USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER = 0x01
+USB_ENDPOINT_TRANSFER_TYPE_ISOCHRONOUS = 0x01
+USB_ENDPOINT_TRANSFER_TYPE_BULK = 0x02
+USB_ENDPOINT_TRANSFER_TYPE_INTERRUPT = 0x03
+USB_ENDPOINT_IN = 0x80
+
+USB_BT_HCI_CLASS_TUPLE = (
+    USB_DEVICE_CLASS_WIRELESS_CONTROLLER,
+    USB_DEVICE_SUBCLASS_RF_CONTROLLER,
+    USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER,
+)
+
+MAX_SCO_PACKET_SIZE = 1024
+MAX_SCO_IN_PACKETS = 128
+NUMBER_OF_SCO_IN_TRANSFERS = 2
+
+
 # -----------------------------------------------------------------------------
 def load_libusb():
     '''
@@ -60,65 +88,166 @@ def load_libusb():
             usb1.loadLibrary(libusb_dll)
 
 
-async def open_usb_transport(spec: str) -> Transport:
-    '''
-    Open a USB transport.
-    The moniker string has this syntax:
-    either <index> or
-    <vendor>:<product> or
-    <vendor>:<product>/<serial-number>] or
-    <vendor>:<product>#<index>
-    With <index> as the 0-based index to select amongst all the devices that appear
-    to be supporting Bluetooth HCI (0 being the first one), or
-    Where <vendor> and <product> are the vendor ID and product ID in hexadecimal. The
-    /<serial-number> suffix or #<index> suffix max be specified when more than one
-    device with the same vendor and product identifiers are present.
+def find_endpoints(device, forced_mode, sco_alternate=None):
+    '''Look for the interfaces with the right class and endpoints'''
+    # pylint: disable-next=too-many-nested-blocks
+    for configuration_index, configuration in enumerate(device):
+        # Select the interface and endpoints for ACL
+        acl_interface = None
+        bulk_in = None
+        bulk_out = None
+        interrupt_in = None
+        for interface in configuration:
+            for setting in interface:
+                if acl_interface is not None:
+                    continue
 
-    In addition, if the moniker ends with the symbol "!", the device will be used in
-    "forced" mode:
-    the first USB interface of the device will be used, regardless of the interface
-    class/subclass.
-    This may be useful for some devices that use a custom class/subclass but may
-    nonetheless work as-is.
+                if (
+                    not forced_mode
+                    and (
+                        setting.getClass(),
+                        setting.getSubClass(),
+                        setting.getProtocol(),
+                    )
+                    != USB_BT_HCI_CLASS_TUPLE
+                ):
+                    continue
 
-    Examples:
-    0 --> the first BT USB dongle
-    04b4:f901 --> the BT USB dongle with vendor=04b4 and product=f901
-    04b4:f901#2 --> the third USB device with vendor=04b4 and product=f901
-    04b4:f901/00E04C239987 --> the BT USB dongle with vendor=04b4 and product=f901 and
-    serial number 00E04C239987
-    usb:0B05:17CB! --> the BT USB dongle vendor=0B05 and product=17CB, in "forced" mode.
-    '''
+                for endpoint in setting:
+                    attributes = endpoint.getAttributes()
+                    address = endpoint.getAddress()
+                    if attributes & 0x03 == USB_ENDPOINT_TRANSFER_TYPE_BULK:
+                        if address & USB_ENDPOINT_IN:
+                            if bulk_in is None:
+                                bulk_in = endpoint
+                        else:
+                            if bulk_out is None:
+                                bulk_out = endpoint
+                    elif attributes & 0x03 == USB_ENDPOINT_TRANSFER_TYPE_INTERRUPT:
+                        if address & USB_ENDPOINT_IN and interrupt_in is None:
+                            interrupt_in = endpoint
 
-    # pylint: disable=invalid-name
-    USB_RECIPIENT_DEVICE = 0x00
-    USB_REQUEST_TYPE_CLASS = 0x01 << 5
-    USB_DEVICE_CLASS_DEVICE = 0x00
-    USB_DEVICE_CLASS_WIRELESS_CONTROLLER = 0xE0
-    USB_DEVICE_SUBCLASS_RF_CONTROLLER = 0x01
-    USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER = 0x01
-    USB_ENDPOINT_TRANSFER_TYPE_BULK = 0x02
-    USB_ENDPOINT_TRANSFER_TYPE_INTERRUPT = 0x03
-    USB_ENDPOINT_IN = 0x80
+                # Only keep complete sets (endpoints that should be under the
+                # same interface)
+                if (
+                    bulk_in is not None
+                    and bulk_out is not None
+                    and interrupt_in is not None
+                ):
+                    acl_interface = setting
 
-    USB_BT_HCI_CLASS_TUPLE = (
-        USB_DEVICE_CLASS_WIRELESS_CONTROLLER,
-        USB_DEVICE_SUBCLASS_RF_CONTROLLER,
-        USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER,
+        # Select the interface and endpoints for SCO
+        sco_interface = None
+        max_packet_size = (0, 0)
+        isochronous_in = None
+        isochronous_out = None
+
+        for interface in configuration:
+            if sco_interface is not None:
+                continue
+
+            if sco_alternate is None:
+                continue
+
+            for setting in interface:
+                if (
+                    not forced_mode
+                    and (
+                        setting.getClass(),
+                        setting.getSubClass(),
+                        setting.getProtocol(),
+                    )
+                    != USB_BT_HCI_CLASS_TUPLE
+                ):
+                    continue
+
+                if (
+                    sco_alternate != 0
+                    and setting.getAlternateSetting() != sco_alternate
+                ):
+                    continue
+
+                isochronous_in = None
+                isochronous_out = None
+
+                for endpoint in setting:
+                    if (
+                        endpoint.getAttributes() & 0x03
+                        == USB_ENDPOINT_TRANSFER_TYPE_ISOCHRONOUS
+                    ):
+                        if endpoint.getMaxPacketSize() > 0:
+                            if endpoint.getAddress() & USB_ENDPOINT_IN:
+                                if (
+                                    isochronous_in is None
+                                    or endpoint.getMaxPacketSize()
+                                    > (isochronous_in.getMaxPacketSize())
+                                ):
+                                    isochronous_in = endpoint
+                            else:
+                                if (
+                                    isochronous_out is None
+                                    or endpoint.getMaxPacketSize()
+                                    > (isochronous_out.getMaxPacketSize())
+                                ):
+                                    isochronous_out = endpoint
+
+                if isochronous_in is not None and isochronous_out is not None:
+                    if (
+                        sco_interface is None
+                        or sco_alternate == 0
+                        and (
+                            isochronous_in.getMaxPacketSize(),
+                            isochronous_out.getMaxPacketSize(),
+                        )
+                        > max_packet_size
+                    ):
+                        sco_interface = setting
+                        max_packet_size = (
+                            isochronous_in.getMaxPacketSize(),
+                            isochronous_out.getMaxPacketSize(),
                         )
 
-    READ_SIZE = 4096
+        # Return if we found at least a compatible ACL interface
+        if acl_interface is not None:
+            return (
+                configuration_index + 1,
+                acl_interface,
+                sco_interface,
+                interrupt_in,
+                bulk_in,
+                isochronous_in,
+                bulk_out,
+                isochronous_out,
+            )
 
-    class UsbPacketSink:
-        def __init__(self, device, acl_out):
+        logger.debug(f'skipping configuration {configuration_index + 1}')
+
+    return None
+
+
+class UsbPacketSink:
+    def __init__(self, device, bulk_out, isochronous_out) -> None:
         self.device = device
-            self.acl_out = acl_out
-            self.acl_out_transfer = device.getTransfer()
-            self.acl_out_transfer_ready = asyncio.Semaphore(1)
-            self.packets = asyncio.Queue[bytes]()  # Queue of packets waiting to be sent
+        self.bulk_out = bulk_out
+        self.isochronous_out = isochronous_out
+        self.bulk_or_control_out_transfer = device.getTransfer()
+        self.isochronous_out_transfer = (
+            device.getTransfer(
+                iso_packets=(
+                    MAX_SCO_PACKET_SIZE // isochronous_out.getMaxPacketSize()
+                    if isochronous_out.getMaxPacketSize()
+                    else 1
+                )
+            )
+            if isochronous_out is not None
+            else None
+        )
+        self.out_transfer_ready = asyncio.Semaphore(1)
+        self.packets: asyncio.Queue[bytes] = (
+            asyncio.Queue()
+        )  # Queue of packets waiting to be sent
         self.loop = asyncio.get_running_loop()
         self.queue_task = None
-            self.cancel_done = self.loop.create_future()
         self.closed = False
 
     def start(self):
@@ -137,13 +266,10 @@ async def open_usb_transport(spec: str) -> Transport:
         self.packets.put_nowait(packet)
 
     def transfer_callback(self, transfer):
-            self.loop.call_soon_threadsafe(self.acl_out_transfer_ready.release)
+        self.loop.call_soon_threadsafe(self.out_transfer_ready.release)
         status = transfer.getStatus()
 
-            # pylint: disable=no-member
-            if status == usb1.TRANSFER_CANCELLED:
-                self.loop.call_soon_threadsafe(self.cancel_done.set_result, None)
-                return
+        logger.debug(f"OUT CALLBACK: {status}")
 
         if status != usb1.TRANSFER_COMPLETED:
             logger.warning(
@@ -154,106 +280,263 @@ async def open_usb_transport(spec: str) -> Transport:
             )
 
     async def process_queue(self):
-            while True:
+        while not self.closed:
             # Wait for a packet to transfer.
             packet = await self.packets.get()
 
             # Wait until we can start a transfer.
-                await self.acl_out_transfer_ready.acquire()
+            await self.out_transfer_ready.acquire()
 
             # Transfer the packet.
             packet_type = packet[0]
+            packet_payload = packet[1:]
+            submitted = False
+            try:
                 if packet_type == hci.HCI_ACL_DATA_PACKET:
-                    self.acl_out_transfer.setBulk(
-                        self.acl_out, packet[1:], callback=self.transfer_callback
+                    self.bulk_or_control_out_transfer.setBulk(
+                        self.bulk_out.getAddress(),
+                        packet_payload,
+                        callback=self.transfer_callback,
                     )
-                    self.acl_out_transfer.submit()
+                    self.bulk_or_control_out_transfer.submit()
+                    submitted = True
                 elif packet_type == hci.HCI_COMMAND_PACKET:
-                    self.acl_out_transfer.setControl(
+                    self.bulk_or_control_out_transfer.setControl(
                         USB_RECIPIENT_DEVICE | USB_REQUEST_TYPE_CLASS,
                         0,
                         0,
                         0,
-                        packet[1:],
+                        packet_payload,
                         callback=self.transfer_callback,
                     )
-                    self.acl_out_transfer.submit()
+                    self.bulk_or_control_out_transfer.submit()
+                    submitted = True
+                elif packet_type == hci.HCI_SYNCHRONOUS_DATA_PACKET:
+                    if self.isochronous_out_transfer is None:
+                        logger.warning(
+                            color('isochronous packets not supported', 'red')
+                        )
+                        self.out_transfer_ready.release()
+                        continue
+
+                    # Setup a list of packet lengths, each up to the max packet size
+                    iso_max_packet_size = self.isochronous_out.getMaxPacketSize()
+                    iso_packet_count = (
+                        len(packet_payload) + iso_max_packet_size - 1
+                    ) // iso_max_packet_size
+                    iso_packet_lengths = [iso_max_packet_size] * (iso_packet_count - 1)
+                    iso_packet_lengths.append(
+                        len(packet_payload) - sum(iso_packet_lengths)
+                    )
+
+                    # Set up and submit the isochronous transfer
+                    self.isochronous_out_transfer.setIsochronous(
+                        self.isochronous_out.getAddress(),
+                        packet_payload,
+                        callback=self.transfer_callback,
+                        iso_transfer_length_list=iso_packet_lengths,
+                    )
+                    self.isochronous_out_transfer.submit()
+                    submitted = True
+                elif packet_type == hci.HCI_ISO_DATA_PACKET:
+                    if self.isochronous_out_transfer is None:
+                        # Workaround: Send ISO packets over Bulk Out when Isochronous endpoints are not enabled
+                        self.bulk_or_control_out_transfer.setBulk(
+                            self.bulk_out.getAddress(),
+                            packet_payload,
+                            callback=self.transfer_callback,
+                        )
+                        self.bulk_or_control_out_transfer.submit()
+                        submitted = True
+                    else:
+                        logger.warning(
+                            color(
+                                'ISO packets over Isochronous endpoints not supported yet',
+                                'red',
+                            )
+                        )
+                        self.out_transfer_ready.release()
+                        continue
                 else:
                     logger.warning(
                         color(f'unsupported packet type {packet_type}', 'red')
                     )
+            except Exception as error:
+                logger.warning(f'!!! exception while submitting transfer: {error}')
+
+            if not submitted:
+                self.out_transfer_ready.release()
 
     def close(self):
         self.closed = True
-            if self.queue_task:
-                self.queue_task.cancel()
 
     async def terminate(self):
-            if not self.closed:
         self.close()
 
+        if self.queue_task:
+            self.queue_task.cancel()
+
         # Empty the packet queue so that we don't send any more data
         while not self.packets.empty():
             self.packets.get_nowait()
 
-            # If we have a transfer in flight, cancel it
-            if self.acl_out_transfer.isSubmitted():
+        # If we have transfers in flight, cancel them
+        for transfer in (
+            self.bulk_or_control_out_transfer,
+            self.isochronous_out_transfer,
+        ):
+            if transfer is None:
+                continue
+
+            if transfer.isSubmitted():
                 # Try to cancel the transfer, but that may fail because it may have
                 # already completed
                 try:
-                    self.acl_out_transfer.cancel()
+                    transfer.cancel()
 
                     logger.debug('waiting for OUT transfer cancellation to be done...')
-                    await self.cancel_done
+                    await self.out_transfer_ready.acquire()
                     logger.debug('OUT transfer cancellation done')
-                except usb1.USBError:
-                    logger.debug('OUT transfer likely already completed')
+                except usb1.USBError as error:
+                    logger.debug(f'OUT transfer likely already completed ({error})')
 
-    class UsbPacketSource(asyncio.Protocol, BaseSource):
-        def __init__(self, device, metadata, acl_in, events_in):
+            try:
+                transfer.close()
+            except usb1.USBError as error:
+                logger.warning(f'failed to close transfer ({error})')
+
+
+READ_SIZE = 4096
+
+
+class PacketSplitter:
+    """Splitter than can parse a byte stream and extract packets that consist of a
+    header and a body, where the header includes an n-byte 'length' field at a
+    certain offset.
+    Extracted packets are emitted by calling a function passed to the constructor,
+    with the full packet (header + body) as argument.
+    """
+
+    def __init__(
+        self, length_offset: int, length_size: int, emit: Callable[[bytes], Any]
+    ) -> None:
+        self.emit = emit
+        self.packet = b''
+        self.length_offset = length_offset
+        self.length_size = length_size
+        self.header_size = length_offset + length_size
+
+    def feed(self, data: bytes) -> None:
+        while data:
+            # Accumulate until we have a complete header
+            if (bytes_needed := self.header_size - len(self.packet)) > 0:
+                self.packet += data[:bytes_needed]
+                data = data[bytes_needed:]
+                if len(self.packet) < self.header_size:
+                    continue
+
+            packet_length = self.header_size + int.from_bytes(
+                self.packet[self.length_offset : self.length_offset + self.length_size],
+                'little',
+            )
+            bytes_needed = packet_length - len(self.packet)
+            self.packet += data[:bytes_needed]
+            data = data[bytes_needed:]
+            if len(self.packet) == packet_length:
+                # Packet complete
+                self.emit(self.packet)
+                self.packet = b''
+
+
+class ScoPacketSplitter(PacketSplitter):
+    def __init__(self, emit: Callable[[bytes], Any]) -> None:
+        # The length field is 1 byte at offset 2 in the HCI SCO packet header
+        super().__init__(length_offset=2, length_size=1, emit=emit)
+
+
+class EventPacketSplitter(PacketSplitter):
+    def __init__(self, emit: Callable[[bytes], Any]) -> None:
+        # The length field is 1 byte at offset 1 in the HCI Event packet header
+        super().__init__(length_offset=1, length_size=1, emit=emit)
+
+
+class AclPacketSplitter(PacketSplitter):
+    def __init__(self, emit: Callable[[bytes], Any]) -> None:
+        # The length field is 2 bytes at offset 2 in the HCI ACL packet header
+        super().__init__(length_offset=2, length_size=2, emit=emit)
+
+
+class UsbPacketSource(asyncio.Protocol, BaseSource):
+    def __init__(self, device, metadata, interrupt_in, bulk_in, isochronous_in):
         super().__init__()
         self.device = device
         self.metadata = metadata
-            self.acl_in = acl_in
-            self.acl_in_transfer = None
-            self.events_in = events_in
-            self.events_in_transfer = None
+        self.interrupt_in = interrupt_in
+        self.interrupt_in_transfer = None
+        self.bulk_in = bulk_in
+        self.bulk_in_transfer = None
+        self.isochronous_in = isochronous_in
+        self.isochronous_in_transfers = []
         self.loop = asyncio.get_running_loop()
         self.queue = asyncio.Queue()
         self.dequeue_task = None
-            self.cancel_done = {
-                hci.HCI_EVENT_PACKET: self.loop.create_future(),
-                hci.HCI_ACL_DATA_PACKET: self.loop.create_future(),
+        self.done = {}
+        self.splitters = {
+            hci.HCI_EVENT_PACKET: EventPacketSplitter(
+                lambda packet: self.queue_packet(hci.HCI_EVENT_PACKET, packet)
+            ),
+            hci.HCI_ACL_DATA_PACKET: AclPacketSplitter(
+                lambda packet: self.queue_packet(hci.HCI_ACL_DATA_PACKET, packet)
+            ),
+            hci.HCI_SYNCHRONOUS_DATA_PACKET: ScoPacketSplitter(
+                lambda packet: self.queue_packet(
+                    hci.HCI_SYNCHRONOUS_DATA_PACKET, packet
+                )
+            ),
         }
         self.closed = False
+        self.lock = threading.Lock()
 
     def start(self):
         # Set up transfer objects for input
-            self.events_in_transfer = device.getTransfer()
-            self.events_in_transfer.setInterrupt(
-                self.events_in,
+        self.interrupt_in_transfer = self.device.getTransfer()
+        self.interrupt_in_transfer.setInterrupt(
+            self.interrupt_in.getAddress(),
             READ_SIZE,
             callback=self.transfer_callback,
             user_data=hci.HCI_EVENT_PACKET,
         )
-            self.events_in_transfer.submit()
+        self.done[self.interrupt_in_transfer] = asyncio.Event()
+        self.interrupt_in_transfer.submit()
 
-            self.acl_in_transfer = device.getTransfer()
-            self.acl_in_transfer.setBulk(
-                self.acl_in,
+        self.bulk_in_transfer = self.device.getTransfer()
+        self.bulk_in_transfer.setBulk(
+            self.bulk_in.getAddress(),
             READ_SIZE,
             callback=self.transfer_callback,
             user_data=hci.HCI_ACL_DATA_PACKET,
         )
-            self.acl_in_transfer.submit()
+        self.done[self.bulk_in_transfer] = asyncio.Event()
+        self.bulk_in_transfer.submit()
+
+        if self.isochronous_in is not None:
+            for _ in range(NUMBER_OF_SCO_IN_TRANSFERS):
+                transfer = self.device.getTransfer(iso_packets=MAX_SCO_IN_PACKETS)
+                transfer.setIsochronous(
+                    self.isochronous_in.getAddress(),
+                    MAX_SCO_IN_PACKETS * self.isochronous_in.getMaxPacketSize(),
+                    callback=self.transfer_callback,
+                    user_data=hci.HCI_SYNCHRONOUS_DATA_PACKET,
+                )
+                self.isochronous_in_transfers.append(transfer)
+                self.done[transfer] = asyncio.Event()
+                transfer.submit()
 
         self.dequeue_task = self.loop.create_task(self.dequeue())
 
-        @property
-        def usb_transfer_submitted(self):
-            return (
-                self.events_in_transfer.isSubmitted()
-                or self.acl_in_transfer.isSubmitted()
+    def queue_packet(self, packet_type: int, packet_data: bytes) -> None:
+        self.loop.call_soon_threadsafe(
+            self.queue.put_nowait, bytes([packet_type]) + packet_data
         )
 
     def transfer_callback(self, transfer):
@@ -261,26 +544,53 @@ async def open_usb_transport(spec: str) -> Transport:
         status = transfer.getStatus()
 
         # pylint: disable=no-member
-            if status == usb1.TRANSFER_COMPLETED:
-                packet = (
-                    bytes([packet_type])
-                    + transfer.getBuffer()[: transfer.getActualLength()]
+        if (
+            packet_type != hci.HCI_SYNCHRONOUS_DATA_PACKET
+            or transfer.getActualLength()
+            or status != usb1.TRANSFER_COMPLETED
+        ):
+            logger.debug(
+                f"IN[{packet_type}] CALLBACK: status={status}, length={transfer.getActualLength()}"
+            )
+        if status == usb1.TRANSFER_COMPLETED:
+            with self.lock:
+                if self.closed:
+                    logger.debug("packet source closed, discarding transfer")
+                elif (splitter := self.splitters.get(packet_type)) is None:
+                    logger.warning(f'no splitter for packet type {packet_type}')
+                else:
+                    if packet_type == hci.HCI_SYNCHRONOUS_DATA_PACKET:
+                        for iso_status, iso_buffer in transfer.iterISO():
+                            if not iso_buffer:
+                                continue
+                            if iso_status:
+                                logger.warning(f"ISO packet status error: {iso_status}")
+                                continue
+                            logger.debug(
+                                "### SCO packet: %d %s",
+                                len(iso_buffer),
+                                iso_buffer.hex(),
+                            )
+                            splitter.feed(iso_buffer)
+                    else:
+                        splitter.feed(
+                            transfer.getBuffer()[: transfer.getActualLength()]
                         )
-                self.loop.call_soon_threadsafe(self.queue.put_nowait, packet)
 
                     # Re-submit the transfer so we can receive more data
+                    try:
                         transfer.submit()
+                    except usb1.USBError as error:
+                        logger.warning(f"Failed to re-submit transfer: {error}")
+                        self.loop.call_soon_threadsafe(self.on_transport_lost)
         elif status == usb1.TRANSFER_CANCELLED:
-                self.loop.call_soon_threadsafe(
-                    self.cancel_done[packet_type].set_result, None
-                )
+            logger.debug(f"IN[{packet_type}] transfer canceled")
+            self.loop.call_soon_threadsafe(self.done[transfer].set)
         else:
             logger.warning(
-                    color(
-                        f'!!! IN[{packet_type}] transfer not completed: status={status}',
-                        'red',
-                    )
+                color(f'!!! IN[{packet_type}] transfer not completed', 'red')
             )
+            self.loop.call_soon_threadsafe(self.done[transfer].set)
             self.loop.call_soon_threadsafe(self.on_transport_lost)
 
     async def dequeue(self):
@@ -293,72 +603,107 @@ async def open_usb_transport(spec: str) -> Transport:
                 try:
                     self.sink.on_packet(packet)
                 except Exception:
-                        logger.exception(
-                            color('!!! Exception in sink.on_packet', 'red')
-                        )
+                    logger.exception(color('!!! Exception in sink.on_packet', 'red'))
 
     def close(self):
+        with self.lock:
             self.closed = True
 
     async def terminate(self):
-            if not self.closed:
         self.close()
 
+        if self.dequeue_task:
             self.dequeue_task.cancel()
 
         # Cancel the transfers
-            for transfer in (self.events_in_transfer, self.acl_in_transfer):
+        for transfer in (
+            self.interrupt_in_transfer,
+            self.bulk_in_transfer,
+            *self.isochronous_in_transfers,
+        ):
+            if transfer is None:
+                continue
+
             if transfer.isSubmitted():
-                    # Try to cancel the transfer, but that may fail because it may have
-                    # already completed
+                # Try to cancel the transfer, but that may fail because it may
+                # have already completed
                 packet_type = transfer.getUserData()
+                assert isinstance(packet_type, int)
                 try:
                     transfer.cancel()
                     logger.debug(
                         f'waiting for IN[{packet_type}] transfer cancellation '
                         'to be done...'
                     )
-                        await self.cancel_done[packet_type]
+                    await self.done[transfer].wait()
                     logger.debug(f'IN[{packet_type}] transfer cancellation done')
-                    except usb1.USBError:
+                except usb1.USBError as error:
                     logger.debug(
-                            f'IN[{packet_type}] transfer likely already completed'
+                        f'IN[{packet_type}] transfer likely already completed '
+                        f'({error})'
                     )
 
-    class UsbTransport(Transport):
-        def __init__(self, context, device, interface, setting, source, sink):
+
+class UsbTransport(Transport):
+    def __init__(self, context, device, acl_interface, sco_interface, source, sink):
         super().__init__(source, sink)
         self.context = context
         self.device = device
-            self.interface = interface
+        self.acl_interface = acl_interface
+        self.sco_interface = sco_interface
         self.loop = asyncio.get_running_loop()
         self.event_loop_done = self.loop.create_future()
+        self.event_loop_should_exit = False
+        self.lock = threading.Lock()
 
         # Get exclusive access
-            device.claimInterface(interface)
+        device.claimInterface(acl_interface.getNumber())
+        if sco_interface is not None:
+            device.claimInterface(sco_interface.getNumber())
 
         # Set the alternate setting if not the default
-            if setting != 0:
-                device.setInterfaceAltSetting(interface, setting)
+        if acl_interface.getAlternateSetting() != 0:
+            logger.debug(
+                f'setting ACL interface {acl_interface.getNumber()} '
+                f'altsetting {acl_interface.getAlternateSetting()}'
+            )
+            device.setInterfaceAltSetting(
+                acl_interface.getNumber(), acl_interface.getAlternateSetting()
+            )
+        if sco_interface is not None and sco_interface.getAlternateSetting() != 0:
+            logger.debug(
+                f'setting SCO interface {sco_interface.getNumber()} '
+                f'altsetting {sco_interface.getAlternateSetting()}'
+            )
+            device.setInterfaceAltSetting(
+                sco_interface.getNumber(), sco_interface.getAlternateSetting()
+            )
 
         # The source and sink can now start
         source.start()
         sink.start()
 
         # Create a thread to process events
-            self.event_thread = threading.Thread(target=self.run)
+        self.event_thread = threading.Thread(target=self.run, daemon=True)
         self.event_thread.start()
 
     def run(self):
         logger.debug('starting USB event loop')
-            while self.source.usb_transfer_submitted:
+        while True:
+            with self.lock:
+                if self.event_loop_should_exit:
+                    logger.debug("USB event loop exit requested")
+                    break
+
             # pylint: disable=no-member
             try:
                 self.context.handleEvents()
             except usb1.USBErrorInterrupted:
                 pass
+            except Exception as error:
+                logger.warning(f'!!! Exception while handling events: {error}')
 
-            logger.debug('USB event loop done')
+        logger.debug('ending USB event loop')
         self.loop.call_soon_threadsafe(self.event_loop_done.set_result, None)
 
     async def close(self):
@@ -366,12 +711,60 @@ async def open_usb_transport(spec: str) -> Transport:
         self.sink.close()
         await self.source.terminate()
         await self.sink.terminate()
-            self.device.releaseInterface(self.interface)
+
+        # We no longer need the event loop to run
+        with self.lock:
+            self.event_loop_should_exit = True
+        self.context.interruptEventHandler()
+
+        self.device.releaseInterface(self.acl_interface.getNumber())
+        if self.sco_interface:
+            self.device.releaseInterface(self.sco_interface.getNumber())
         self.device.close()
         self.context.close()
 
         # Wait for the thread to terminate
+        logger.debug("waiting for USB event loop to be done...")
         await self.event_loop_done
+        logger.debug("USB event loop done")
+
+
+async def open_usb_transport(spec: str) -> Transport:
+    '''
+    Open a USB transport.
+    The moniker string has this syntax:
+    either <index> or
+    <vendor>:<product> or
+    <vendor>:<product>/<serial-number>] or
+    <vendor>:<product>#<index>
+    With <index> as the 0-based index to select amongst all the devices that appear
+    to be supporting Bluetooth HCI (0 being the first one), or
+    Where <vendor> and <product> are the vendor ID and product ID in hexadecimal. The
+    /<serial-number> suffix or #<index> suffix max be specified when more than one
+    device with the same vendor and product identifiers are present.
+
+    Opotionally, the moniker may include a +sco=<alternate> suffix to enable SCO/eSCO
+    and specify the alternate setting to use for SCO/eSCO transfers, with 0 meaning an
+    automatic selection.
+
+    In addition, if the moniker ends with the symbol "!", the device will be used in
+    "forced" mode:
+    the first USB interface of the device will be used, regardless of the interface
+    class/subclass.
+    This may be useful for some devices that use a custom class/subclass but may
+    nonetheless work as-is.
+
+    Examples:
+    0 --> the first BT USB dongle
+    04b4:f901 --> the BT USB dongle with vendor=04b4 and product=f901
+    04b4:f901#2 --> the third USB device with vendor=04b4 and product=f901
+    04b4:f901/00E04C239987 --> the BT USB dongle with vendor=04b4 and product=f901 and
+    serial number 00E04C239987
+    0B05:17CB! --> the BT USB dongle with vendor=0B05 and product=17CB, in "forced"
+    mode.
+    0+sco=0 --> the first BT USB dongle, with SCO enabled using auto-selection.
+    0+sco=5 --> the first BT USB dongle, with SCO enabled using alternate setting 5.
+    '''
 
     # Find the device according to the spec moniker
     load_libusb()
@@ -379,6 +772,7 @@ async def open_usb_transport(spec: str) -> Transport:
     context.open()
     try:
         found = None
+        device = None
 
         if spec.endswith('!'):
             spec = spec[:-1]
@@ -386,6 +780,12 @@ async def open_usb_transport(spec: str) -> Transport:
         else:
             forced_mode = False
 
+        if '+sco=' in spec:
+            spec, sco_alternate_str = spec.split('+sco=')
+            sco_alternate = int(sco_alternate_str)
+        else:
+            sco_alternate = None
+
         if ':' in spec:
             vendor_id, product_id = spec.split(':')
             serial_number = None
@@ -461,76 +861,41 @@ async def open_usb_transport(spec: str) -> Transport:
 
         logger.debug(f'USB Device: {found}')
 
-        # Look for the first interface with the right class and endpoints
-        def find_endpoints(device):
-            # pylint: disable-next=too-many-nested-blocks
-            for configuration_index, configuration in enumerate(device):
-                interface = None
-                for interface in configuration:
-                    setting = None
-                    for setting in interface:
-                        if (
-                            not forced_mode
-                            and (
-                                setting.getClass(),
-                                setting.getSubClass(),
-                                setting.getProtocol(),
-                            )
-                            != USB_BT_HCI_CLASS_TUPLE
-                        ):
-                            continue
-
-                        events_in = None
-                        acl_in = None
-                        acl_out = None
-                        for endpoint in setting:
-                            attributes = endpoint.getAttributes()
-                            address = endpoint.getAddress()
-                            if attributes & 0x03 == USB_ENDPOINT_TRANSFER_TYPE_BULK:
-                                if address & USB_ENDPOINT_IN and acl_in is None:
-                                    acl_in = address
-                                elif acl_out is None:
-                                    acl_out = address
-                            elif (
-                                attributes & 0x03
-                                == USB_ENDPOINT_TRANSFER_TYPE_INTERRUPT
-                            ):
-                                if address & USB_ENDPOINT_IN and events_in is None:
-                                    events_in = address
-
-                        # Return if we found all 3 endpoints
-                        if (
-                            acl_in is not None
-                            and acl_out is not None
-                            and events_in is not None
-                        ):
-                            return (
-                                configuration_index + 1,
-                                setting.getNumber(),
-                                setting.getAlternateSetting(),
-                                acl_in,
-                                acl_out,
-                                events_in,
-                            )
-
-                        logger.debug(
-                            f'skipping configuration {configuration_index + 1} / '
-                            f'interface {setting.getNumber()}'
-                        )
-
-            return None
-
-        endpoints = find_endpoints(found)
+        assert device is not None
+        endpoints = find_endpoints(device, forced_mode, sco_alternate)
         if endpoints is None:
             raise TransportInitError('no compatible interface found for device')
-        (configuration, interface, setting, acl_in, acl_out, events_in) = endpoints
+        (
+            configuration,
+            acl_interface,
+            sco_interface,
+            interrupt_in,
+            bulk_in,
+            isochronous_in,
+            bulk_out,
+            isochronous_out,
+        ) = endpoints
+        acl_interface_info = (
+            f'acl_interface={acl_interface.getNumber()}/'
+            f'{acl_interface.getAlternateSetting()}'
+        )
+        sco_interface_info = (
+            '<none>'
+            if sco_interface is None
+            else (
+                f'sco_interface={sco_interface.getNumber()}/'
+                f'{sco_interface.getAlternateSetting()}'
+            )
+        )
         logger.debug(
             f'selected endpoints: configuration={configuration}, '
-            f'interface={interface}, '
-            f'setting={setting}, '
-            f'acl_in=0x{acl_in:02X}, '
-            f'acl_out=0x{acl_out:02X}, '
-            f'events_in=0x{events_in:02X}, '
+            f'acl_interface={acl_interface_info}, '
+            f'sco_interface={sco_interface_info}, '
+            f'interrupt_in=0x{interrupt_in.getAddress():02X}, '
+            f'bulk_in=0x{bulk_in.getAddress():02X}, '
+            f'bulk_out=0x{bulk_out.getAddress():02X}, '
+            f'isochronous_in=0x{isochronous_in.getAddress() if isochronous_in else 0:02X}, '
+            f'isochronous_out=0x{isochronous_out.getAddress() if isochronous_out else 0:02X}'
         )
 
         device_metadata = {
@@ -562,9 +927,11 @@ async def open_usb_transport(spec: str) -> Transport:
             except usb1.USBError:
                 logger.warning('failed to set configuration')
 
-        source = UsbPacketSource(device, device_metadata, acl_in, events_in)
-        sink = UsbPacketSink(device, acl_out)
-        return UsbTransport(context, device, interface, setting, source, sink)
+        source = UsbPacketSource(
+            device, device_metadata, interrupt_in, bulk_in, isochronous_in
+        )
+        sink = UsbPacketSink(device, bulk_out, isochronous_out)
+        return UsbTransport(context, device, acl_interface, sco_interface, source, sink)
     except usb1.USBError as error:
         logger.warning(color(f'!!! failed to open USB device: {error}', 'red'))
         context.close()

examples/run_avrcp.py

@@ -133,10 +133,10 @@ def on_avrcp_start(
     utils.AsyncRunner.spawn(get_supported_events())
 
     async def monitor_track_changed() -> None:
-        async for identifier in avrcp_protocol.monitor_track_changed():
-            print("TRACK CHANGED:", identifier.hex())
+        async for uid in avrcp_protocol.monitor_track_changed():
+            print("TRACK CHANGED:", hex(uid))
             websocket_server.send_message(
-                {"type": "track-changed", "params": {"identifier": identifier.hex()}}
+                {"type": "track-changed", "params": {"identifier": hex(uid)}}
             )
 
     async def monitor_playback_status() -> None:

examples/run_gatt_client_and_server.py

@@ -83,6 +83,7 @@ async def main() -> None:
         GATT_DEVICE_INFORMATION_SERVICE, [manufacturer_name_characteristic]
     )
     server_device.add_service(device_info_service)
+    await server_device.start_advertising()
 
     # Connect the client to the server
     connection = await client_device.connect(server_device.random_address)

examples/run_hfp_handsfree.py

@@ -20,17 +20,119 @@ import contextlib
 import functools
 import json
 import sys
+import wave
 
 import websockets.asyncio.server
 
 import bumble.logging
 from bumble import hci, hfp, rfcomm
-from bumble.device import Connection, Device
+from bumble.device import Connection, Device, ScoLink
 from bumble.hfp import HfProtocol
 from bumble.transport import open_transport
 
+# -----------------------------------------------------------------------------
 ws: websockets.asyncio.server.ServerConnection | None = None
 hf_protocol: HfProtocol | None = None
+input_wav: wave.Wave_read | None = None
+output_wav: wave.Wave_write | None = None
+
+
+# -----------------------------------------------------------------------------
+def on_audio_packet(packet: hci.HCI_SynchronousDataPacket) -> None:
+    if (
+        packet.packet_status
+        != hci.HCI_SynchronousDataPacket.Status.CORRECTLY_RECEIVED_DATA
+    ):
+        print('!!! discarding packet with status ', packet.packet_status.name)
+        return
+
+    frame_count = len(packet.data) // 2
+    print(f">>> received {frame_count} PCM samples")
+
+    if output_wav:
+        # Save the PCM audio to the output
+        output_wav.writeframes(packet.data)
+
+    if input_wav and hf_protocol:
+        # Send PCM audio from the input, same amount as what was received
+        while not (pcm_data := input_wav.readframes(frame_count)):
+            input_wav.setpos(0)  # Loop
+        print(f">>> sending {frame_count} PCM samples")
+        hf_protocol.dlc.multiplexer.l2cap_channel.connection.device.host.send_sco_sdu(
+            connection_handle=packet.connection_handle,
+            sdu=pcm_data,
+        )
+
+
+# -----------------------------------------------------------------------------
+def on_sco_connection(link: ScoLink) -> None:
+    print('### SCO connection established:', link)
+    if link.air_mode == hci.CodecID.TRANSPARENT:
+        print("@@@ The controller does not encode/decode voice")
+        return
+
+    link.sink = on_audio_packet
+
+
+# -----------------------------------------------------------------------------
+def on_sco_request(
+    link_type: int, connection: Connection, protocol: HfProtocol
+) -> None:
+    if link_type == hci.HCI_Connection_Complete_Event.LinkType.SCO:
+        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]
+    else:
+        raise RuntimeError("unknown active codec")
+
+    if connection.device.host.supports_command(
+        hci.HCI_ENHANCED_ACCEPT_SYNCHRONOUS_CONNECTION_REQUEST_COMMAND
+    ):
+        connection.cancel_on_disconnection(
+            connection.device.send_async_command(
+                hci.HCI_Enhanced_Accept_Synchronous_Connection_Request_Command(
+                    bd_addr=connection.peer_address, **esco_parameters.asdict()
+                )
+            )
+        )
+    elif connection.device.host.supports_command(
+        hci.HCI_ACCEPT_SYNCHRONOUS_CONNECTION_REQUEST_COMMAND
+    ):
+        connection.cancel_on_disconnection(
+            connection.device.send_async_command(
+                hci.HCI_Accept_Synchronous_Connection_Request_Command(
+                    bd_addr=connection.peer_address,
+                    transmit_bandwidth=esco_parameters.transmit_bandwidth,
+                    receive_bandwidth=esco_parameters.receive_bandwidth,
+                    max_latency=esco_parameters.max_latency,
+                    voice_setting=int(
+                        hci.VoiceSetting(
+                            input_sample_size=hci.VoiceSetting.InputSampleSize.SIZE_16_BITS,
+                            input_data_format=hci.VoiceSetting.InputDataFormat.TWOS_COMPLEMENT,
+                        )
+                    ),
+                    retransmission_effort=esco_parameters.retransmission_effort,
+                    packet_type=esco_parameters.packet_type,
+                )
+            )
+        )
+    else:
+        print('!!! no supported command for SCO connection request')
+        return
+
+    global output_wav
+    if output_wav:
+        output_wav.setnchannels(1)
+        output_wav.setsampwidth(2)
+        match protocol.active_codec:
+            case hfp.AudioCodec.CVSD:
+                output_wav.setframerate(8000)
+            case hfp.AudioCodec.MSBC:
+                output_wav.setframerate(16000)
+
+    connection.on('sco_connection', on_sco_connection)
 
 
 # -----------------------------------------------------------------------------
@@ -40,59 +142,47 @@ def on_dlc(dlc: rfcomm.DLC, configuration: hfp.HfConfiguration):
     hf_protocol = HfProtocol(dlc, configuration)
     asyncio.create_task(hf_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.LinkType.SCO:
-                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
-                ]
-            else:
-                raise RuntimeError("unknown active codec")
-
-            connection.cancel_on_disconnection(
-                connection.device.send_command(
-                    hci.HCI_Enhanced_Accept_Synchronous_Connection_Request_Command(
-                        bd_addr=connection.peer_address, **esco_parameters.asdict()
+    connection = dlc.multiplexer.l2cap_channel.connection
+    handler = functools.partial(
+        on_sco_request,
+        connection=connection,
+        protocol=hf_protocol,
     )
-                )
-            )
-
-    handler = functools.partial(on_sco_request, protocol=hf_protocol)
-    dlc.multiplexer.l2cap_channel.connection.device.on('sco_request', handler)
+    connection.on('sco_request', handler)
     dlc.multiplexer.l2cap_channel.once(
         'close',
-        lambda: dlc.multiplexer.l2cap_channel.connection.device.remove_listener(
-            'sco_request', handler
-        ),
+        lambda: connection.remove_listener('sco_request', handler),
     )
 
-    def on_ag_indicator(indicator):
+    hf_protocol.on('ag_indicator', on_ag_indicator)
+    hf_protocol.on('codec_negotiation', on_codec_negotiation)
+
+
+# -----------------------------------------------------------------------------
+def on_ag_indicator(indicator):
     global ws
     if ws:
         asyncio.create_task(ws.send(str(indicator)))
 
-    hf_protocol.on('ag_indicator', on_ag_indicator)
+
+# -----------------------------------------------------------------------------
+def on_codec_negotiation(codec: hfp.AudioCodec):
+    print(f'### Negotiated codec: {codec.name}')
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
-    if len(sys.argv) < 3:
-        print('Usage: run_classic_hfp.py <device-config> <transport-spec>')
-        print('example: run_classic_hfp.py classic2.json usb:04b4:f901')
+async def run(device: Device, codec: str | None) -> None:
+    if codec is None:
+        supported_audio_codecs = [hfp.AudioCodec.CVSD, hfp.AudioCodec.MSBC]
+    else:
+        if codec == 'cvsd':
+            supported_audio_codecs = [hfp.AudioCodec.CVSD]
+        elif codec == 'msbc':
+            supported_audio_codecs = [hfp.AudioCodec.MSBC]
+        else:
+            print('Unknown codec: ', codec)
             return
 
-    print('<<< connecting to HCI...')
-    async with await open_transport(sys.argv[2]) as hci_transport:
-        print('<<< connected')
-
     # Hands-Free profile configuration.
     # TODO: load configuration from file.
     configuration = hfp.HfConfiguration(
@@ -108,18 +198,9 @@ async def main() -> None:
         supported_hf_indicators=[
             hfp.HfIndicator.BATTERY_LEVEL,
         ],
-            supported_audio_codecs=[
-                hfp.AudioCodec.CVSD,
-                hfp.AudioCodec.MSBC,
-            ],
+        supported_audio_codecs=supported_audio_codecs,
     )
 
-        # Create a device
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
-        device.classic_enabled = True
-
     # Create and register a server
     rfcomm_server = rfcomm.Server(device)
 
@@ -129,9 +210,7 @@ async def main() -> None:
 
     # Advertise the HFP RFComm channel in the SDP
     device.sdp_service_records = {
-            0x00010001: hfp.make_hf_sdp_records(
-                0x00010001, channel_number, configuration
-            )
+        0x00010001: hfp.make_hf_sdp_records(0x00010001, channel_number, configuration)
     }
 
     # Let's go!
@@ -167,7 +246,59 @@ async def main() -> None:
 
     await websockets.asyncio.server.serve(serve, 'localhost', 8989)
 
-        await hci_transport.source.terminated
+    await asyncio.get_running_loop().create_future()  # run forever
+
+
+# -----------------------------------------------------------------------------
+async def main() -> None:
+    if len(sys.argv) < 3:
+        print(
+            'Usage: run_hfp_handsfree.py <device-config> <transport-spec> '
+            '[codec] [input] [output]'
+        )
+        print('example: run_hfp_handsfree.py classic2.json usb:0')
+        return
+
+    device_config = sys.argv[1]
+    transport_spec = sys.argv[2]
+
+    codec: str | None = None
+    if len(sys.argv) >= 4:
+        codec = sys.argv[3]
+
+    input_file_name: str | None = None
+    if len(sys.argv) >= 5:
+        input_file_name = sys.argv[4]
+
+    output_file_name: str | None = None
+    if len(sys.argv) >= 6:
+        output_file_name = sys.argv[5]
+
+    global input_wav, output_wav
+    input_cm: contextlib.AbstractContextManager[wave.Wave_read | None] = (
+        wave.open(input_file_name, "rb")
+        if input_file_name
+        else contextlib.nullcontext(None)
+    )
+    output_cm: contextlib.AbstractContextManager[wave.Wave_write | None] = (
+        wave.open(output_file_name, "wb")
+        if output_file_name
+        else contextlib.nullcontext(None)
+    )
+    with input_cm as input_wav, output_cm as output_wav:
+        if input_wav and input_wav.getnchannels() != 1:
+            print("Mono input required")
+            return
+        if input_wav and input_wav.getsampwidth() != 2:
+            print("16-bit input required")
+            return
+
+        async with await open_transport(transport_spec) as transport:
+            device = Device.from_config_file_with_hci(
+                device_config, transport.source, transport.sink
+            )
+            device.classic_enabled = True
+            await run(device, codec)
 
 
 # -----------------------------------------------------------------------------

pyproject.toml

@@ -13,13 +13,12 @@ authors = [{ name = "Google", email = "bumble-dev@google.com" }]
 requires-python = ">=3.10"
 dependencies = [
     "aiohttp ~= 3.8; platform_system!='Emscripten'",
-    "appdirs >= 1.4; platform_system!='Emscripten'",
     "click >= 8.1.3; platform_system!='Emscripten'",
     "cryptography >= 44.0.3; platform_system!='Emscripten' and platform_system!='Android'",
     # Pyodide bundles a version of cryptography that is built for wasm, which may not match the
     # versions available on PyPI. Relax the version requirement since it's better than being
     # completely unable to import the package in case of version mismatch.
-    "cryptography >= 44.0.3; platform_system=='Emscripten'",
+    "cryptography >= 39.0.0; platform_system=='Emscripten'",
     # Android wheels for cryptography are not yet available on PyPI, so chaquopy uses
     # the builds from https://chaquo.com/pypi-13.1/cryptography/. But these are not regually
     # updated. Relax the version requirement since it's better than being completely unable
@@ -37,7 +36,7 @@ dependencies = [
     "pyserial-asyncio >= 0.5; platform_system!='Emscripten'",
     "pyserial >= 3.5; platform_system!='Emscripten'",
     "pyusb >= 1.2; platform_system!='Emscripten'",
-    "tomli ~= 2.2.1; platform_system!='Emscripten'",    
+    "tomli ~= 2.2.1; platform_system!='Emscripten' and python_version<'3.11'",
     "websockets >= 15.0.1; platform_system!='Emscripten'",
 ]
 

rust/Cargo.lock

@@ -221,9 +221,9 @@ checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
 
 [[package]]
 name = "bytes"
-version = "1.5.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "cc"

rust/Cargo.toml

@@ -30,7 +30,7 @@ hex = "0.4.3"
 itertools = "0.11.0"
 lazy_static = "1.4.0"
 thiserror = "1.0.41"
-bytes = "1.5.0"
+bytes = "1.11.1"
 pdl-derive = "0.2.0"
 pdl-runtime = "0.2.0"
 futures = "0.3.28"

tasks.py

@@ -170,7 +170,9 @@ def format_code(ctx, check=False, diff=False):
 @task
 def check_types(ctx):
     checklist = ["apps", "bumble", "examples", "tests", "tasks.py"]
+    print(">>> Running the type checker...")
     try:
+        print("+++ Checking with mypy...")
         ctx.run(f"mypy {' '.join(checklist)}")
     except UnexpectedExit as exc:
         print("Please check your code against the mypy messages.")

tests/avdtp_test.py

@@ -120,6 +120,31 @@ def test_messages(message: avdtp.Message):
     assert message.payload == parsed.payload
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.parametrize(
+    'pdu',
+    (
+        b'',  # empty PDU — would IndexError on pdu[0]
+        b'\x00',  # 1-byte SINGLE_PACKET — would IndexError on pdu[1]
+        b'\x04',  # 1-byte START_PACKET — would IndexError on pdu[1]
+        b'\x44\x10',  # 2-byte START_PACKET — would IndexError on pdu[2]
+    ),
+)
+def test_message_assembler_truncated_pdu(pdu: bytes):
+    """Truncated AVDTP PDUs from a remote peer must NOT raise IndexError —
+    same DoS class as #912 (ATT empty PDU). The assembler is required to
+    log + drop and stay alive so the L2CAP channel survives."""
+    completed = []
+
+    def callback(transaction_label, message):
+        completed.append((transaction_label, message))
+
+    assembler = avdtp.MessageAssembler(callback)
+    # Must not raise; nothing should be delivered to callback either.
+    assembler.on_pdu(pdu)
+    assert not completed
+
+
 # -----------------------------------------------------------------------------
 def test_rtp():
     packet = bytes.fromhex(

tests/avrcp_test.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import asyncio
 import struct
 from collections.abc import Sequence
+from unittest import mock
 
 import pytest
 
@@ -118,8 +119,6 @@ class TwoDevices(test_utils.TwoDevices):
             scope=avrcp.Scope.NOW_PLAYING,
             uid=0,
             uid_counter=1,
-            start_item=0,
-            end_item=0,
             attributes=[avrcp.MediaAttributeId.DEFAULT_COVER_ART],
         ),
         avrcp.GetTotalNumberOfItemsCommand(scope=avrcp.Scope.NOW_PLAYING),
@@ -136,7 +135,7 @@ def test_command(command: avrcp.Command):
     "event,",
     [
         avrcp.UidsChangedEvent(uid_counter=7),
-        avrcp.TrackChangedEvent(identifier=b'12356'),
+        avrcp.TrackChangedEvent(uid=12356),
         avrcp.VolumeChangedEvent(volume=9),
         avrcp.PlaybackStatusChangedEvent(play_status=avrcp.PlayStatus.PLAYING),
         avrcp.AddressedPlayerChangedEvent(
@@ -581,6 +580,87 @@ async def test_get_supported_company_ids():
         assert supported_company_ids == [avrcp.AVRCP_BLUETOOTH_SIG_COMPANY_ID]
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_list_player_application_settings():
+    two_devices: TwoDevices = await TwoDevices.create_with_avdtp()
+
+    expected_settings = {
+        avrcp.ApplicationSetting.AttributeId.REPEAT_MODE: [
+            avrcp.ApplicationSetting.RepeatModeStatus.ALL_TRACK_REPEAT,
+            avrcp.ApplicationSetting.RepeatModeStatus.GROUP_REPEAT,
+            avrcp.ApplicationSetting.RepeatModeStatus.SINGLE_TRACK_REPEAT,
+            avrcp.ApplicationSetting.RepeatModeStatus.OFF,
+        ],
+        avrcp.ApplicationSetting.AttributeId.SHUFFLE_ON_OFF: [
+            avrcp.ApplicationSetting.ShuffleOnOffStatus.OFF,
+            avrcp.ApplicationSetting.ShuffleOnOffStatus.ALL_TRACKS_SHUFFLE,
+            avrcp.ApplicationSetting.ShuffleOnOffStatus.GROUP_SHUFFLE,
+        ],
+    }
+    two_devices.protocols[1].delegate = avrcp.Delegate(
+        supported_player_app_settings=expected_settings
+    )
+    actual_settings = await two_devices.protocols[
+        0
+    ].list_supported_player_app_settings()
+    assert actual_settings == expected_settings
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_get_set_player_app_settings():
+    two_devices: TwoDevices = await TwoDevices.create_with_avdtp()
+
+    delegate = two_devices.protocols[1].delegate
+    await two_devices.protocols[0].send_avrcp_command(
+        avc.CommandFrame.CommandType.CONTROL,
+        avrcp.SetPlayerApplicationSettingValueCommand(
+            attribute=[
+                avrcp.ApplicationSetting.AttributeId.REPEAT_MODE,
+                avrcp.ApplicationSetting.AttributeId.SHUFFLE_ON_OFF,
+            ],
+            value=[
+                avrcp.ApplicationSetting.RepeatModeStatus.ALL_TRACK_REPEAT,
+                avrcp.ApplicationSetting.ShuffleOnOffStatus.GROUP_SHUFFLE,
+            ],
+        ),
+    )
+    expected_settings = {
+        avrcp.ApplicationSetting.AttributeId.REPEAT_MODE: avrcp.ApplicationSetting.RepeatModeStatus.ALL_TRACK_REPEAT,
+        avrcp.ApplicationSetting.AttributeId.SHUFFLE_ON_OFF: avrcp.ApplicationSetting.ShuffleOnOffStatus.GROUP_SHUFFLE,
+    }
+    assert delegate.player_app_settings == expected_settings
+
+    actual_settings = await two_devices.protocols[0].get_player_app_settings(
+        [
+            avrcp.ApplicationSetting.AttributeId.REPEAT_MODE,
+            avrcp.ApplicationSetting.AttributeId.SHUFFLE_ON_OFF,
+        ]
+    )
+    assert actual_settings == expected_settings
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_play_item():
+    two_devices: TwoDevices = await TwoDevices.create_with_avdtp()
+
+    delegate = two_devices.protocols[1].delegate
+
+    with mock.patch.object(delegate, delegate.play_item.__name__) as play_item_mock:
+        await two_devices.protocols[0].send_avrcp_command(
+            avc.CommandFrame.CommandType.CONTROL,
+            avrcp.PlayItemCommand(
+                scope=avrcp.Scope.MEDIA_PLAYER_LIST, uid=0, uid_counter=1
+            ),
+        )
+
+        play_item_mock.assert_called_once_with(
+            scope=avrcp.Scope.MEDIA_PLAYER_LIST, uid=0, uid_counter=1
+        )
+
+
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
 async def test_monitor_volume():
@@ -635,6 +715,102 @@ async def test_monitor_now_playing_content():
         await anext(now_playing_iter)
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_monitor_track_changed():
+    two_devices = await TwoDevices.create_with_avdtp()
+
+    delegate = two_devices.protocols[1].delegate = avrcp.Delegate(
+        [avrcp.EventId.TRACK_CHANGED]
+    )
+    delegate.current_track_uid = avrcp.TrackChangedEvent.NO_TRACK
+    track_iter = two_devices.protocols[0].monitor_track_changed()
+
+    # Interim
+    assert (await anext(track_iter)) == avrcp.TrackChangedEvent.NO_TRACK
+    # Changed
+    two_devices.protocols[1].notify_track_changed(1)
+    assert (await anext(track_iter)) == 1
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_monitor_uid_changed():
+    two_devices = await TwoDevices.create_with_avdtp()
+
+    delegate = two_devices.protocols[1].delegate = avrcp.Delegate(
+        [avrcp.EventId.UIDS_CHANGED]
+    )
+    delegate.uid_counter = 0
+    uid_iter = two_devices.protocols[0].monitor_uids()
+
+    # Interim
+    assert (await anext(uid_iter)) == 0
+    # Changed
+    two_devices.protocols[1].notify_uids_changed(1)
+    assert (await anext(uid_iter)) == 1
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_monitor_addressed_player():
+    two_devices = await TwoDevices.create_with_avdtp()
+
+    delegate = two_devices.protocols[1].delegate = avrcp.Delegate(
+        [avrcp.EventId.ADDRESSED_PLAYER_CHANGED]
+    )
+    delegate.uid_counter = 0
+    delegate.addressed_player_id = 0
+    addressed_player_iter = two_devices.protocols[0].monitor_addressed_player()
+
+    # Interim
+    assert (
+        await anext(addressed_player_iter)
+    ) == avrcp.AddressedPlayerChangedEvent.Player(player_id=0, uid_counter=0)
+    # Changed
+    two_devices.protocols[1].notify_addressed_player_changed(
+        avrcp.AddressedPlayerChangedEvent.Player(player_id=1, uid_counter=1)
+    )
+    assert (
+        await anext(addressed_player_iter)
+    ) == avrcp.AddressedPlayerChangedEvent.Player(player_id=1, uid_counter=1)
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_monitor_player_app_settings():
+    two_devices = await TwoDevices.create_with_avdtp()
+
+    delegate = two_devices.protocols[1].delegate = avrcp.Delegate(
+        supported_events=[avrcp.EventId.PLAYER_APPLICATION_SETTING_CHANGED]
+    )
+    delegate.player_app_settings = {
+        avrcp.ApplicationSetting.AttributeId.REPEAT_MODE: avrcp.ApplicationSetting.RepeatModeStatus.ALL_TRACK_REPEAT
+    }
+    settings_iter = two_devices.protocols[0].monitor_player_application_settings()
+
+    # Interim
+    interim = await anext(settings_iter)
+    assert interim[0].attribute_id == avrcp.ApplicationSetting.AttributeId.REPEAT_MODE
+    assert (
+        interim[0].value_id
+        == avrcp.ApplicationSetting.RepeatModeStatus.ALL_TRACK_REPEAT
+    )
+
+    # Changed
+    two_devices.protocols[1].notify_player_application_settings_changed(
+        [
+            avrcp.PlayerApplicationSettingChangedEvent.Setting(
+                avrcp.ApplicationSetting.AttributeId.REPEAT_MODE,
+                avrcp.ApplicationSetting.RepeatModeStatus.GROUP_REPEAT,
+            )
+        ]
+    )
+    changed = await anext(settings_iter)
+    assert changed[0].attribute_id == avrcp.ApplicationSetting.AttributeId.REPEAT_MODE
+    assert changed[0].value_id == avrcp.ApplicationSetting.RepeatModeStatus.GROUP_REPEAT
+
+
 # -----------------------------------------------------------------------------
 if __name__ == '__main__':
     test_frame_parser()

tests/core_test.py

@@ -73,6 +73,14 @@ def test_uuid_to_hex_str() -> None:
     )
 
 
+# -----------------------------------------------------------------------------
+def test_uuid_hash() -> None:
+    uuid = UUID("1234")
+    uuid_128_bytes = UUID.from_bytes(uuid.to_bytes(force_128=True))
+    assert uuid in {uuid_128_bytes}
+    assert uuid_128_bytes in {uuid}
+
+
 # -----------------------------------------------------------------------------
 def test_appearance() -> None:
     a = Appearance(Appearance.Category.COMPUTER, Appearance.ComputerSubcategory.LAPTOP)

tests/device_test.py

@@ -309,6 +309,27 @@ async def test_legacy_advertising_disconnection(auto_restart):
         assert not devices[0].is_advertising
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_le_multiple_connects():
+    devices = TwoDevices()
+    for controller in devices.controllers:
+        controller.le_features |= hci.LeFeatureMask.LE_EXTENDED_ADVERTISING
+    for dev in devices:
+        await dev.power_on()
+    await devices[0].start_advertising(auto_restart=True, advertising_interval_min=1.0)
+
+    connection = await devices[1].connect(devices[0].random_address)
+    await connection.disconnect()
+
+    await async_barrier()
+    await async_barrier()
+
+    # a second connection attempt is working
+    connection = await devices[1].connect(devices[0].random_address)
+    await connection.disconnect()
+
+
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
 async def test_advertising_and_scanning():
@@ -445,7 +466,9 @@ async def test_get_remote_le_features():
     devices = TwoDevices()
     await devices.setup_connection()
 
-    assert (await devices.connections[0].get_remote_le_features()) is not None
+    assert (
+        await devices.connections[0].get_remote_le_features()
+    ) == devices.controllers[1].le_features
 
 
 # -----------------------------------------------------------------------------
@@ -803,6 +826,22 @@ async def test_remote_name_request():
     assert actual_name == expected_name
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_get_remote_classic_features():
+    devices = TwoDevices()
+    devices[0].classic_enabled = True
+    devices[1].classic_enabled = True
+    await devices[0].power_on()
+    await devices[1].power_on()
+    connection = await devices[0].connect_classic(devices[1].public_address)
+
+    assert (
+        await asyncio.wait_for(connection.get_remote_classic_features(), _TIMEOUT)
+        == devices.controllers[1].lmp_features
+    )
+
+
 # -----------------------------------------------------------------------------
 async def run_test_device():
     await test_device_connect_parallel()

tests/host_test.py

@@ -22,6 +22,7 @@ import unittest.mock
 
 import pytest
 
+from bumble import controller, hci
 from bumble.controller import Controller
 from bumble.hci import (
     HCI_AclDataPacket,
@@ -49,34 +50,27 @@ logger = logging.getLogger(__name__)
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    'supported_commands, lmp_features',
+    'supported_commands, max_lmp_features_page_number',
     [
-        (
-            # Default commands
-            '2000800000c000000000e4000000a822000000000000040000f7ffff7f000000'
-            '30f0f9ff01008004000000000000000000000000000000000000000000000000',
-            # Only LE LMP feature
-            '0000000060000000',
-        ),
+        (controller.Controller.supported_commands, 0),
         (
             # All commands
-            'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
-            'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+            set(hci.HCI_Command.command_names.keys()),
             # 3 pages of LMP features
-            '000102030405060708090A0B0C0D0E0F011112131415161718191A1B1C1D1E1F',
+            2,
         ),
     ],
 )
-async def test_reset(supported_commands: str, lmp_features: str):
+async def test_reset(supported_commands: set[int], max_lmp_features_page_number: int):
     controller = Controller('C')
-    controller.supported_commands = bytes.fromhex(supported_commands)
-    controller.lmp_features = bytes.fromhex(lmp_features)
+    controller.supported_commands = supported_commands
+    controller.lmp_features_max_page_number = max_lmp_features_page_number
     host = Host(controller, AsyncPipeSink(controller))
 
     await host.reset()
 
-    assert host.local_lmp_features == int.from_bytes(
-        bytes.fromhex(lmp_features), 'little'
+    assert host.local_lmp_features == (
+        controller.lmp_features & ~(1 << (64 * max_lmp_features_page_number + 1))
     )
 
 
@@ -177,13 +171,14 @@ class Source:
 
 
 class Sink:
-    response: HCI_Event
+    response: HCI_Event | None
 
-    def __init__(self, source: Source, response: HCI_Event) -> None:
+    def __init__(self, source: Source, response: HCI_Event | None) -> None:
         self.source = source
         self.response = response
 
     def on_packet(self, packet: bytes) -> None:
+        if self.response is not None:
             self.source.sink.on_packet(bytes(self.response))
 
 
@@ -234,6 +229,23 @@ async def test_send_sync_command() -> None:
     assert isinstance(response3.return_parameters, HCI_GenericReturnParameters)
 
 
+@pytest.mark.asyncio
+async def test_send_sync_command_timeout() -> None:
+    source = Source()
+    sink = Sink(source, None)
+
+    host = Host(source, sink)
+    host.ready = True
+
+    with pytest.raises(asyncio.TimeoutError):
+        await host.send_sync_command(HCI_Reset_Command(), response_timeout=0.01)
+
+    # The sending semaphore should have been released, so this should not block
+    # indefinitely
+    with pytest.raises(asyncio.TimeoutError):
+        await host.send_sync_command(hci.HCI_Reset_Command(), response_timeout=0.01)
+
+
 @pytest.mark.asyncio
 async def test_send_async_command() -> None:
     source = Source()

tests/keystore_test.py

@@ -21,6 +21,7 @@ import logging
 import os
 import pathlib
 import tempfile
+from unittest import mock
 
 import pytest
 
@@ -179,11 +180,55 @@ async def test_default_namespace(temporary_file):
     assert keys.irk.value == bytes.fromhex('e7b2543b206e4e46b44f9e51dad22bd1')
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_no_filename(tmp_path):
+    import platformdirs
+
+    with mock.patch.object(platformdirs, 'user_data_path', return_value=tmp_path):
+        # Case 1: no namespace, no filename
+        keystore = JsonKeyStore(None, None)
+        expected_directory = tmp_path / 'Pairing'
+        expected_filename = expected_directory / 'keys.json'
+        assert keystore.directory_name == expected_directory
+        assert keystore.filename == expected_filename
+
+        # Save some data
+        keys = PairingKeys()
+        ltk = bytes([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
+        keys.ltk = PairingKeys.Key(ltk)
+        await keystore.update('foo', keys)
+        assert expected_filename.exists()
+
+        # Load back
+        keystore2 = JsonKeyStore(None, None)
+        foo = await keystore2.get('foo')
+        assert foo is not None
+        assert foo.ltk.value == ltk
+
+        # Case 2: namespace, no filename
+        keystore3 = JsonKeyStore('my:namespace', None)
+        # safe_name = 'my-namespace' (lower is already 'my:namespace', then replace ':' with '-')
+        expected_filename3 = expected_directory / 'my-namespace.json'
+        assert keystore3.filename == expected_filename3
+
+        # Save some data
+        await keystore3.update('bar', keys)
+        assert expected_filename3.exists()
+
+        # Load back
+        keystore4 = JsonKeyStore('my:namespace', None)
+        bar = await keystore4.get('bar')
+        assert bar is not None
+        assert bar.ltk.value == ltk
+
+
 # -----------------------------------------------------------------------------
 async def run_tests():
     await test_basic()
     await test_parsing()
     await test_default_namespace()
+    await test_no_filename()
 
 
 # -----------------------------------------------------------------------------

tests/sdp_test.py

@@ -18,9 +18,11 @@
 import asyncio
 import logging
 import os
+import re
 
 import pytest
 
+from bumble import sdp
 from bumble.core import BT_L2CAP_PROTOCOL_ID, UUID
 from bumble.sdp import (
     SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
@@ -206,6 +208,16 @@ def sdp_records(record_count=1):
     }
 
 
+# -----------------------------------------------------------------------------
+def test_pdu_parameter_length(caplog) -> None:
+    caplog.set_level(logging.WARNING)
+    pdu = sdp.SDP_ErrorResponse(
+        transaction_id=0, error_code=sdp.ErrorCode.INVALID_SDP_VERSION
+    )
+    assert sdp.SDP_PDU.from_bytes(bytes(pdu)) == pdu
+    assert not re.search(r"Expect \d+ bytes, got \d+", caplog.text)
+
+
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
 async def test_service_search():
@@ -428,3 +440,43 @@ async def run():
 if __name__ == '__main__':
     logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
     asyncio.run(run())
+
+
+# -----------------------------------------------------------------------------
+def test_nested_sequence_recursion_guard():
+    """Regression test: deeply-nested SDP SEQUENCE/ALTERNATIVE must not crash
+    the parser with RecursionError. Instead a ValueError is raised once the
+    configured nesting limit is exceeded.
+
+    Root cause: DataElement.from_bytes -> list_from_bytes -> (constructor
+    dispatching back to list_from_bytes for SEQUENCE/ALTERNATIVE) recursed
+    without a depth limit. A malicious SDP peer could craft a PDU exceeding
+    Pythons default recursion limit (~1000 frames) and crash the host.
+    """
+    # Build nested SEQUENCE payload with tag 0x36 (SEQUENCE, 2-byte length).
+    inner = b"\x35\x00"  # empty SEQUENCE terminator
+    for _ in range(1500):
+        size = len(inner)
+        if size >= 65535:
+            break
+        inner = bytes([0x36, (size >> 8) & 0xFF, size & 0xFF]) + inner
+
+    with pytest.raises(ValueError, match="nesting exceeds max depth"):
+        DataElement.from_bytes(inner)
+
+
+def test_nested_sequence_within_limit_still_works():
+    """Nested-but-reasonable SDP SEQUENCEs must still parse correctly."""
+    leaf = DataElement.unsigned_integer(1, value_size=2)
+    payload = leaf
+    for _ in range(16):  # under the 32-depth limit
+        payload = DataElement.sequence([payload])
+    raw = bytes(payload)
+    parsed = DataElement.from_bytes(raw)
+    # Walk back down to confirm structural integrity preserved
+    cur = parsed
+    for _ in range(16):
+        assert cur.type == DataElement.SEQUENCE
+        cur = cur.value[0]
+    assert cur.type == DataElement.UNSIGNED_INTEGER
+    assert cur.value == 1

tests/self_test.py

@@ -29,8 +29,7 @@ from bumble.gatt import Characteristic, Service
 from bumble.hci import Role
 from bumble.pairing import PairingConfig, PairingDelegate
 from bumble.smp import (
-    SMP_CONFIRM_VALUE_FAILED_ERROR,
-    SMP_PAIRING_NOT_SUPPORTED_ERROR,
+    ErrorCode,
     OobContext,
     OobLegacyContext,
 )
@@ -378,7 +377,7 @@ async def test_self_smp_reject():
         await _test_self_smp_with_configs(None, rejecting_pairing_config)
         paired = True
     except ProtocolError as error:
-        assert error.error_code == SMP_PAIRING_NOT_SUPPORTED_ERROR
+        assert error.error_code == ErrorCode.PAIRING_NOT_SUPPORTED
 
     assert not paired
 
@@ -403,7 +402,7 @@ async def test_self_smp_wrong_pin():
         )
         paired = True
     except ProtocolError as error:
-        assert error.error_code == SMP_CONFIRM_VALUE_FAILED_ERROR
+        assert error.error_code == ErrorCode.CONFIRM_VALUE_FAILED
 
     assert not paired
 
@@ -534,11 +533,11 @@ async def test_self_smp_oob_sc():
 
     with pytest.raises(ProtocolError) as error:
         await _test_self_smp_with_configs(pairing_config_1, pairing_config_4)
-    assert error.value.error_code == SMP_CONFIRM_VALUE_FAILED_ERROR
+    assert error.value.error_code == ErrorCode.CONFIRM_VALUE_FAILED
 
     with pytest.raises(ProtocolError):
         await _test_self_smp_with_configs(pairing_config_4, pairing_config_1)
-    assert error.value.error_code == SMP_CONFIRM_VALUE_FAILED_ERROR
+    assert error.value.error_code == ErrorCode.CONFIRM_VALUE_FAILED
 
 
 # -----------------------------------------------------------------------------

tests/smp_test.py

@@ -24,7 +24,7 @@ import pytest
 from bumble import crypto, pairing, smp
 from bumble.core import AdvertisingData
 from bumble.crypto import EccKey, aes_cmac, ah, c1, f4, f5, f6, g2, h6, h7, s1
-from bumble.device import Device
+from bumble.device import Device, DeviceConfiguration
 from bumble.hci import Address
 from bumble.pairing import LeRole, OobData, OobSharedData
 
@@ -312,3 +312,17 @@ async def test_send_identity_address_command(
     actual_command = mock_method.call_args.args[0]
     assert actual_command.addr_type == expected_identity_address.address_type
     assert actual_command.bd_addr == expected_identity_address
+
+
+@pytest.mark.asyncio
+async def test_smp_debug_mode():
+    config = DeviceConfiguration(smp_debug_mode=True)
+    device = Device(config=config)
+
+    assert device.smp_manager.ecc_key.x == smp.SMP_DEBUG_KEY_PUBLIC_X
+    assert device.smp_manager.ecc_key.y == smp.SMP_DEBUG_KEY_PUBLIC_Y
+
+    device.smp_manager.debug_mode = False
+
+    assert not device.smp_manager.ecc_key.x == smp.SMP_DEBUG_KEY_PUBLIC_X
+    assert not device.smp_manager.ecc_key.y == smp.SMP_DEBUG_KEY_PUBLIC_Y

tests/transport_test.py

@@ -24,7 +24,7 @@ import sys
 import pytest
 
 from bumble import controller, device, hci, link, transport
-from bumble.transport import common
+from bumble.transport import common, usb
 
 
 # -----------------------------------------------------------------------------
@@ -252,6 +252,69 @@ async def test_open_transport_with_metadata(spec):
     await controller_transport.close()
 
 
+# -----------------------------------------------------------------------------
+def test_packet_splitter_complete():
+    emitted = []
+    splitter = usb.AclPacketSplitter(emitted.append)
+    packet = bytes([0x01, 0x00, 0x04, 0x00, 0x11, 0x22, 0x33, 0x44])
+    splitter.feed(packet)
+    assert emitted == [packet]
+
+
+def test_packet_splitter_chunks():
+    emitted = []
+    splitter = usb.AclPacketSplitter(emitted.append)
+    packet = bytes([0x01, 0x00, 0x04, 0x00, 0x11, 0x22, 0x33, 0x44])
+    splitter.feed(packet[:4])
+    assert emitted == []
+    splitter.feed(packet[4:])
+    assert emitted == [packet]
+
+
+def test_packet_splitter_multiple():
+    emitted = []
+    splitter = usb.AclPacketSplitter(emitted.append)
+    packet1 = bytes([0x01, 0x00, 0x04, 0x00, 0x11, 0x22, 0x33, 0x44])
+    packet2 = bytes([0x02, 0x00, 0x02, 0x00, 0x55, 0x66])
+    splitter.feed(packet1 + packet2)
+    assert emitted == [packet1, packet2]
+
+
+def test_packet_splitter_partial():
+    emitted = []
+    splitter = usb.AclPacketSplitter(emitted.append)
+    packet1 = bytes([0x01, 0x00, 0x04, 0x00, 0x11, 0x22, 0x33, 0x44])
+    packet2 = bytes([0x02, 0x00, 0x02, 0x00, 0x55, 0x66])
+    splitter.feed(packet1 + packet2[:4])
+    assert emitted == [packet1]
+    splitter.feed(packet2[4:])
+    assert emitted == [packet1, packet2]
+
+
+def test_packet_splitter_empty_payload():
+    emitted = []
+    splitter = usb.AclPacketSplitter(emitted.append)
+    packet = bytes([0x01, 0x00, 0x00, 0x00])
+    splitter.feed(packet)
+    assert emitted == [packet]
+
+
+def test_sco_packet_splitter():
+    emitted = []
+    splitter = usb.ScoPacketSplitter(emitted.append)
+    packet = bytes([0x01, 0x00, 0x03, 0x11, 0x22, 0x33])
+    splitter.feed(packet)
+    assert emitted == [packet]
+
+
+def test_event_packet_splitter():
+    emitted = []
+    splitter = usb.EventPacketSplitter(emitted.append)
+    packet = bytes([0x04, 0x02, 0x11, 0x22])
+    splitter.feed(packet)
+    assert emitted == [packet]
+
+
 # -----------------------------------------------------------------------------
 if __name__ == '__main__':
     test_parser()

tests/usb_test.py

@@ -0,0 +1,95 @@
+# Copyright 2026 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.
+
+import asyncio
+from unittest import mock
+
+import pytest
+
+from bumble import hci
+from bumble.transport import usb
+
+
+@pytest.mark.asyncio
+async def test_usb_packet_sink_iso_routing():
+    # Mock usb1 device and endpoints
+    mock_device = mock.Mock()
+    mock_bulk_out = mock.Mock()
+    mock_bulk_out.getAddress.return_value = 0x02
+
+    # Scenario 1: Isochronous endpoints are not enabled (isochronous_out is None)
+    mock_transfer = mock.Mock()
+    mock_device.getTransfer.return_value = mock_transfer
+
+    sink = usb.UsbPacketSink(mock_device, mock_bulk_out, isochronous_out=None)
+    sink.start()
+
+    # Send HCI_ISO_DATA_PACKET
+    iso_packet = bytes([hci.HCI_ISO_DATA_PACKET, 0x01, 0x02, 0x03])
+    sink.on_packet(iso_packet)
+
+    # Yield control to let the queue processor run
+    await asyncio.sleep(0.01)
+
+    # Verify it was sent via bulk transfer
+    mock_transfer.setBulk.assert_called_once_with(
+        0x02,
+        bytes([0x01, 0x02, 0x03]),
+        callback=sink.transfer_callback,
+    )
+    mock_transfer.submit.assert_called_once()
+
+    if sink.queue_task:
+        sink.queue_task.cancel()
+        try:
+            await sink.queue_task
+        except asyncio.CancelledError:
+            pass
+
+
+@pytest.mark.asyncio
+async def test_usb_packet_sink_iso_routing_with_iso_endpoint():
+    # Mock usb1 device and endpoints
+    mock_device = mock.Mock()
+    mock_bulk_out = mock.Mock()
+    mock_bulk_out.getAddress.return_value = 0x02
+    mock_iso_out = mock.Mock()
+    mock_iso_out.getMaxPacketSize.return_value = 64
+
+    # Scenario 2: Isochronous endpoints are enabled
+    mock_transfer_bulk = mock.Mock()
+    mock_transfer_iso = mock.Mock()
+
+    # getTransfer is called twice: once for bulk_or_control and once for isochronous
+    mock_device.getTransfer.side_effect = [mock_transfer_bulk, mock_transfer_iso]
+
+    sink = usb.UsbPacketSink(mock_device, mock_bulk_out, isochronous_out=mock_iso_out)
+    sink.start()
+
+    # Send HCI_ISO_DATA_PACKET
+    iso_packet = bytes([hci.HCI_ISO_DATA_PACKET, 0x01, 0x02, 0x03])
+    sink.on_packet(iso_packet)
+
+    # Yield control to let the queue processor run
+    await asyncio.sleep(0.01)
+
+    # Verify it was NOT sent via bulk transfer
+    mock_transfer_bulk.setBulk.assert_not_called()
+
+    if sink.queue_task:
+        sink.queue_task.cancel()
+        try:
+            await sink.queue_task
+        except asyncio.CancelledError:
+            pass

web/heart_rate_monitor/heart_rate_monitor.html

@@ -3,7 +3,7 @@
 <head>
   <link rel="stylesheet" href="https://fonts.googleapis.com/icon?family=Material+Icons">
   <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@24,400,0,0" />
-  <script src="https://cdn.jsdelivr.net/pyodide/v0.24.1/full/pyodide.js"></script>
+  <script src="https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.js"></script>
   <script type="module" src="../ui.js"></script>
   <script type="module" src="heart_rate_monitor.js"></script>
   <style>

web/scanner/scanner.html

@@ -3,7 +3,7 @@
 <head>
   <link rel="stylesheet" href="https://fonts.googleapis.com/icon?family=Material+Icons">
   <link rel="stylesheet" href="scanner.css">
-  <script src="https://cdn.jsdelivr.net/pyodide/v0.24.1/full/pyodide.js"></script>
+  <script src="https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.js"></script>
   <script type="module" src="../ui.js"></script>
   <script type="module" src="scanner.js"></script>
 </style>

web/speaker/speaker.html

@@ -4,7 +4,7 @@
   <title>Bumble Speaker</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/icon?family=Material+Icons">
   <link rel="stylesheet" href="speaker.css">
-  <script src="https://cdn.jsdelivr.net/pyodide/v0.24.1/full/pyodide.js"></script>
+  <script src="https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.js"></script>
   <script type="module" src="speaker.js"></script>
   <script type="module" src="../ui.js"></script>
 </head>