bumble 0.0.199__py3-none-any.whl → 0.0.201__py3-none-any.whl

bumble/codecs.py

@@ -17,6 +17,7 @@
 # -----------------------------------------------------------------------------
 from __future__ import annotations
 from dataclasses import dataclass
+from typing_extensions import Self
 
 from bumble import core
 
@@ -101,12 +102,40 @@ class BitReader:
                 break
 
 
+# -----------------------------------------------------------------------------
+class BitWriter:
+    """Simple but not optimized bit stream writer."""
+
+    data: int
+    bit_count: int
+
+    def __init__(self) -> None:
+        self.data = 0
+        self.bit_count = 0
+
+    def write(self, value: int, bit_count: int) -> None:
+        self.data = (self.data << bit_count) | value
+        self.bit_count += bit_count
+
+    def write_bytes(self, data: bytes) -> None:
+        bit_count = 8 * len(data)
+        self.data = (self.data << bit_count) | int.from_bytes(data, 'big')
+        self.bit_count += bit_count
+
+    def __bytes__(self) -> bytes:
+        return (self.data << ((8 - (self.bit_count % 8)) % 8)).to_bytes(
+            (self.bit_count + 7) // 8, 'big'
+        )
+
+
 # -----------------------------------------------------------------------------
 class AacAudioRtpPacket:
     """AAC payload encapsulated in an RTP packet payload"""
 
+    audio_mux_element: AudioMuxElement
+
     @staticmethod
-    def latm_value(reader: BitReader) -> int:
+    def read_latm_value(reader: BitReader) -> int:
         bytes_for_value = reader.read(2)
         value = 0
         for _ in range(bytes_for_value + 1):
@@ -114,24 +143,33 @@ class AacAudioRtpPacket:
         return value
 
     @staticmethod
-    def program_config_element(reader: BitReader):
-        raise core.InvalidPacketError('program_config_element not supported')
+    def read_audio_object_type(reader: BitReader):
+        # GetAudioObjectType - ISO/EIC 14496-3 Table 1.16
+        audio_object_type = reader.read(5)
+        if audio_object_type == 31:
+            audio_object_type = 32 + reader.read(6)
+
+        return audio_object_type
 
     @dataclass
     class GASpecificConfig:
-        def __init__(
-            self, reader: BitReader, channel_configuration: int, audio_object_type: int
-        ) -> None:
+        audio_object_type: int
+        # NOTE: other fields not supported
+
+        @classmethod
+        def from_bits(
+            cls, reader: BitReader, channel_configuration: int, audio_object_type: int
+        ) -> Self:
             # GASpecificConfig - ISO/EIC 14496-3 Table 4.1
             frame_length_flag = reader.read(1)
             depends_on_core_coder = reader.read(1)
             if depends_on_core_coder:
-                self.core_coder_delay = reader.read(14)
+                core_coder_delay = reader.read(14)
             extension_flag = reader.read(1)
             if not channel_configuration:
-                AacAudioRtpPacket.program_config_element(reader)
+                raise core.InvalidPacketError('program_config_element not supported')
             if audio_object_type in (6, 20):
-                self.layer_nr = reader.read(3)
+                layer_nr = reader.read(3)
             if extension_flag:
                 if audio_object_type == 22:
                     num_of_sub_frame = reader.read(5)
@@ -144,14 +182,13 @@ class AacAudioRtpPacket:
                 if extension_flag_3 == 1:
                     raise core.InvalidPacketError('extensionFlag3 == 1 not supported')
 
-    @staticmethod
-    def audio_object_type(reader: BitReader):
-        # GetAudioObjectType - ISO/EIC 14496-3 Table 1.16
-        audio_object_type = reader.read(5)
-        if audio_object_type == 31:
-            audio_object_type = 32 + reader.read(6)
+            return cls(audio_object_type)
 
-        return audio_object_type
+        def to_bits(self, writer: BitWriter) -> None:
+            assert self.audio_object_type in (1, 2)
+            writer.write(0, 1)  # frame_length_flag = 0
+            writer.write(0, 1)  # depends_on_core_coder = 0
+            writer.write(0, 1)  # extension_flag = 0
 
     @dataclass
     class AudioSpecificConfig:
