fix uninitialized variable

update credits even without a sink

.vscode/settings.json

@@ -33,6 +33,7 @@
         "dhkey",
         "diversifier",
         "endianness",
+        "ESCO",
         "Fitbit",
         "GATTLINK",
         "HANDSFREE",

apps/bench.py

@@ -513,6 +513,7 @@ class Ping:
             await self.packet_io.send_packet(bytes([PacketType.RESET]))
 
             self.current_packet_index = 0
+            self.latencies = []
             await self.send_next_ping()
 
             await self.done.wait()

apps/controller_info.py

@@ -18,15 +18,17 @@
 import asyncio
 import os
 import logging
-import click
-from bumble.company_ids import COMPANY_IDENTIFIERS
+import time
 
+import click
+
+from bumble.company_ids import COMPANY_IDENTIFIERS
 from bumble.colors import color
 from bumble.core import name_or_number
 from bumble.hci import (
     map_null_terminated_utf8_string,
+    LeFeatureMask,
     HCI_SUCCESS,
-    HCI_LE_SUPPORTED_FEATURES_NAMES,
     HCI_VERSION_NAMES,
     LMP_VERSION_NAMES,
     HCI_Command,
@@ -48,6 +50,7 @@ from bumble.hci import (
     HCI_LE_Read_Maximum_Advertising_Data_Length_Command,
     HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND,
     HCI_LE_Read_Suggested_Default_Data_Length_Command,
+    HCI_Read_Local_Version_Information_Command,
 )
 from bumble.host import Host
 from bumble.transport import open_transport_or_link
@@ -137,7 +140,7 @@ async def get_le_info(host: Host) -> None:
 
     print(color('LE Features:', 'yellow'))
     for feature in host.supported_le_features:
-        print('  ', name_or_number(HCI_LE_SUPPORTED_FEATURES_NAMES, feature))
+        print(LeFeatureMask(feature).name)
 
 
 # -----------------------------------------------------------------------------
@@ -166,7 +169,7 @@ async def get_acl_flow_control_info(host: Host) -> None:
 
 
 # -----------------------------------------------------------------------------
-async def async_main(transport):
+async def async_main(latency_probes, transport):
     print('<<< connecting to HCI...')
     async with await open_transport_or_link(transport) as (hci_source, hci_sink):
         print('<<< connected')
@@ -174,6 +177,23 @@ async def async_main(transport):
         host = Host(hci_source, hci_sink)
         await host.reset()
 
+        # Measure the latency if requested
+        latencies = []
+        if latency_probes:
+            for _ in range(latency_probes):
+                start = time.time()
+                await host.send_command(HCI_Read_Local_Version_Information_Command())
+                latencies.append(1000 * (time.time() - start))
+            print(
+                color('HCI Command Latency:', 'yellow'),
+                (
+                    f'min={min(latencies):.2f}, '
+                    f'max={max(latencies):.2f}, '
+                    f'average={sum(latencies)/len(latencies):.2f}'
+                ),
+                '\n',
+            )
+
         # Print version
         print(color('Version:', 'yellow'))
         print(
@@ -209,10 +229,16 @@ async def async_main(transport):
 
 # -----------------------------------------------------------------------------
 @click.command()
+@click.option(
+    '--latency-probes',
+    metavar='N',
+    type=int,
+    help='Send N commands to measure HCI transport latency statistics',
+)
 @click.argument('transport')
-def main(transport):
+def main(latency_probes, transport):
     logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
-    asyncio.run(async_main(transport))
+    asyncio.run(async_main(latency_probes, transport))
 
 
 # -----------------------------------------------------------------------------

bumble/controller.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import logging
 import asyncio
+import dataclasses
 import itertools
 import random
 import struct
@@ -42,6 +43,7 @@ from bumble.hci import (
     HCI_LE_1M_PHY,
     HCI_SUCCESS,
     HCI_UNKNOWN_HCI_COMMAND_ERROR,
+    HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
     HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR,
     HCI_VERSION_BLUETOOTH_CORE_5_0,
     Address,
@@ -53,6 +55,7 @@ from bumble.hci import (
     HCI_Connection_Request_Event,
     HCI_Disconnection_Complete_Event,
     HCI_Encryption_Change_Event,
+    HCI_Synchronous_Connection_Complete_Event,
     HCI_LE_Advertising_Report_Event,
     HCI_LE_Connection_Complete_Event,
     HCI_LE_Read_Remote_Features_Complete_Event,
@@ -60,10 +63,11 @@ from bumble.hci import (
     HCI_Packet,
     HCI_Role_Change_Event,
 )
-from typing import Optional, Union, Dict, TYPE_CHECKING
+from typing import Optional, Union, Dict, Any, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from bumble.transport.common import TransportSink, TransportSource
+    from bumble.link import LocalLink
+    from bumble.transport.common import TransportSink
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -79,15 +83,18 @@ class DataObject:
 
 
 # -----------------------------------------------------------------------------
+@dataclasses.dataclass
 class Connection:
-    def __init__(self, controller, handle, role, peer_address, link, transport):
-        self.controller = controller
-        self.handle = handle
-        self.role = role
-        self.peer_address = peer_address
-        self.link = link
+    controller: Controller
+    handle: int
+    role: int
+    peer_address: Address
+    link: Any
+    transport: int
+    link_type: int
+
+    def __post_init__(self):
         self.assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
-        self.transport = transport
 
     def on_hci_acl_data_packet(self, packet):
         self.assembler.feed_packet(packet)
@@ -106,10 +113,10 @@ class Connection:
 class Controller:
     def __init__(
         self,
-        name,
+        name: str,
         host_source=None,
         host_sink: Optional[TransportSink] = None,
-        link=None,
+        link: Optional[LocalLink] = None,
         public_address: Optional[Union[bytes, str, Address]] = None,
     ):
         self.name = name
@@ -359,12 +366,13 @@ class Controller:
         if connection is None:
             connection_handle = self.allocate_connection_handle()
             connection = Connection(
-                self,
-                connection_handle,
-                BT_PERIPHERAL_ROLE,
-                peer_address,
-                self.link,
-                BT_LE_TRANSPORT,
+                controller=self,
+                handle=connection_handle,
+                role=BT_PERIPHERAL_ROLE,
+                peer_address=peer_address,
+                link=self.link,
+                transport=BT_LE_TRANSPORT,
+                link_type=HCI_Connection_Complete_Event.ACL_LINK_TYPE,
             )
             self.peripheral_connections[peer_address] = connection
             logger.debug(f'New PERIPHERAL connection handle: 0x{connection_handle:04X}')
@@ -418,12 +426,13 @@ class Controller:
             if connection is None:
                 connection_handle = self.allocate_connection_handle()
                 connection = Connection(
-                    self,
-                    connection_handle,
-                    BT_CENTRAL_ROLE,
-                    peer_address,
-                    self.link,
-                    BT_LE_TRANSPORT,
+                    controller=self,
+                    handle=connection_handle,
+                    role=BT_CENTRAL_ROLE,
+                    peer_address=peer_address,
+                    link=self.link,
+                    transport=BT_LE_TRANSPORT,
+                    link_type=HCI_Connection_Complete_Event.ACL_LINK_TYPE,
                 )
                 self.central_connections[peer_address] = connection
                 logger.debug(
@@ -568,6 +577,7 @@ class Controller:
                     peer_address=peer_address,
                     link=self.link,
                     transport=BT_BR_EDR_TRANSPORT,
+                    link_type=HCI_Connection_Complete_Event.ACL_LINK_TYPE,
                 )
                 self.classic_connections[peer_address] = connection
                 logger.debug(
@@ -621,6 +631,42 @@ class Controller:
             )
         )
 
+    def on_classic_sco_connection_complete(
+        self, peer_address: Address, status: int, link_type: int
+    ):
+        if status == HCI_SUCCESS:
+            # Allocate (or reuse) a connection handle
+            connection_handle = self.allocate_connection_handle()
+            connection = Connection(
+                controller=self,
+                handle=connection_handle,
+                # Role doesn't matter in SCO.
+                role=BT_CENTRAL_ROLE,
+                peer_address=peer_address,
+                link=self.link,
+                transport=BT_BR_EDR_TRANSPORT,
+                link_type=link_type,
+            )
+            self.classic_connections[peer_address] = connection
+            logger.debug(f'New SCO connection handle: 0x{connection_handle:04X}')
+        else:
+            connection_handle = 0
+
+        self.send_hci_packet(
+            HCI_Synchronous_Connection_Complete_Event(
+                status=status,
+                connection_handle=connection_handle,
+                bd_addr=peer_address,
+                link_type=link_type,
+                # TODO: Provide SCO connection parameters.
+                transmission_interval=0,
+                retransmission_window=0,
+                rx_packet_length=0,
+                tx_packet_length=0,
+                air_mode=0,
+            )
+        )
+
     ############################################################
     # Advertising support
     ############################################################
@@ -740,6 +786,68 @@ class Controller:
         )
         self.link.classic_accept_connection(self, command.bd_addr, command.role)
 
+    def on_hci_enhanced_setup_synchronous_connection_command(self, command):
+        '''
+        See Bluetooth spec Vol 4, Part E - 7.1.45 Enhanced Setup Synchronous Connection command
+        '''
+
+        if self.link is None:
+            return
+
+        if not (
+            connection := self.find_classic_connection_by_handle(
+                command.connection_handle
+            )
+        ):
+            self.send_hci_packet(
+                HCI_Command_Status_Event(
+                    status=HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
+                    num_hci_command_packets=1,
+                    command_opcode=command.op_code,
+                )
+            )
+            return
+
+        self.send_hci_packet(
+            HCI_Command_Status_Event(
+                status=HCI_SUCCESS,
+                num_hci_command_packets=1,
+                command_opcode=command.op_code,
+            )
+        )
+        self.link.classic_sco_connect(
+            self, connection.peer_address, HCI_Connection_Complete_Event.ESCO_LINK_TYPE
+        )
+
+    def on_hci_enhanced_accept_synchronous_connection_request_command(self, command):
+        '''
+        See Bluetooth spec Vol 4, Part E - 7.1.46 Enhanced Accept Synchronous Connection Request command
+        '''
+
+        if self.link is None:
+            return
+
+        if not (connection := self.find_classic_connection_by_address(command.bd_addr)):
+            self.send_hci_packet(
+                HCI_Command_Status_Event(
+                    status=HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
+                    num_hci_command_packets=1,
+                    command_opcode=command.op_code,
+                )
+            )
+            return
+
+        self.send_hci_packet(
+            HCI_Command_Status_Event(
+                status=HCI_SUCCESS,
+                num_hci_command_packets=1,
+                command_opcode=command.op_code,
+            )
+        )
+        self.link.classic_accept_sco_connection(
+            self, connection.peer_address, HCI_Connection_Complete_Event.ESCO_LINK_TYPE
+        )
+
     def on_hci_switch_role_command(self, command):
         '''
         See Bluetooth spec Vol 4, Part E - 7.2.8 Switch Role command
@@ -1104,6 +1212,18 @@ class Controller:
         See Bluetooth spec Vol 4, Part E - 7.8.21 LE Read Remote Features Command
         '''
 
+        handle = command.connection_handle
+
+        if not self.find_connection_by_handle(handle):
+            self.send_hci_packet(
+                HCI_Command_Status_Event(
+                    status=HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR,
+                    num_hci_command_packets=1,
+                    command_opcode=command.op_code,
+                )
+            )
+            return
+
         # First, say that the command is pending
         self.send_hci_packet(
             HCI_Command_Status_Event(
@@ -1117,7 +1237,7 @@ class Controller:
         self.send_hci_packet(
             HCI_LE_Read_Remote_Features_Complete_Event(
                 status=HCI_SUCCESS,
-                connection_handle=0,
+                connection_handle=handle,
                 le_features=bytes.fromhex('dd40000000000000'),
             )
         )

bumble/device.py

@@ -49,7 +49,6 @@ from .hci import (
     HCI_AUTHENTICATED_COMBINATION_KEY_GENERATED_FROM_P_256_TYPE,
     HCI_CENTRAL_ROLE,
     HCI_COMMAND_STATUS_PENDING,
-    HCI_CONNECTED_ISOCHRONOUS_STREAM_LE_SUPPORTED_FEATURE,
     HCI_CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES_ERROR,
     HCI_DISPLAY_YES_NO_IO_CAPABILITY,
     HCI_DISPLAY_ONLY_IO_CAPABILITY,
@@ -60,12 +59,8 @@ from .hci import (
     HCI_LE_1M_PHY,
     HCI_LE_1M_PHY_BIT,
     HCI_LE_2M_PHY,
-    HCI_LE_2M_PHY_LE_SUPPORTED_FEATURE,
-    HCI_LE_CLEAR_RESOLVING_LIST_COMMAND,
     HCI_LE_CODED_PHY,
     HCI_LE_CODED_PHY_BIT,
-    HCI_LE_CODED_PHY_LE_SUPPORTED_FEATURE,
-    HCI_LE_EXTENDED_ADVERTISING_LE_SUPPORTED_FEATURE,
     HCI_LE_EXTENDED_CREATE_CONNECTION_COMMAND,
     HCI_LE_RAND_COMMAND,
     HCI_LE_READ_PHY_COMMAND,
@@ -86,7 +81,7 @@ from .hci import (
     HCI_Constant,
     HCI_Create_Connection_Cancel_Command,
     HCI_Create_Connection_Command,
-    HCI_Create_Connection_Command,
+    HCI_Connection_Complete_Event,
     HCI_Disconnect_Command,
     HCI_Encryption_Change_Event,
     HCI_Error,
@@ -107,6 +102,7 @@ from .hci import (
     HCI_LE_Extended_Create_Connection_Command,
     HCI_LE_Rand_Command,
     HCI_LE_Read_PHY_Command,
+    HCI_LE_Read_Remote_Features_Command,
     HCI_LE_Reject_CIS_Request_Command,
     HCI_LE_Remove_Advertising_Set_Command,
     HCI_LE_Set_Address_Resolution_Enable_Command,
@@ -152,6 +148,7 @@ from .hci import (
     HCI_Write_Secure_Connections_Host_Support_Command,
     HCI_Write_Simple_Pairing_Mode_Command,
     OwnAddressType,
+    LeFeatureMask,
     phy_list_to_bits,
 )
 from .host import Host
@@ -682,6 +679,7 @@ class Connection(CompositeEventEmitter):
     self_address: Address
     peer_address: Address
     peer_resolvable_address: Optional[Address]
+    peer_le_features: Optional[LeFeatureMask]
     role: int
     encryption: int
     authenticated: bool
@@ -758,6 +756,7 @@ class Connection(CompositeEventEmitter):
         )  # By default, use the device's shared server
         self.pairing_peer_io_capability = None
         self.pairing_peer_authentication_requirements = None
+        self.peer_le_features = None
 
     # [Classic only]
     @classmethod
@@ -906,6 +905,15 @@ class Connection(CompositeEventEmitter):
     async def request_remote_name(self):
         return await self.device.request_remote_name(self)
 
+    async def get_remote_le_features(self) -> LeFeatureMask:
+        """[LE Only] Reads remote LE supported features.
+
+        Returns:
+            LE features supported by the remote device.
+        """
+        self.peer_le_features = await self.device.get_remote_le_features(self)
+        return self.peer_le_features
+
     async def __aenter__(self):
         return self
 
@@ -1538,9 +1546,7 @@ class Device(CompositeEventEmitter):
             if self.cis_enabled:
                 await self.send_command(
                     HCI_LE_Set_Host_Feature_Command(
-                        bit_number=(
-                            HCI_CONNECTED_ISOCHRONOUS_STREAM_LE_SUPPORTED_FEATURE
-                        ),
+                        bit_number=LeFeatureMask.CONNECTED_ISOCHRONOUS_STREAM,
                         bit_value=1,
                     )
                 )
@@ -1596,21 +1602,21 @@ class Device(CompositeEventEmitter):
                     )
                 )
 
-    def supports_le_feature(self, feature):
-        return self.host.supports_le_feature(feature)
+    def supports_le_features(self, feature: LeFeatureMask) -> bool:
+        return self.host.supports_le_features(feature)
 
     def supports_le_phy(self, phy):
         if phy == HCI_LE_1M_PHY:
             return True
 
         feature_map = {
-            HCI_LE_2M_PHY: HCI_LE_2M_PHY_LE_SUPPORTED_FEATURE,
-            HCI_LE_CODED_PHY: HCI_LE_CODED_PHY_LE_SUPPORTED_FEATURE,
+            HCI_LE_2M_PHY: LeFeatureMask.LE_2M_PHY,
+            HCI_LE_CODED_PHY: LeFeatureMask.LE_CODED_PHY,
         }
         if phy not in feature_map:
             raise ValueError('invalid PHY')
 
-        return self.host.supports_le_feature(feature_map[phy])
+        return self.host.supports_le_features(feature_map[phy])
 
     @deprecated("Please use start_legacy_advertising.")
     async def start_advertising(
@@ -1920,8 +1926,8 @@ class Device(CompositeEventEmitter):
         self.advertisement_accumulators = {}
 
         # Enable scanning
-        if not legacy and self.supports_le_feature(
-            HCI_LE_EXTENDED_ADVERTISING_LE_SUPPORTED_FEATURE
+        if not legacy and self.supports_le_features(
+            LeFeatureMask.LE_EXTENDED_ADVERTISING
         ):
             # Set the scanning parameters
             scan_type = (
@@ -1939,7 +1945,7 @@ class Device(CompositeEventEmitter):
                 scanning_phys_bits |= 1 << HCI_LE_1M_PHY_BIT
                 scanning_phy_count += 1
             if HCI_LE_CODED_PHY in scanning_phys:
-                if self.supports_le_feature(HCI_LE_CODED_PHY_LE_SUPPORTED_FEATURE):
+                if self.supports_le_features(LeFeatureMask.LE_CODED_PHY):
                     scanning_phys_bits |= 1 << HCI_LE_CODED_PHY_BIT
                     scanning_phy_count += 1
 
@@ -2000,7 +2006,7 @@ class Device(CompositeEventEmitter):
 
     async def stop_scanning(self) -> None:
         # Disable scanning
-        if self.supports_le_feature(HCI_LE_EXTENDED_ADVERTISING_LE_SUPPORTED_FEATURE):
+        if self.supports_le_features(LeFeatureMask.LE_EXTENDED_ADVERTISING):
             await self.send_command(
                 HCI_LE_Set_Extended_Scan_Enable_Command(
                     enable=0, filter_duplicates=0, duration=0, period=0
@@ -3142,6 +3148,32 @@ class Device(CompositeEventEmitter):
             )
             raise HCI_StatusError(result)
 
+    async def get_remote_le_features(self, connection: Connection) -> LeFeatureMask:
+        """[LE Only] Reads remote LE supported features.
+
+        Args:
+            handle: connection handle to read LE features.
+
+        Returns:
+            LE features supported by the remote device.
+        """
+        with closing(EventWatcher()) as watcher:
+            read_feature_future: asyncio.Future[
+                LeFeatureMask
+            ] = asyncio.get_running_loop().create_future()
+
+            def on_le_remote_features(handle: int, features: int):
+                if handle == connection.handle:
+                    read_feature_future.set_result(LeFeatureMask(features))
+
+            watcher.on(self.host, 'le_remote_features', on_le_remote_features)
+            await self.send_command(
+                HCI_LE_Read_Remote_Features_Command(
+                    connection_handle=connection.handle
+                ),
+            )
+            return await read_feature_future
+
     @host_event_handler
     def on_flush(self):
         self.emit('flush')
@@ -3319,8 +3351,21 @@ class Device(CompositeEventEmitter):
     def on_connection_request(self, bd_addr, class_of_device, link_type):
         logger.debug(f'*** Connection request: {bd_addr}')
 
+        # Handle SCO request.
+        if link_type in (
+            HCI_Connection_Complete_Event.SCO_LINK_TYPE,
+            HCI_Connection_Complete_Event.ESCO_LINK_TYPE,
+        ):
+            if connection := self.find_connection_by_bd_addr(
+                bd_addr, transport=BT_BR_EDR_TRANSPORT
+            ):
+                self.emit('sco_request', connection, link_type)
+            else:
+                logger.error(f'SCO request from a non-connected device {bd_addr}')
+            return
+
         # match a pending future using `bd_addr`
-        if bd_addr in self.classic_pending_accepts:
+        elif bd_addr in self.classic_pending_accepts:
             future, *_ = self.classic_pending_accepts.pop(bd_addr)
             future.set_result((bd_addr, class_of_device, link_type))
 

bumble/hci.py

@@ -1360,55 +1360,51 @@ HCI_SUPPORTED_COMMANDS_FLAGS = (
 
 # LE Supported Features
 # See Bluetooth spec @ Vol 6, Part B, 4.6 FEATURE SUPPORT
-HCI_LE_ENCRYPTION_LE_SUPPORTED_FEATURE                                  = 0
-HCI_CONNECTION_PARAMETERS_REQUEST_PROCEDURE_LE_SUPPORTED_FEATURE        = 1
-HCI_EXTENDED_REJECT_INDICATION_LE_SUPPORTED_FEATURE                     = 2
-HCI_PERIPHERAL_INITIATED_FEATURE_EXCHANGE_LE_SUPPORTED_FEATURE          = 3
-HCI_LE_PING_LE_SUPPORTED_FEATURE                                        = 4
-HCI_LE_DATA_PACKET_LENGTH_EXTENSION_LE_SUPPORTED_FEATURE                = 5
-HCI_LL_PRIVACY_LE_SUPPORTED_FEATURE                                     = 6
-HCI_EXTENDED_SCANNER_FILTER_POLICIES_LE_SUPPORTED_FEATURE               = 7
-HCI_LE_2M_PHY_LE_SUPPORTED_FEATURE                                      = 8
-HCI_STABLE_MODULATION_INDEX_TRANSMITTER_LE_SUPPORTED_FEATURE            = 9
-HCI_STABLE_MODULATION_INDEX_RECEIVER_LE_SUPPORTED_FEATURE               = 10
-HCI_LE_CODED_PHY_LE_SUPPORTED_FEATURE                                   = 11
-HCI_LE_EXTENDED_ADVERTISING_LE_SUPPORTED_FEATURE                        = 12
-HCI_LE_PERIODIC_ADVERTISING_LE_SUPPORTED_FEATURE                        = 13
-HCI_CHANNEL_SELECTION_ALGORITHM_2_LE_SUPPORTED_FEATURE                  = 14
-HCI_LE_POWER_CLASS_1_LE_SUPPORTED_FEATURE                               = 15
-HCI_MINIMUM_NUMBER_OF_USED_CHANNELS_PROCEDURE_LE_SUPPORTED_FEATURE      = 16
-HCI_CONNECTION_CTE_REQUEST_LE_SUPPORTED_FEATURE                         = 17
-HCI_CONNECTION_CTE_RESPONSE_LE_SUPPORTED_FEATURE                        = 18
-HCI_CONNECTIONLESS_CTE_TRANSMITTER_LE_SUPPORTED_FEATURE                 = 19
-HCI_CONNECTIONLESS_CTR_RECEIVER_LE_SUPPORTED_FEATURE                    = 20
-HCI_ANTENNA_SWITCHING_DURING_CTE_TRANSMISSION_LE_SUPPORTED_FEATURE      = 21
-HCI_ANTENNA_SWITCHING_DURING_CTE_RECEPTION_LE_SUPPORTED_FEATURE         = 22
-HCI_RECEIVING_CONSTANT_TONE_EXTENSIONS_LE_SUPPORTED_FEATURE             = 23
-HCI_PERIODIC_ADVERTISING_SYNC_TRANSFER_SENDER_LE_SUPPORTED_FEATURE      = 24
-HCI_PERIODIC_ADVERTISING_SYNC_TRANSFER_RECIPIENT_LE_SUPPORTED_FEATURE   = 25
-HCI_SLEEP_CLOCK_ACCURACY_UPDATES_LE_SUPPORTED_FEATURE                   = 26
-HCI_REMOTE_PUBLIC_KEY_VALIDATION_LE_SUPPORTED_FEATURE                   = 27
-HCI_CONNECTED_ISOCHRONOUS_STREAM_CENTRAL_LE_SUPPORTED_FEATURE           = 28
-HCI_CONNECTED_ISOCHRONOUS_STREAM_PERIPHERAL_LE_SUPPORTED_FEATURE        = 29
-HCI_ISOCHRONOUS_BROADCASTER_LE_SUPPORTED_FEATURE                        = 30
-HCI_SYNCHRONIZED_RECEIVER_LE_SUPPORTED_FEATURE                          = 31
-HCI_CONNECTED_ISOCHRONOUS_STREAM_LE_SUPPORTED_FEATURE                   = 32
-HCI_LE_POWER_CONTROL_REQUEST_LE_SUPPORTED_FEATURE                       = 33
-HCI_LE_POWER_CONTROL_REQUEST_DUP_LE_SUPPORTED_FEATURE                   = 34
-HCI_LE_PATH_LOSS_MONITORING_LE_SUPPORTED_FEATURE                        = 35
-HCI_PERIODIC_ADVERTISING_ADI_SUPPORT_LE_SUPPORTED_FEATURE               = 36
-HCI_CONNECTION_SUBRATING_LE_SUPPORTED_FEATURE                           = 37
-HCI_CONNECTION_SUBRATING_HOST_SUPPORT_LE_SUPPORTED_FEATURE              = 38
-HCI_CHANNEL_CLASSIFICATION_LE_SUPPORTED_FEATURE                         = 39
-HCI_ADVERTISING_CODING_SELECTION_LE_SUPPORTED_FEATURE                   = 40
-HCI_ADVERTISING_CODING_SELECTION_HOST_SUPPORT_LE_SUPPORTED_FEATURE      = 41
-HCI_PERIODIC_ADVERTISING_WITH_RESPONSES_ADVERTISER_LE_SUPPORTED_FEATURE = 43
-HCI_PERIODIC_ADVERTISING_WITH_RESPONSES_SCANNER_LE_SUPPORTED_FEATURE    = 44
-
-HCI_LE_SUPPORTED_FEATURES_NAMES = {
-    flag: feature_name for (feature_name, flag) in globals().items()
-    if feature_name.startswith('HCI_') and feature_name.endswith('_LE_SUPPORTED_FEATURE')
-}
+class LeFeatureMask(enum.IntFlag):
+    LE_ENCRYPTION                                  = 1 << 0
+    CONNECTION_PARAMETERS_REQUEST_PROCEDURE        = 1 << 1
+    EXTENDED_REJECT_INDICATION                     = 1 << 2
+    PERIPHERAL_INITIATED_FEATURE_EXCHANGE          = 1 << 3
+    LE_PING                                        = 1 << 4
+    LE_DATA_PACKET_LENGTH_EXTENSION                = 1 << 5
+    LL_PRIVACY                                     = 1 << 6
+    EXTENDED_SCANNER_FILTER_POLICIES               = 1 << 7
+    LE_2M_PHY                                      = 1 << 8
+    STABLE_MODULATION_INDEX_TRANSMITTER            = 1 << 9
+    STABLE_MODULATION_INDEX_RECEIVER               = 1 << 10
+    LE_CODED_PHY                                   = 1 << 11
+    LE_EXTENDED_ADVERTISING                        = 1 << 12
+    LE_PERIODIC_ADVERTISING                        = 1 << 13
+    CHANNEL_SELECTION_ALGORITHM_2                  = 1 << 14
+    LE_POWER_CLASS_1                               = 1 << 15
+    MINIMUM_NUMBER_OF_USED_CHANNELS_PROCEDURE      = 1 << 16
+    CONNECTION_CTE_REQUEST                         = 1 << 17
+    CONNECTION_CTE_RESPONSE                        = 1 << 18
+    CONNECTIONLESS_CTE_TRANSMITTER                 = 1 << 19
+    CONNECTIONLESS_CTR_RECEIVER                    = 1 << 20
+    ANTENNA_SWITCHING_DURING_CTE_TRANSMISSION      = 1 << 21
+    ANTENNA_SWITCHING_DURING_CTE_RECEPTION         = 1 << 22
+    RECEIVING_CONSTANT_TONE_EXTENSIONS             = 1 << 23
+    PERIODIC_ADVERTISING_SYNC_TRANSFER_SENDER      = 1 << 24
+    PERIODIC_ADVERTISING_SYNC_TRANSFER_RECIPIENT   = 1 << 25
+    SLEEP_CLOCK_ACCURACY_UPDATES                   = 1 << 26
+    REMOTE_PUBLIC_KEY_VALIDATION                   = 1 << 27
+    CONNECTED_ISOCHRONOUS_STREAM_CENTRAL           = 1 << 28
+    CONNECTED_ISOCHRONOUS_STREAM_PERIPHERAL        = 1 << 29
+    ISOCHRONOUS_BROADCASTER                        = 1 << 30
+    SYNCHRONIZED_RECEIVER                          = 1 << 31
+    CONNECTED_ISOCHRONOUS_STREAM                   = 1 << 32
+    LE_POWER_CONTROL_REQUEST                       = 1 << 33
+    LE_POWER_CONTROL_REQUEST_DUP                   = 1 << 34
+    LE_PATH_LOSS_MONITORING                        = 1 << 35
+    PERIODIC_ADVERTISING_ADI_SUPPORT               = 1 << 36
+    CONNECTION_SUBRATING                           = 1 << 37
+    CONNECTION_SUBRATING_HOST_SUPPORT              = 1 << 38
+    CHANNEL_CLASSIFICATION                         = 1 << 39
+    ADVERTISING_CODING_SELECTION                   = 1 << 40
+    ADVERTISING_CODING_SELECTION_HOST_SUPPORT      = 1 << 41
+    PERIODIC_ADVERTISING_WITH_RESPONSES_ADVERTISER = 1 << 43
+    PERIODIC_ADVERTISING_WITH_RESPONSES_SCANNER    = 1 << 44
 
 
 # fmt: on
@@ -4765,7 +4761,11 @@ class HCI_Event(HCI_Packet):
             HCI_Object.init_from_bytes(self, parameters, 0, fields)
         return self
 
-    def __init__(self, event_code, parameters=None, **kwargs):
+    def __init__(self, event_code=-1, parameters=None, **kwargs):
+        # Since the legacy implementation relies on an __init__ injector, typing always
+        # complains that positional argument event_code is not passed, so here sets a
+        # default value to allow building derived HCI_Event without event_code.
+        assert event_code != -1
         super().__init__(HCI_Event.event_name(event_code))
         if (fields := getattr(self, 'fields', None)) and kwargs:
             HCI_Object.init_from_fields(self, fields, kwargs)

bumble/helpers.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable, MutableMapping
-from typing import cast, Any
+from typing import cast, Any, Optional
 import logging
 
 from bumble import avdtp
@@ -69,7 +69,7 @@ PSM_NAMES = {
 class PacketTracer:
     class AclStream:
         psms: MutableMapping[int, int]
-        peer: PacketTracer.AclStream
+        peer: Optional[PacketTracer.AclStream]
         avdtp_assemblers: MutableMapping[int, avdtp.MessageAssembler]
 
         def __init__(self, analyzer: PacketTracer.Analyzer) -> None:
@@ -77,6 +77,7 @@ class PacketTracer:
             self.packet_assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
             self.avdtp_assemblers = {}  # AVDTP assemblers, by source_cid
             self.psms = {}  # PSM, by source_cid
+            self.peer = None
 
         # pylint: disable=too-many-nested-blocks
         def on_acl_pdu(self, pdu: bytes) -> None:

bumble/host.py

@@ -70,6 +70,7 @@ from .hci import (
     HCI_Reset_Command,
     HCI_Set_Event_Mask_Command,
     HCI_SynchronousDataPacket,
+    LeFeatureMask,
 )
 from .core import (
     BT_BR_EDR_TRANSPORT,
@@ -487,8 +488,8 @@ class Host(AbortableEventEmitter):
 
         return commands
 
-    def supports_le_feature(self, feature):
-        return (self.local_le_features & (1 << feature)) != 0
+    def supports_le_features(self, feature: LeFeatureMask) -> bool:
+        return (self.local_le_features & feature) == feature
 
     @property
     def supported_le_features(self):
@@ -1033,3 +1034,15 @@ class Host(AbortableEventEmitter):
             event.bd_addr,
             event.host_supported_features,
         )
+
+    def on_hci_le_read_remote_features_complete_event(self, event):
+        if event.status != HCI_SUCCESS:
+            self.emit(
+                'le_remote_features_failure', event.connection_handle, event.status
+            )
+        else:
+            self.emit(
+                'le_remote_features',
+                event.connection_handle,
+                int.from_bytes(event.le_features, 'little'),
+            )

bumble/link.py

@@ -26,9 +26,13 @@ from bumble.hci import (
     HCI_SUCCESS,
     HCI_CONNECTION_ACCEPT_TIMEOUT_ERROR,
     HCI_CONNECTION_TIMEOUT_ERROR,
+    HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
     HCI_PAGE_TIMEOUT_ERROR,
     HCI_Connection_Complete_Event,
 )
+from bumble import controller
+
+from typing import Optional, Set
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -57,6 +61,8 @@ class LocalLink:
     Link bus for controllers to communicate with each other
     '''
 
+    controllers: Set[controller.Controller]
+
     def __init__(self):
         self.controllers = set()
         self.pending_connection = None
@@ -79,7 +85,9 @@ class LocalLink:
                 return controller
         return None
 
-    def find_classic_controller(self, address):
+    def find_classic_controller(
+        self, address: Address
+    ) -> Optional[controller.Controller]:
         for controller in self.controllers:
             if controller.public_address == address:
                 return controller
@@ -271,6 +279,52 @@ class LocalLink:
             initiator_controller.public_address, int(not (initiator_new_role))
         )
 
+    def classic_sco_connect(
+        self,
+        initiator_controller: controller.Controller,
+        responder_address: Address,
+        link_type: int,
+    ):
+        logger.debug(
+            f'[Classic] {initiator_controller.public_address} connects SCO to {responder_address}'
+        )
+        responder_controller = self.find_classic_controller(responder_address)
+        # Initiator controller should handle it.
+        assert responder_controller
+
+        responder_controller.on_classic_connection_request(
+            initiator_controller.public_address,
+            link_type,
+        )
+
+    def classic_accept_sco_connection(
+        self,
+        responder_controller: controller.Controller,
+        initiator_address: Address,
+        link_type: int,
+    ):
+        logger.debug(
+            f'[Classic] {responder_controller.public_address} accepts to connect SCO {initiator_address}'
+        )
+        initiator_controller = self.find_classic_controller(initiator_address)
+        if initiator_controller is None:
+            responder_controller.on_classic_sco_connection_complete(
+                responder_controller.public_address,
+                HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
+                link_type,
+            )
+            return
+
+        async def task():
+            initiator_controller.on_classic_sco_connection_complete(
+                responder_controller.public_address, HCI_SUCCESS, link_type
+            )
+
+        asyncio.create_task(task())
+        responder_controller.on_classic_sco_connection_complete(
+            initiator_controller.public_address, HCI_SUCCESS, link_type
+        )
+
 
 # -----------------------------------------------------------------------------
 class RemoteLink:

bumble/pandora/host.py

@@ -285,10 +285,11 @@ class HostService(HostServicer):
             raise NotImplementedError(
                 "TODO: add support for extended advertising in Bumble"
             )
-        if request.interval:
-            raise NotImplementedError("TODO: add support for `request.interval`")
-        if request.interval_range:
-            raise NotImplementedError("TODO: add support for `request.interval_range`")
+        if advertising_interval := request.interval:
+            self.device.config.advertising_interval_min = int(advertising_interval)
+            self.device.config.advertising_interval_max = int(advertising_interval)
+        if interval_range := request.interval_range:
+            self.device.config.advertising_interval_max += int(interval_range)
         if request.primary_phy:
             raise NotImplementedError("TODO: add support for `request.primary_phy`")
         if request.secondary_phy:

bumble/rfcomm.py

@@ -538,8 +538,9 @@ class DLC(EventEmitter):
             f'[{self.dlci}] {len(data)} bytes, '
             f'rx_credits={self.rx_credits}: {data.hex()}'
         )
-        if len(data) and self.sink:
-            self.sink(data)  # pylint: disable=not-callable
+        if data:
+            if self.sink:
+                self.sink(data)  # pylint: disable=not-callable
 
             # Update the credits
             if self.rx_credits > 0:

bumble/transport/__init__.py

@@ -82,14 +82,13 @@ async def open_transport(name: str) -> Transport:
 
     scheme, *tail = name.split(':', 1)
     spec = tail[0] if tail else None
+    metadata = None
     if spec:
         # Metadata may precede the spec
         if spec.startswith('['):
             metadata_str, *tail = spec[1:].split(']')
             spec = tail[0] if tail else None
             metadata = dict([entry.split('=') for entry in metadata_str.split(',')])
-        else:
-            metadata = None
 
     transport = await _open_transport(scheme, spec)
     if metadata:
@@ -198,12 +197,13 @@ async def open_transport_or_link(name: str) -> Transport:
 
     """
     if name.startswith('link-relay:'):
+        logger.warning('Link Relay has been deprecated.')
         from ..controller import Controller
         from ..link import RemoteLink  # lazy import
 
         link = RemoteLink(name[11:])
         await link.wait_until_connected()
-        controller = Controller('remote', link=link)
+        controller = Controller('remote', link=link)  # type:ignore[arg-type]
 
         class LinkTransport(Transport):
             async def close(self):

extras/android/RemoteHCI/app/build.gradle.kts

@@ -10,7 +10,7 @@ android {
 
     defaultConfig {
         applicationId = "com.github.google.bumble.remotehci"
-        minSdk = 26
+        minSdk = 29
         targetSdk = 33
         versionCode = 1
         versionName = "1.0"

extras/android/RemoteHCI/app/src/main/java/com/github/google/bumble/remotehci/HciHal.java

@@ -4,6 +4,7 @@ import android.hardware.bluetooth.V1_0.Status;
 import android.os.IBinder;
 import android.os.RemoteException;
 import android.os.ServiceManager;
+import android.os.Trace;
 import android.util.Log;
 
 import java.util.ArrayList;
@@ -53,6 +54,7 @@ class HciHidlHal extends android.hardware.bluetooth.V1_0.IBluetoothHciCallbacks.
     private final android.hardware.bluetooth.V1_0.IBluetoothHci mHciService;
     private final HciHalCallback mHciCallbacks;
     private int mInitializationStatus = -1;
+    private final boolean mTracingEnabled = Trace.isEnabled();
 
 
     public static HciHidlHal create(HciHalCallback hciCallbacks) {
@@ -89,6 +91,7 @@ class HciHidlHal extends android.hardware.bluetooth.V1_0.IBluetoothHciCallbacks.
         }
 
         // Map the status code.
+        Log.d(TAG, "Initialization status = " + mInitializationStatus);
         switch (mInitializationStatus) {
             case android.hardware.bluetooth.V1_0.Status.SUCCESS:
                 return Status.SUCCESS;
@@ -108,6 +111,10 @@ class HciHidlHal extends android.hardware.bluetooth.V1_0.IBluetoothHciCallbacks.
     public void sendPacket(HciPacket.Type type, byte[] packet) {
         ArrayList<Byte> data = HciPacket.byteArrayToList(packet);
 
+        if (mTracingEnabled) {
+            Trace.beginAsyncSection("SEND_PACKET_TO_HAL", 1);
+        }
+
         try {
             switch (type) {
                 case COMMAND:
@@ -125,6 +132,10 @@ class HciHidlHal extends android.hardware.bluetooth.V1_0.IBluetoothHciCallbacks.
         } catch (RemoteException error) {
             Log.w(TAG, "failed to forward packet: " + error);
         }
+
+        if (mTracingEnabled) {
+            Trace.endAsyncSection("SEND_PACKET_TO_HAL", 1);
+        }
     }
 
     @Override
@@ -157,6 +168,7 @@ class HciAidlHal extends android.hardware.bluetooth.IBluetoothHciCallbacks.Stub
     private final android.hardware.bluetooth.IBluetoothHci mHciService;
     private final HciHalCallback mHciCallbacks;
     private int mInitializationStatus = android.hardware.bluetooth.Status.SUCCESS;
+    private final boolean mTracingEnabled = Trace.isEnabled();
 
     public static HciAidlHal create(HciHalCallback hciCallbacks) {
         IBinder binder = ServiceManager.getService("android.hardware.bluetooth.IBluetoothHci/default");
@@ -187,6 +199,7 @@ class HciAidlHal extends android.hardware.bluetooth.IBluetoothHciCallbacks.Stub
         }
 
         // Map the status code.
+        Log.d(TAG, "Initialization status = " + mInitializationStatus);
         switch (mInitializationStatus) {
             case android.hardware.bluetooth.Status.SUCCESS:
                 return Status.SUCCESS;
@@ -208,6 +221,10 @@ class HciAidlHal extends android.hardware.bluetooth.IBluetoothHciCallbacks.Stub
     // HciHal methods.
     @Override
     public void sendPacket(HciPacket.Type type, byte[] packet) {
+        if (mTracingEnabled) {
+            Trace.beginAsyncSection("SEND_PACKET_TO_HAL", 1);
+        }
+
         try {
             switch (type) {
                 case COMMAND:
@@ -229,6 +246,10 @@ class HciAidlHal extends android.hardware.bluetooth.IBluetoothHciCallbacks.Stub
         } catch (RemoteException error) {
             Log.w(TAG, "failed to forward packet: " + error);
         }
+
+        if (mTracingEnabled) {
+            Trace.endAsyncSection("SEND_PACKET_TO_HAL", 1);
+        }
     }
 
     // IBluetoothHciCallbacks methods.

extras/android/RemoteHCI/app/src/main/java/com/github/google/bumble/remotehci/HciServer.java

@@ -1,5 +1,6 @@
 package com.github.google.bumble.remotehci;
 
+import android.os.Trace;
 import android.util.Log;
 
 import java.io.IOException;
@@ -15,6 +16,7 @@ public class HciServer {
     private final int mPort;
     private final Listener mListener;
     private OutputStream mOutputStream;
+    private final boolean mTracingEnabled = Trace.isEnabled();
 
     public interface Listener extends HciParser.Sink {
         void onHostConnectionState(boolean connected);
@@ -27,6 +29,8 @@ public class HciServer {
     }
 
     public void run() throws IOException {
+        Log.i(TAG, "Tracing enabled: "  + mTracingEnabled);
+
         for (;;) {
             try {
                 loop();
@@ -73,6 +77,10 @@ public class HciServer {
     }
 
     public void sendPacket(HciPacket.Type type, byte[] packet) {
+        if (mTracingEnabled) {
+            Trace.beginAsyncSection("SEND_PACKET_FROM_HAL", 2);
+        }
+
         // Create a combined data buffer so we can write it out in a single call.
         byte[] data = new byte[packet.length + 1];
         data[0] = type.value;
@@ -89,5 +97,9 @@ public class HciServer {
                 Log.d(TAG, "no client, dropping packet");
             }
         }
+
+        if (mTracingEnabled) {
+            Trace.endAsyncSection("SEND_PACKET_FROM_HAL", 2);
+        }
     }
 }

tests/device_test.py

@@ -50,6 +50,8 @@ from bumble.gatt import (
     GATT_APPEARANCE_CHARACTERISTIC,
 )
 
+from .test_utils import TwoDevices
+
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
@@ -412,6 +414,15 @@ async def test_extended_advertising_disconnection(auto_restart):
         device.start_extended_advertising.assert_not_called()
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+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
+
+
 # -----------------------------------------------------------------------------
 def test_gatt_services_with_gas():
     device = Device(host=Host(None, None))

tests/hfp_test.py

@@ -23,9 +23,11 @@ import pytest
 from typing import Tuple
 
 from .test_utils import TwoDevices
+from bumble import core
+from bumble import device
 from bumble import hfp
 from bumble import rfcomm
-
+from bumble import hci
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -87,6 +89,63 @@ async def test_slc():
     ag_task.cancel()
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_sco_setup():
+    devices = TwoDevices()
+
+    # Enable Classic connections
+    devices[0].classic_enabled = True
+    devices[1].classic_enabled = True
+
+    # Start
+    await devices[0].power_on()
+    await devices[1].power_on()
+
+    connections = await asyncio.gather(
+        devices[0].connect(
+            devices[1].public_address, transport=core.BT_BR_EDR_TRANSPORT
+        ),
+        devices[1].accept(devices[0].public_address),
+    )
+
+    def on_sco_request(_connection: device.Connection, _link_type: int):
+        connections[1].abort_on(
+            'disconnection',
+            devices[1].send_command(
+                hci.HCI_Enhanced_Accept_Synchronous_Connection_Request_Command(
+                    bd_addr=connections[1].peer_address,
+                    **hfp.ESCO_PARAMETERS[
+                        hfp.DefaultCodecParameters.ESCO_CVSD_S1
+                    ].asdict(),
+                )
+            ),
+        )
+
+    devices[1].on('sco_request', on_sco_request)
+
+    sco_connections = [
+        asyncio.get_running_loop().create_future(),
+        asyncio.get_running_loop().create_future(),
+    ]
+
+    devices[0].on(
+        'sco_connection', lambda sco_link: sco_connections[0].set_result(sco_link)
+    )
+    devices[1].on(
+        'sco_connection', lambda sco_link: sco_connections[1].set_result(sco_link)
+    )
+
+    await devices[0].send_command(
+        hci.HCI_Enhanced_Setup_Synchronous_Connection_Command(
+            connection_handle=connections[0].handle,
+            **hfp.ESCO_PARAMETERS[hfp.DefaultCodecParameters.ESCO_CVSD_S1].asdict(),
+        )
+    )
+
+    await asyncio.gather(*sco_connections)
+
+
 # -----------------------------------------------------------------------------
 async def run():
     await test_slc()

tests/test_utils.py

@@ -29,17 +29,18 @@ class TwoDevices:
         self.connections = [None, None]
 
         self.link = LocalLink()
+        addresses = ['F0:F1:F2:F3:F4:F5', 'F5:F4:F3:F2:F1:F0']
         self.controllers = [
-            Controller('C1', link=self.link),
-            Controller('C2', link=self.link),
+            Controller('C1', link=self.link, public_address=addresses[0]),
+            Controller('C2', link=self.link, public_address=addresses[1]),
         ]
         self.devices = [
             Device(
-                address=Address('F0:F1:F2:F3:F4:F5'),
+                address=Address(addresses[0]),
                 host=Host(self.controllers[0], AsyncPipeSink(self.controllers[0])),
             ),
             Device(
-                address=Address('F5:F4:F3:F2:F1:F0'),
+                address=Address(addresses[1]),
                 host=Host(self.controllers[1], AsyncPipeSink(self.controllers[1])),
             ),
         ]