bumble 0.0.222__py3-none-any.whl → 0.0.224__py3-none-any.whl

bumble/drivers/intel.py

@@ -89,52 +89,55 @@ HCI_INTEL_WRITE_BOOT_PARAMS_COMMAND = hci.hci_vendor_command_op_code(0x000E)
 hci.HCI_Command.register_commands(globals())
 
 
-@hci.HCI_Command.command
 @dataclasses.dataclass
-class HCI_Intel_Read_Version_Command(hci.HCI_Command):
-    param0: int = dataclasses.field(metadata=hci.metadata(1))
+class HCI_Intel_Read_Version_ReturnParameters(hci.HCI_StatusReturnParameters):
+    tlv: bytes = hci.field(metadata=hci.metadata('*'))
+
 
-    return_parameters_fields = [
-        ("status", hci.STATUS_SPEC),
-        ("tlv", "*"),
-    ]
+@hci.HCI_SyncCommand.sync_command(HCI_Intel_Read_Version_ReturnParameters)
+@dataclasses.dataclass
+class HCI_Intel_Read_Version_Command(
+    hci.HCI_SyncCommand[HCI_Intel_Read_Version_ReturnParameters]
+):
+    param0: int = dataclasses.field(metadata=hci.metadata(1))
 
 
-@hci.HCI_Command.command
+@hci.HCI_SyncCommand.sync_command(hci.HCI_StatusReturnParameters)
 @dataclasses.dataclass
-class Hci_Intel_Secure_Send_Command(hci.HCI_Command):
+class Hci_Intel_Secure_Send_Command(
+    hci.HCI_SyncCommand[hci.HCI_StatusReturnParameters]
+):
     data_type: int = dataclasses.field(metadata=hci.metadata(1))
     data: bytes = dataclasses.field(metadata=hci.metadata("*"))
 
-    return_parameters_fields = [
-        ("status", 1),
-    ]
+
+@dataclasses.dataclass
+class HCI_Intel_Reset_ReturnParameters(hci.HCI_ReturnParameters):
+    data: bytes = hci.field(metadata=hci.metadata('*'))
 
 
-@hci.HCI_Command.command
+@hci.HCI_SyncCommand.sync_command(HCI_Intel_Reset_ReturnParameters)
 @dataclasses.dataclass
-class HCI_Intel_Reset_Command(hci.HCI_Command):
+class HCI_Intel_Reset_Command(hci.HCI_SyncCommand[HCI_Intel_Reset_ReturnParameters]):
     reset_type: int = dataclasses.field(metadata=hci.metadata(1))
     patch_enable: int = dataclasses.field(metadata=hci.metadata(1))
     ddc_reload: int = dataclasses.field(metadata=hci.metadata(1))
     boot_option: int = dataclasses.field(metadata=hci.metadata(1))
     boot_address: int = dataclasses.field(metadata=hci.metadata(4))
 
-    return_parameters_fields = [
-        ("data", "*"),
-    ]
+
+@dataclasses.dataclass
+class HCI_Intel_Write_Device_Config_ReturnParameters(hci.HCI_StatusReturnParameters):
+    params: bytes = hci.field(metadata=hci.metadata('*'))
 
 
-@hci.HCI_Command.command
+@hci.HCI_SyncCommand.sync_command(HCI_Intel_Write_Device_Config_ReturnParameters)
 @dataclasses.dataclass
-class Hci_Intel_Write_Device_Config_Command(hci.HCI_Command):
+class HCI_Intel_Write_Device_Config_Command(
+    hci.HCI_SyncCommand[HCI_Intel_Write_Device_Config_ReturnParameters]
+):
     data: bytes = dataclasses.field(metadata=hci.metadata("*"))
 
-    return_parameters_fields = [
-        ("status", hci.STATUS_SPEC),
-        ("params", "*"),
-    ]
-
 
 # -----------------------------------------------------------------------------
 # Functions
@@ -402,7 +405,7 @@ class Driver(common.Driver):
             self.host.on_hci_event_packet(event)
             return
 