@@ -159,6 +196,7 @@ class AacAudioRtpPacket:
         sampling_frequency_index: int
         sampling_frequency: int
         channel_configuration: int
+        ga_specific_config: AacAudioRtpPacket.GASpecificConfig
         sbr_present_flag: int
         ps_present_flag: int
         extension_audio_object_type: int
@@ -182,44 +220,73 @@ class AacAudioRtpPacket:
             7350,
         ]
 
-        def __init__(self, reader: BitReader) -> None:
+        @classmethod
+        def for_simple_aac(
+            cls,
+            audio_object_type: int,
+            sampling_frequency: int,
+            channel_configuration: int,
+        ) -> Self:
+            if sampling_frequency not in cls.SAMPLING_FREQUENCIES:
+                raise ValueError(f'invalid sampling frequency {sampling_frequency}')
+
+            ga_specific_config = AacAudioRtpPacket.GASpecificConfig(audio_object_type)
+
+            return cls(
+                audio_object_type=audio_object_type,
+                sampling_frequency_index=cls.SAMPLING_FREQUENCIES.index(
+                    sampling_frequency
+                ),
+                sampling_frequency=sampling_frequency,
+                channel_configuration=channel_configuration,
+                ga_specific_config=ga_specific_config,
+                sbr_present_flag=0,
+                ps_present_flag=0,
+                extension_audio_object_type=0,
+                extension_sampling_frequency_index=0,
+                extension_sampling_frequency=0,
+                extension_channel_configuration=0,
+            )
+
+        @classmethod
+        def from_bits(cls, reader: BitReader) -> Self:
             # AudioSpecificConfig - ISO/EIC 14496-3 Table 1.15
-            self.audio_object_type = AacAudioRtpPacket.audio_object_type(reader)
-            self.sampling_frequency_index = reader.read(4)
-            if self.sampling_frequency_index == 0xF:
-                self.sampling_frequency = reader.read(24)
+            audio_object_type = AacAudioRtpPacket.read_audio_object_type(reader)
+            sampling_frequency_index = reader.read(4)
+            if sampling_frequency_index == 0xF:
+                sampling_frequency = reader.read(24)
             else:
-                self.sampling_frequency = self.SAMPLING_FREQUENCIES[
-                    self.sampling_frequency_index
-                ]
-            self.channel_configuration = reader.read(4)
-            self.sbr_present_flag = -1
-            self.ps_present_flag = -1
-            if self.audio_object_type in (5, 29):
-                self.extension_audio_object_type = 5
-                self.sbc_present_flag = 1
-                if self.audio_object_type == 29:
-                    self.ps_present_flag = 1
-                self.extension_sampling_frequency_index = reader.read(4)
-                if self.extension_sampling_frequency_index == 0xF:
-                    self.extension_sampling_frequency = reader.read(24)
+                sampling_frequency = cls.SAMPLING_FREQUENCIES[sampling_frequency_index]
+            channel_configuration = reader.read(4)
+            sbr_present_flag = 0
+            ps_present_flag = 0
+            extension_sampling_frequency_index = 0
+            extension_sampling_frequency = 0
+            extension_channel_configuration = 0
+            extension_audio_object_type = 0
+            if audio_object_type in (5, 29):
+                extension_audio_object_type = 5
+                sbr_present_flag = 1
+                if audio_object_type == 29:
+                    ps_present_flag = 1
+                extension_sampling_frequency_index = reader.read(4)
+                if extension_sampling_frequency_index == 0xF:
+                    extension_sampling_frequency = reader.read(24)
                 else:
-                    self.extension_sampling_frequency = self.SAMPLING_FREQUENCIES[
-                        self.extension_sampling_frequency_index
+                    extension_sampling_frequency = cls.SAMPLING_FREQUENCIES[
+                        extension_sampling_frequency_index
                     ]
-                self.audio_object_type = AacAudioRtpPacket.audio_object_type(reader)
-                if self.audio_object_type == 22:
-                    self.extension_channel_configuration = reader.read(4)
-            else:
-                self.extension_audio_object_type = 0
+                audio_object_type = AacAudioRtpPacket.read_audio_object_type(reader)
+                if audio_object_type == 22:
+                    extension_channel_configuration = reader.read(4)
 
-            if self.audio_object_type in (1, 2, 3, 4, 6, 7, 17, 19, 20, 21, 22, 23):
-                ga_specific_config = AacAudioRtpPacket.GASpecificConfig(
-                    reader, self.channel_configuration, self.audio_object_type
+            if audio_object_type in (1, 2, 3, 4, 6, 7, 17, 19, 20, 21, 22, 23):
+                ga_specific_config = AacAudioRtpPacket.GASpecificConfig.from_bits(
+                    reader, channel_configuration, audio_object_type
                 )
             else:
                 raise core.InvalidPacketError(
-                    f'audioObjectType {self.audio_object_type} not supported'
+                    f'audioObjectType {audio_object_type} not supported'
                 )
 
             # if self.extension_audio_object_type != 5 and bits_to_decode >= 16:
@@ -248,13 +315,44 @@ class AacAudioRtpPacket:
             #                     self.extension_sampling_frequency = self.SAMPLING_FREQUENCIES[self.extension_sampling_frequency_index]
             #             self.extension_channel_configuration = reader.read(4)
 
+            return cls(
+                audio_object_type,
+                sampling_frequency_index,
+                sampling_frequency,
+                channel_configuration,
+                ga_specific_config,
+                sbr_present_flag,
+                ps_present_flag,
+                extension_audio_object_type,
+                extension_sampling_frequency_index,
+                extension_sampling_frequency,
+                extension_channel_configuration,
+            )
+
+        def to_bits(self, writer: BitWriter) -> None:
+            if self.sampling_frequency_index >= 15:
+                raise ValueError(
+                    f"unsupported sampling frequency index {self.sampling_frequency_index}"
+                )
+
+            if self.audio_object_type not in (1, 2):
+                raise ValueError(
+                    f"unsupported audio object type {self.audio_object_type} "
+                )
+
+            writer.write(self.audio_object_type, 5)
+            writer.write(self.sampling_frequency_index, 4)
+            writer.write(self.channel_configuration, 4)
+            self.ga_specific_config.to_bits(writer)
+
     @dataclass
     class StreamMuxConfig:
         other_data_present: int
         other_data_len_bits: int
         audio_specific_config: AacAudioRtpPacket.AudioSpecificConfig
 
-        def __init__(self, reader: BitReader) -> None:
+        @classmethod
+        def from_bits(cls, reader: BitReader) -> Self:
             # StreamMuxConfig - ISO/EIC 14496-3 Table 1.42
             audio_mux_version = reader.read(1)
             if audio_mux_version == 1:
@@ -264,7 +362,7 @@ class AacAudioRtpPacket:
             if audio_mux_version_a != 0:
                 raise core.InvalidPacketError('audioMuxVersionA != 0 not supported')
             if audio_mux_version == 1:
-                tara_buffer_fullness = AacAudioRtpPacket.latm_value(reader)
+                tara_buffer_fullness = AacAudioRtpPacket.read_latm_value(reader)
             stream_cnt = 0
             all_streams_same_time_framing = reader.read(1)
             num_sub_frames = reader.read(6)
@@ -275,13 +373,13 @@ class AacAudioRtpPacket:
             if num_layer != 0:
                 raise core.InvalidPacketError('num_layer != 0 not supported')
             if audio_mux_version == 0:
-                self.audio_specific_config = AacAudioRtpPacket.AudioSpecificConfig(
+                audio_specific_config = AacAudioRtpPacket.AudioSpecificConfig.from_bits(
                     reader
                 )
             else:
-                asc_len = AacAudioRtpPacket.latm_value(reader)
+                asc_len = AacAudioRtpPacket.read_latm_value(reader)
                 marker = reader.bit_position
-                self.audio_specific_config = AacAudioRtpPacket.AudioSpecificConfig(
+                audio_specific_config = AacAudioRtpPacket.AudioSpecificConfig.from_bits(
                     reader
                 )
                 audio_specific_config_len = reader.bit_position - marker
@@ -299,36 +397,49 @@ class AacAudioRtpPacket:
                     f'frame_length_type {frame_length_type} not supported'
                 )
 
-            self.other_data_present = reader.read(1)
-            if self.other_data_present:
+            other_data_present = reader.read(1)
+            other_data_len_bits = 0
+            if other_data_present:
                 if audio_mux_version == 1:
-                    self.other_data_len_bits = AacAudioRtpPacket.latm_value(reader)
+                    other_data_len_bits = AacAudioRtpPacket.read_latm_value(reader)
                 else:
-                    self.other_data_len_bits = 0
                     while True:
-                        self.other_data_len_bits *= 256
+                        other_data_len_bits *= 256
                         other_data_len_esc = reader.read(1)
-                        self.other_data_len_bits += reader.read(8)
+                        other_data_len_bits += reader.read(8)
                         if other_data_len_esc == 0:
                             break
             crc_check_present = reader.read(1)
             if crc_check_present:
                 crc_checksum = reader.read(8)
 
+            return cls(other_data_present, other_data_len_bits, audio_specific_config)
+
+        def to_bits(self, writer: BitWriter) -> None:
+            writer.write(0, 1)  # audioMuxVersion = 0
+            writer.write(1, 1)  # allStreamsSameTimeFraming = 1
+            writer.write(0, 6)  # numSubFrames = 0
+            writer.write(0, 4)  # numProgram = 0
+            writer.write(0, 3)  # numLayer = 0
+            self.audio_specific_config.to_bits(writer)
+            writer.write(0, 3)  # frameLengthType = 0
+            writer.write(0, 8)  # latmBufferFullness = 0
+            writer.write(0, 1)  # otherDataPresent = 0
+            writer.write(0, 1)  # crcCheckPresent = 0
+
     @dataclass
     class AudioMuxElement:
-        payload: bytes
         stream_mux_config: AacAudioRtpPacket.StreamMuxConfig
+        payload: bytes
 
-        def __init__(self, reader: BitReader, mux_config_present: int):
-            if mux_config_present == 0:
-                raise core.InvalidPacketError('muxConfigPresent == 0 not supported')
-
+        @classmethod
+        def from_bits(cls, reader: BitReader) -> Self:
             # AudioMuxElement - ISO/EIC 14496-3 Table 1.41
+            # (only supports mux_config_present=1)
             use_same_stream_mux = reader.read(1)
             if use_same_stream_mux:
                 raise core.InvalidPacketError('useSameStreamMux == 1 not supported')
-            self.stream_mux_config = AacAudioRtpPacket.StreamMuxConfig(reader)
+            stream_mux_config = AacAudioRtpPacket.StreamMuxConfig.from_bits(reader)
 
             # We only support:
             # allStreamsSameTimeFraming == 1
@@ -344,19 +455,46 @@ class AacAudioRtpPacket:
                 if tmp != 255:
                     break
 
-            self.payload = reader.read_bytes(mux_slot_length_bytes)
+            payload = reader.read_bytes(mux_slot_length_bytes)
 
-            if self.stream_mux_config.other_data_present:
-                reader.skip(self.stream_mux_config.other_data_len_bits)
+            if stream_mux_config.other_data_present:
+                reader.skip(stream_mux_config.other_data_len_bits)
 
             # ByteAlign
             while reader.bit_position % 8:
                 reader.read(1)
 
-    def __init__(self, data: bytes) -> None:
+            return cls(stream_mux_config, payload)
+
+        def to_bits(self, writer: BitWriter) -> None:
+            writer.write(0, 1)  # useSameStreamMux = 0
+            self.stream_mux_config.to_bits(writer)
+            mux_slot_length_bytes = len(self.payload)
+            while mux_slot_length_bytes > 255:
+                writer.write(255, 8)
+                mux_slot_length_bytes -= 255
+            writer.write(mux_slot_length_bytes, 8)
+            if mux_slot_length_bytes == 255:
+                writer.write(0, 8)
+            writer.write_bytes(self.payload)
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> Self:
         # Parse the bit stream
         reader = BitReader(data)
-        self.audio_mux_element = self.AudioMuxElement(reader, mux_config_present=1)
+        return cls(cls.AudioMuxElement.from_bits(reader))
+
+    @classmethod
+    def for_simple_aac(
+        cls, sampling_frequency: int, channel_configuration: int, payload: bytes
+    ) -> Self:
+        audio_specific_config = cls.AudioSpecificConfig.for_simple_aac(
+            2, sampling_frequency, channel_configuration
+        )
+        stream_mux_config = cls.StreamMuxConfig(0, 0, audio_specific_config)
+        audio_mux_element = cls.AudioMuxElement(stream_mux_config, payload)
+
+        return cls(audio_mux_element)
 
     def to_adts(self):
         # pylint: disable=line-too-long
@@ -383,3 +521,11 @@ class AacAudioRtpPacket:
             )
             + self.audio_mux_element.payload
         )
+
+    def __init__(self, audio_mux_element: AudioMuxElement) -> None:
+        self.audio_mux_element = audio_mux_element
+
+    def __bytes__(self) -> bytes:
+        writer = BitWriter()
+        self.audio_mux_element.to_bits(writer)
+        return bytes(writer)

bumble/device.py

@@ -1571,14 +1571,22 @@ class Connection(CompositeEventEmitter):
                     raise
 
     def __str__(self):
-        return (
-            f'Connection(handle=0x{self.handle:04X}, '
-            f'role={self.role_name}, '
-            f'self_address={self.self_address}, '
-            f'self_resolvable_address={self.self_resolvable_address}, '
-            f'peer_address={self.peer_address}, '
-            f'peer_resolvable_address={self.peer_resolvable_address})'
-        )
+        if self.transport == BT_LE_TRANSPORT:
+            return (
+                f'Connection(transport=LE, handle=0x{self.handle:04X}, '
+                f'role={self.role_name}, '
+                f'self_address={self.self_address}, '
+                f'self_resolvable_address={self.self_resolvable_address}, '
+                f'peer_address={self.peer_address}, '
+                f'peer_resolvable_address={self.peer_resolvable_address})'
+            )
+        else:
+            return (
+                f'Connection(transport=BR/EDR, handle=0x{self.handle:04X}, '
+                f'role={self.role_name}, '
+                f'self_address={self.self_address}, '
+                f'peer_address={self.peer_address})'
+            )
 
 
 # -----------------------------------------------------------------------------
@@ -1766,9 +1774,9 @@ device_host_event_handlers: List[str] = []
 # -----------------------------------------------------------------------------
 class Device(CompositeEventEmitter):
     # Incomplete list of fields.
-    random_address: Address  # Random address that may change with RPA
-    public_address: Address  # Public address (obtained from the controller)
-    static_address: Address  # Random address that can be set but does not change
+    random_address: Address  # Random private address that may change periodically
+    public_address: Address  # Public address that is globally unique (from controller)
+    static_address: Address  # Random static address that does not change once set
     classic_enabled: bool
     name: str
     class_of_device: int

bumble/hci.py

@@ -3440,11 +3440,11 @@ class HCI_Read_Local_Supported_Codecs_V2_Command(HCI_Command):
     See Bluetooth spec @ 7.4.8 Read Local Supported Codecs Command
     '''
 
-    class Transport(OpenIntEnum):
-        BR_EDR_ACL = 0x00
-        BR_EDR_SCO = 0x01
-        LE_CIS = 0x02
-        LE_BIS = 0x03
+    class Transport(enum.IntFlag):
+        BR_EDR_ACL = 1 << 0
+        BR_EDR_SCO = 1 << 1
+        LE_CIS = 1 << 2
+        LE_BIS = 1 << 3
 
 
 # -----------------------------------------------------------------------------
@@ -6065,6 +6065,32 @@ class HCI_Read_Remote_Version_Information_Complete_Event(HCI_Event):
     '''
 
 
+# -----------------------------------------------------------------------------
+@HCI_Event.event(
+    [
+        ('status', STATUS_SPEC),
+        ('connection_handle', 2),
+        ('unused', 1),
+        (
+            'service_type',
+            {
+                'size': 1,
+                'mapper': lambda x: HCI_QOS_Setup_Complete_Event.ServiceType(x).name,
+            },
+        ),
+    ]
+)
+class HCI_QOS_Setup_Complete_Event(HCI_Event):
+    '''
+    See Bluetooth spec @ 7.7.13 QoS Setup Complete Event
+    '''
+
+    class ServiceType(OpenIntEnum):
+        NO_TRAFFIC_AVAILABLE = 0x00
+        BEST_EFFORT_AVAILABLE = 0x01
+        GUARANTEED_AVAILABLE = 0x02
+
+
 # -----------------------------------------------------------------------------
 @HCI_Event.event(
     [

bumble/hfp.py

@@ -795,29 +795,32 @@ class HfProtocol(pyee.EventEmitter):
         # Append to the read buffer.
         self.read_buffer.extend(data)
 
-        # Locate header and trailer.
-        header = self.read_buffer.find(b'\r\n')
-        trailer = self.read_buffer.find(b'\r\n', header + 2)
-        if header == -1 or trailer == -1:
-            return
-
-        # Isolate the AT response code and parameters.
-        raw_response = self.read_buffer[header + 2 : trailer]
-        response = AtResponse.parse_from(raw_response)
-        logger.debug(f"<<< {raw_response.decode()}")
-
-        # Consume the response bytes.
-        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
-        ):
-            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}'")
+        while self.read_buffer:
+            # Locate header and trailer.
+            header = self.read_buffer.find(b'\r\n')
+            trailer = self.read_buffer.find(b'\r\n', header + 2)
+            if header == -1 or trailer == -1:
+                return
+
+            # Isolate the AT response code and parameters.
+            raw_response = self.read_buffer[header + 2 : trailer]
+            response = AtResponse.parse_from(raw_response)
+            logger.debug(f"<<< {raw_response.decode()}")
+
+            # Consume the response bytes.
+            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
+            ):
+                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}'"
+                )
 
     async def execute_command(
         self,
@@ -1244,31 +1247,32 @@ class AgProtocol(pyee.EventEmitter):
         # Append to the read buffer.
         self.read_buffer.extend(data)
 
-        # Locate the trailer.
-        trailer = self.read_buffer.find(b'\r')
-        if trailer == -1:
-            return
-
-        # Isolate the AT response code and parameters.
-        raw_command = self.read_buffer[:trailer]
-        command = AtCommand.parse_from(raw_command)
-        logger.debug(f"<<< {raw_command.decode()}")
-
-        # Consume the response bytes.
-        self.read_buffer = self.read_buffer[trailer + 1 :]
-
-        if command.sub_code == AtCommand.SubCode.TEST:
-            handler_name = f'_on_{command.code.lower()}_test'
-        elif command.sub_code == AtCommand.SubCode.READ:
-            handler_name = f'_on_{command.code.lower()}_read'
-        else:
-            handler_name = f'_on_{command.code.lower()}'
-
-        if handler := getattr(self, handler_name, None):
-            handler(*command.parameters)
-        else:
-            logger.warning('Handler %s not found', handler_name)
-            self.send_response('ERROR')
+        while self.read_buffer:
+            # Locate the trailer.
+            trailer = self.read_buffer.find(b'\r')
+            if trailer == -1:
+                return
+
+            # Isolate the AT response code and parameters.
+            raw_command = self.read_buffer[:trailer]
+            command = AtCommand.parse_from(raw_command)
+            logger.debug(f"<<< {raw_command.decode()}")
+
+            # Consume the response bytes.
+            self.read_buffer = self.read_buffer[trailer + 1 :]
+
+            if command.sub_code == AtCommand.SubCode.TEST:
+                handler_name = f'_on_{command.code.lower()}_test'
+            elif command.sub_code == AtCommand.SubCode.READ:
+                handler_name = f'_on_{command.code.lower()}_read'
+            else:
+                handler_name = f'_on_{command.code.lower()}'
+
+            if handler := getattr(self, handler_name, None):
+                handler(*command.parameters)
+            else:
+                logger.warning('Handler %s not found', handler_name)
+                self.send_response('ERROR')
 
     def send_response(self, response: str) -> None:
         """Sends an AT response."""

bumble/host.py

@@ -1106,6 +1106,18 @@ class Host(AbortableEventEmitter):
                 event.status,
             )
 
+    def on_hci_qos_setup_complete_event(self, event):
+        if event.status == hci.HCI_SUCCESS:
+            self.emit(
+                'connection_qos_setup', event.connection_handle, event.service_type
+            )
+        else:
+            self.emit(
+                'connection_qos_setup_failure',
+                event.connection_handle,
+                event.status,
+            )
+
     def on_hci_link_supervision_timeout_changed_event(self, event):
         pass