-        if not event.return_parameters == hci.HCI_SUCCESS:
+        if not event.return_parameters.status == hci.HCI_SUCCESS:
             raise DriverError("HCI_Command_Complete_Event error")
 
         if self.max_in_flight_firmware_load_commands != event.num_hci_command_packets:
@@ -641,8 +644,8 @@ class Driver(common.Driver):
         while ddc_data:
             ddc_len = 1 + ddc_data[0]
             ddc_payload = ddc_data[:ddc_len]
-            await self.host.send_command(
-                Hci_Intel_Write_Device_Config_Command(data=ddc_payload)
+            await self.host.send_sync_command(
+                HCI_Intel_Write_Device_Config_Command(data=ddc_payload)
             )
             ddc_data = ddc_data[ddc_len:]
 
@@ -660,31 +663,34 @@ class Driver(common.Driver):
 
     async def read_device_info(self) -> dict[ValueType, Any]:
         self.host.ready = True
-        response = await self.host.send_command(hci.HCI_Reset_Command())
-        if not (
-            isinstance(response, hci.HCI_Command_Complete_Event)
-            and response.return_parameters
-            in (hci.HCI_UNKNOWN_HCI_COMMAND_ERROR, hci.HCI_SUCCESS)
+        response1 = await self.host.send_sync_command_raw(hci.HCI_Reset_Command())
+        if not isinstance(
+            response1.return_parameters, hci.HCI_StatusReturnParameters
+        ) or response1.return_parameters.status not in (
+            hci.HCI_UNKNOWN_HCI_COMMAND_ERROR,
+            hci.HCI_SUCCESS,
         ):
             # When the controller is in operational mode, the response is a
             # successful response.
             # When the controller is in bootloader mode,
             # HCI_UNKNOWN_HCI_COMMAND_ERROR is the expected response. Anything
             # else is a failure.
-            logger.warning(f"unexpected response: {response}")
+            logger.warning(f"unexpected response: {response1}")
             raise DriverError("unexpected HCI response")
 
         # Read the firmware version.
-        response = await self.host.send_command(
+        response2 = await self.host.send_sync_command_raw(
             HCI_Intel_Read_Version_Command(param0=0xFF)
         )
-        if not isinstance(response, hci.HCI_Command_Complete_Event):
-            raise DriverError("unexpected HCI response")
-
-        if response.return_parameters.status != 0:  # type: ignore
+        if (
+            not isinstance(
+                response2.return_parameters, HCI_Intel_Read_Version_ReturnParameters
+            )
+            or response2.return_parameters.status != 0
+        ):
             raise DriverError("HCI_Intel_Read_Version_Command error")
 
-        tlvs = _parse_tlv(response.return_parameters.tlv)  # type: ignore
+        tlvs = _parse_tlv(response2.return_parameters.tlv)  # type: ignore
 
         # Convert the list to a dict. That's Ok here because we only expect each type
         # to appear just once.

bumble/drivers/rtk.py

@@ -16,6 +16,7 @@ Support for Realtek USB dongles.
 Based on various online bits of information, including the Linux kernel.
 (see `drivers/bluetooth/btrtl.c`)
 """
+from __future__ import annotations
 
 import asyncio
 import enum
@@ -31,10 +32,14 @@ import weakref
 # Imports
 # -----------------------------------------------------------------------------
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
 
 from bumble import core, hci
 from bumble.drivers import common
 
+if TYPE_CHECKING:
+    from bumble.host import Host
+
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
@@ -77,6 +82,7 @@ class RtlProjectId(enum.IntEnum):
     PROJECT_ID_8852A = 18
     PROJECT_ID_8852B = 20
     PROJECT_ID_8852C = 25
+    PROJECT_ID_8761C = 51
 
 
 RTK_PROJECT_ID_TO_ROM = {
@@ -92,6 +98,7 @@ RTK_PROJECT_ID_TO_ROM = {
     18: RTK_ROM_LMP_8852A,
     20: RTK_ROM_LMP_8852A,
     25: RTK_ROM_LMP_8852A,
+    51: RTK_ROM_LMP_8761A,
 }
 
 # List of USB (VendorID, ProductID) for Realtek-based devices.
@@ -122,7 +129,12 @@ RTK_USB_PRODUCTS = {
     (0x2357, 0x0604),
     (0x2550, 0x8761),
     (0x2B89, 0x8761),
+    (0x2C0A, 0x8761),
     (0x7392, 0xC611),
+    # Realtek 8761CUV
+    (0x0B05, 0x1BF6),
+    (0x0BDA, 0xC761),
+    (0x7392, 0xF611),
     # Realtek 8821AE
     (0x0B05, 0x17DC),
     (0x13D3, 0x3414),
@@ -182,23 +194,36 @@ HCI_RTK_DROP_FIRMWARE_COMMAND = hci.hci_vendor_command_op_code(0x66)
 hci.HCI_Command.register_commands(globals())
 
 
-@hci.HCI_Command.command
 @dataclass
-class HCI_RTK_Read_ROM_Version_Command(hci.HCI_Command):
-    return_parameters_fields = [("status", hci.STATUS_SPEC), ("version", 1)]
+class HCI_RTK_Read_ROM_Version_ReturnParameters(hci.HCI_StatusReturnParameters):
+    version: int = field(metadata=hci.metadata(1))
+
+
+@hci.HCI_SyncCommand.sync_command(HCI_RTK_Read_ROM_Version_ReturnParameters)
+@dataclass
+class HCI_RTK_Read_ROM_Version_Command(
+    hci.HCI_SyncCommand[HCI_RTK_Read_ROM_Version_ReturnParameters]
+):
+    pass
+
+
+@dataclass
+class HCI_RTK_Download_ReturnParameters(hci.HCI_StatusReturnParameters):
+    index: int = field(metadata=hci.metadata(1))
 
 
-@hci.HCI_Command.command
+@hci.HCI_SyncCommand.sync_command(HCI_RTK_Download_ReturnParameters)
 @dataclass
-class HCI_RTK_Download_Command(hci.HCI_Command):
+class HCI_RTK_Download_Command(hci.HCI_SyncCommand[HCI_RTK_Download_ReturnParameters]):
     index: int = field(metadata=hci.metadata(1))
     payload: bytes = field(metadata=hci.metadata(RTK_FRAGMENT_LENGTH))
-    return_parameters_fields = [("status", hci.STATUS_SPEC), ("index", 1)]
 
 
-@hci.HCI_Command.command
+@hci.HCI_SyncCommand.sync_command(hci.HCI_GenericReturnParameters)
 @dataclass
-class HCI_RTK_Drop_Firmware_Command(hci.HCI_Command):
+class HCI_RTK_Drop_Firmware_Command(
+    hci.HCI_SyncCommand[hci.HCI_GenericReturnParameters]
+):
     pass
 
 
@@ -363,6 +388,15 @@ class Driver(common.Driver):
             fw_name="rtl8761bu_fw.bin",
             config_name="rtl8761bu_config.bin",
         ),
+        # 8761CU
+        DriverInfo(
+            rom=RTK_ROM_LMP_8761A,
+            hci=(0x0E, 0x00),
+            config_needed=False,
+            has_rom_version=True,
+            fw_name="rtl8761cu_fw.bin",
+            config_name="rtl8761cu_config.bin",
+        ),
         # 8822C
         DriverInfo(
             rom=RTK_ROM_LMP_8822B,
@@ -420,9 +454,17 @@ class Driver(common.Driver):
     @staticmethod
     def find_driver_info(hci_version, hci_subversion, lmp_subversion):
         for driver_info in Driver.DRIVER_INFOS:
-            if driver_info.rom == lmp_subversion and driver_info.hci == (
-                hci_subversion,
-                hci_version,
+            if driver_info.rom == lmp_subversion and (
+                driver_info.hci
+                == (
+                    hci_subversion,
+                    hci_version,
+                )
+                or driver_info.hci
+                == (
+                    hci_subversion,
+                    0x0,
+                )
             ):
                 return driver_info
 
@@ -467,7 +509,7 @@ class Driver(common.Driver):
         return None
 
     @staticmethod
-    def check(host):
+    def check(host: Host) -> bool:
         if not host.hci_metadata:
             logger.debug("USB metadata not found")
             return False
@@ -491,37 +533,44 @@ class Driver(common.Driver):
         return True
 
     @staticmethod
-    async def get_loaded_firmware_version(host):
-        response = await host.send_command(HCI_RTK_Read_ROM_Version_Command())
-
-        if response.return_parameters.status != hci.HCI_SUCCESS:
+    async def get_loaded_firmware_version(host: Host) -> int | None:
+        response1 = await host.send_sync_command_raw(HCI_RTK_Read_ROM_Version_Command())
+        if (
+            not isinstance(
+                response1.return_parameters, HCI_RTK_Read_ROM_Version_ReturnParameters
+            )
+            or response1.return_parameters.status != hci.HCI_SUCCESS
+        ):
             return None
 
-        response = await host.send_command(
-            hci.HCI_Read_Local_Version_Information_Command(), check_result=True
-        )
-        return (
-            response.return_parameters.hci_subversion << 16
-            | response.return_parameters.lmp_subversion
+        response2 = await host.send_sync_command(
+            hci.HCI_Read_Local_Version_Information_Command()
         )
+        return response2.hci_subversion << 16 | response2.lmp_subversion
 
     @classmethod
-    async def driver_info_for_host(cls, host):
+    async def driver_info_for_host(cls, host: Host) -> DriverInfo | None:
         try:
-            await host.send_command(
+            await host.send_sync_command(
                 hci.HCI_Reset_Command(),
-                check_result=True,
                 response_timeout=cls.POST_RESET_DELAY,
             )
             host.ready = True  # Needed to let the host know the controller is ready.
         except asyncio.exceptions.TimeoutError:
             logger.warning("timeout waiting for hci reset, retrying")
-            await host.send_command(hci.HCI_Reset_Command(), check_result=True)
+            await host.send_sync_command(hci.HCI_Reset_Command())
             host.ready = True
 
-        command = hci.HCI_Read_Local_Version_Information_Command()
-        response = await host.send_command(command, check_result=True)
-        if response.command_opcode != command.op_code:
+        response = await host.send_sync_command_raw(
+            hci.HCI_Read_Local_Version_Information_Command()
+        )
+        if (
+            not isinstance(
+                response.return_parameters,
+                hci.HCI_Read_Local_Version_Information_ReturnParameters,
+            )
+            or response.return_parameters.status != hci.HCI_SUCCESS
+        ):
             logger.error("failed to probe local version information")
             return None
 
@@ -546,7 +595,7 @@ class Driver(common.Driver):
         return driver_info
 
     @classmethod
-    async def for_host(cls, host, force=False):
+    async def for_host(cls, host: Host, force: bool = False):
         # Check that a driver is needed for this host
         if not force and not cls.check(host):
             return None
@@ -601,15 +650,21 @@ class Driver(common.Driver):
 
         # TODO: load the firmware
 
-    async def download_for_rtl8723b(self):
+    async def download_for_rtl8723b(self) -> int | None:
         if self.driver_info.has_rom_version:
-            response = await self.host.send_command(
-                HCI_RTK_Read_ROM_Version_Command(), check_result=True
+            response1 = await self.host.send_sync_command_raw(
+                HCI_RTK_Read_ROM_Version_Command()
             )
-            if response.return_parameters.status != hci.HCI_SUCCESS:
+            if (
+                not isinstance(
+                    response1.return_parameters,
+                    HCI_RTK_Read_ROM_Version_ReturnParameters,
+                )
+                or response1.return_parameters.status != hci.HCI_SUCCESS
+            ):
                 logger.warning("can't get ROM version")
                 return None
-            rom_version = response.return_parameters.version
+            rom_version = response1.return_parameters.version
             logger.debug(f"ROM version before download: {rom_version:04X}")
         else:
             rom_version = 0
@@ -644,21 +699,25 @@ class Driver(common.Driver):
             fragment_offset = fragment_index * RTK_FRAGMENT_LENGTH
             fragment = payload[fragment_offset : fragment_offset + RTK_FRAGMENT_LENGTH]
             logger.debug(f"downloading fragment {fragment_index}")
-            await self.host.send_command(
-                HCI_RTK_Download_Command(index=download_index, payload=fragment),
-                check_result=True,
+            await self.host.send_sync_command(
+                HCI_RTK_Download_Command(index=download_index, payload=fragment)
             )
 
         logger.debug("download complete!")
 
         # Read the version again
-        response = await self.host.send_command(
-            HCI_RTK_Read_ROM_Version_Command(), check_result=True
+        response2 = await self.host.send_sync_command_raw(
+            HCI_RTK_Read_ROM_Version_Command()
         )
-        if response.return_parameters.status != hci.HCI_SUCCESS:
+        if (
+            not isinstance(
+                response2.return_parameters, HCI_RTK_Read_ROM_Version_ReturnParameters
+            )
+            or response2.return_parameters.status != hci.HCI_SUCCESS
+        ):
             logger.warning("can't get ROM version")
         else:
-            rom_version = response.return_parameters.version
+            rom_version = response2.return_parameters.version
             logger.debug(f"ROM version after download: {rom_version:02X}")
 
         return firmware.version
@@ -680,7 +739,7 @@ class Driver(common.Driver):
 
     async def init_controller(self):
         await self.download_firmware()
-        await self.host.send_command(hci.HCI_Reset_Command(), check_result=True)
+        await self.host.send_sync_command(hci.HCI_Reset_Command())
         logger.info(f"loaded FW image {self.driver_info.fw_name}")
 
 

bumble/gatt.py

@@ -29,7 +29,7 @@ import functools
 import logging
 import struct
 from collections.abc import Iterable, Sequence
-from typing import TypeVar
+from typing import ClassVar, TypeVar
 
 from bumble.att import Attribute, AttributeValue, AttributeValueV2
 from bumble.colors import color
@@ -403,7 +403,7 @@ class TemplateService(Service):
     to expose their UUID as a class property
     '''
 
-    UUID: UUID
+    UUID: ClassVar[UUID]
 
     def __init__(
         self,

bumble/gatt_client.py

@@ -34,11 +34,14 @@ from datetime import datetime
 from typing import (
     TYPE_CHECKING,
     Any,
+    ClassVar,
     Generic,
     TypeVar,
     overload,
 )
 
+from typing_extensions import Self
+
 from bumble import att, core, l2cap, utils
 from bumble.colors import color
 from bumble.core import UUID, InvalidStateError
@@ -249,10 +252,10 @@ class ProfileServiceProxy:
     Base class for profile-specific service proxies
     '''
 
-    SERVICE_CLASS: type[TemplateService]
+    SERVICE_CLASS: ClassVar[type[TemplateService]]
 
     @classmethod
-    def from_client(cls, client: Client) -> ProfileServiceProxy | None:
+    def from_client(cls, client: Client) -> Self | None:
         return ServiceProxy.from_client(cls, client, cls.SERVICE_CLASS.UUID)
 
 
@@ -285,8 +288,6 @@ class Client:
             self._bearer_id = (
                 f'[0x{bearer.connection.handle:04X}|CID=0x{bearer.source_cid:04X}]'
             )
-            # Fill the mtu.
-            bearer.on_att_mtu_update(att.ATT_DEFAULT_MTU)
             self.connection = bearer.connection
         else:
             bearer.on(bearer.EVENT_DISCONNECTION, self.on_disconnection)

bumble/gatt_server.py

@@ -115,7 +115,6 @@ class Server(utils.EventEmitter):
                 channel.connection.handle,
                 channel.source_cid,
             )
-            channel.att_mtu = att.ATT_DEFAULT_MTU
             channel.sink = lambda pdu: self.on_gatt_pdu(
                 channel, att.ATT_PDU.from_bytes(pdu)
             )
@@ -777,6 +776,18 @@ class Server(utils.EventEmitter):
             error_code=att.ATT_ATTRIBUTE_NOT_FOUND_ERROR,
         )
 
+        if (
+            request.starting_handle == 0x0000
+            or request.starting_handle > request.ending_handle
+        ):
+            response = att.ATT_Error_Response(
+                request_opcode_in_error=request.op_code,
+                attribute_handle_in_error=request.starting_handle,
+                error_code=att.ATT_INVALID_HANDLE_ERROR,
+            )
+            self.send_response(bearer, response)
+            return
+
         attributes: list[tuple[int, bytes]] = []
         for attribute in (
             attribute
@@ -977,6 +988,94 @@ class Server(utils.EventEmitter):
 
         self.send_response(bearer, response)
 
+    @utils.AsyncRunner.run_in_task()
+    async def on_att_read_multiple_request(
+        self, bearer: att.Bearer, request: att.ATT_Read_Multiple_Request
+    ):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.4.7 Read Multiple Request.
+        '''
+        response: att.ATT_PDU
+
+        pdu_space_available = bearer.att_mtu - 1
+        values: list[bytes] = []
+
+        for handle in request.set_of_handles:
+            if not (attribute := self.get_attribute(handle)):
+                response = att.ATT_Error_Response(
+                    request_opcode_in_error=request.op_code,
+                    attribute_handle_in_error=handle,
+                    error_code=att.ATT_ATTRIBUTE_NOT_FOUND_ERROR,
+                )
+                self.send_response(bearer, response)
+                return
+            # No need to catch permission errors here, since these attributes
+            # must all be world-readable
+            attribute_value = await attribute.read_value(bearer)
+            # Check the attribute value size
+            max_attribute_size = min(bearer.att_mtu - 1, 251)
+            if len(attribute_value) > max_attribute_size:
+                # We need to truncate
+                attribute_value = attribute_value[:max_attribute_size]
+
+            # Check if there is enough space
+            entry_size = len(attribute_value)
+            if pdu_space_available < entry_size:
+                break
+
+            # Add the attribute to the list
+            values.append(attribute_value)
+            pdu_space_available -= entry_size
+
+        response = att.ATT_Read_Multiple_Response(set_of_values=b''.join(values))
+        self.send_response(bearer, response)
+
+    @utils.AsyncRunner.run_in_task()
+    async def on_att_read_multiple_variable_request(
+        self, bearer: att.Bearer, request: att.ATT_Read_Multiple_Variable_Request
+    ):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.4.11 Read Multiple Variable Request.
+        '''
+        response: att.ATT_PDU
+
+        pdu_space_available = bearer.att_mtu - 1
+        length_value_tuple_list: list[tuple[int, bytes]] = []
+
+        for handle in request.set_of_handles:
+            if not (attribute := self.get_attribute(handle)):
+                response = att.ATT_Error_Response(
+                    request_opcode_in_error=request.op_code,
+                    attribute_handle_in_error=handle,
+                    error_code=att.ATT_ATTRIBUTE_NOT_FOUND_ERROR,
+                )
+                self.send_response(bearer, response)
+                return
+            # No need to catch permission errors here, since these attributes
+            # must all be world-readable
+            attribute_value = await attribute.read_value(bearer)
+            length = len(attribute_value)
+            # Check the attribute value size
+            max_attribute_size = min(bearer.att_mtu - 3, 251)
+            if len(attribute_value) > max_attribute_size:
+                # We need to truncate
+                attribute_value = attribute_value[:max_attribute_size]
+
+            # Check if there is enough space
+            entry_size = 2 + len(attribute_value)
+
+            # Add the attribute to the list
+            length_value_tuple_list.append((length, attribute_value))
+            pdu_space_available -= entry_size
+
+            if pdu_space_available <= 0:
+                break
+
+        response = att.ATT_Read_Multiple_Variable_Response(
+            length_value_tuple_list=length_value_tuple_list
+        )
+        self.send_response(bearer, response)
+
     @utils.AsyncRunner.run_in_task()
     async def on_att_write_request(
         self, bearer: att.Bearer, request: att.ATT_Write_Request