fix support for float32

.github/workflows/python-avatar.yml

@@ -44,7 +44,7 @@ jobs:
         run: cat rootcanal.log
       - name: Upload Mobly logs
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
-          name: mobly-logs-${{ strategy.job-index }}
+          name: mobly-logs
           path: /tmp/logs/mobly/bumble.bumbles/

apps/auracast.py

@@ -18,14 +18,23 @@
 from __future__ import annotations
 
 import asyncio
+import asyncio.subprocess
+import collections
 import contextlib
 import dataclasses
 import functools
 import logging
 import os
-import wave
-import itertools
-from typing import cast, Any, AsyncGenerator, Coroutine, Dict, Optional, Tuple
+import struct
+from typing import (
+    cast,
+    Any,
+    AsyncGenerator,
+    Coroutine,
+    Deque,
+    Optional,
+    Tuple,
+)
 
 import click
 import pyee
@@ -33,8 +42,11 @@ import pyee
 try:
     import lc3  # type: ignore  # pylint: disable=E0401
 except ImportError as e:
-    raise ImportError("Try `python -m pip install \".[lc3]\"`.") from e
+    raise ImportError(
+        "Try `python -m pip install \"git+https://github.com/google/liblc3.git\"`."
+    ) from e
 
+from bumble.audio import io as audio_io
 from bumble.colors import color
 from bumble import company_ids
 from bumble import core
@@ -48,7 +60,6 @@ import bumble.device
 import bumble.transport
 import bumble.utils
 
-
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
@@ -62,6 +73,31 @@ AURACAST_DEFAULT_DEVICE_NAME = 'Bumble Auracast'
 AURACAST_DEFAULT_DEVICE_ADDRESS = hci.Address('F0:F1:F2:F3:F4:F5')
 AURACAST_DEFAULT_SYNC_TIMEOUT = 5.0
 AURACAST_DEFAULT_ATT_MTU = 256
+AURACAST_DEFAULT_FRAME_DURATION = 10000
+AURACAST_DEFAULT_SAMPLE_RATE = 48000
+AURACAST_DEFAULT_TRANSMIT_BITRATE = 80000
+
+
+# -----------------------------------------------------------------------------
+# Utils
+# -----------------------------------------------------------------------------
+def codec_config_string(
+    codec_config: bap.CodecSpecificConfiguration, indent: str
+) -> str:
+    lines = []
+    if codec_config.sampling_frequency is not None:
+        lines.append(f'Sampling Frequency: {codec_config.sampling_frequency.hz} hz')
+    if codec_config.frame_duration is not None:
+        lines.append(f'Frame Duration:     {codec_config.frame_duration.us} µs')
+    if codec_config.octets_per_codec_frame is not None:
+        lines.append(f'Frame Size:         {codec_config.octets_per_codec_frame} bytes')
+    if codec_config.codec_frames_per_sdu is not None:
+        lines.append(f'Frames Per SDU:     {codec_config.codec_frames_per_sdu}')
+    if codec_config.audio_channel_allocation is not None:
+        lines.append(
+            f'Audio Location:     {codec_config.audio_channel_allocation.name}'
+        )
+    return '\n'.join(indent + line for line in lines)
 
 
 # -----------------------------------------------------------------------------
@@ -156,18 +192,17 @@ class BroadcastScanner(pyee.EventEmitter):
             if self.public_broadcast_announcement:
                 print(
                     f'  {color("Features", "cyan")}:     '
-                    f'{self.public_broadcast_announcement.features}'
-                )
-                print(
-                    f'  {color("Metadata", "cyan")}:     '
-                    f'{self.public_broadcast_announcement.metadata}'
+                    f'{self.public_broadcast_announcement.features.name}'
                 )
+                print(f'  {color("Metadata", "cyan")}:')
+                print(self.public_broadcast_announcement.metadata.pretty_print('    '))
 
             if self.basic_audio_announcement:
                 print(color('  Audio:', 'cyan'))
                 print(
                     color('    Presentation Delay:', 'magenta'),
                     self.basic_audio_announcement.presentation_delay,
+                    "µs",
                 )
                 for subgroup in self.basic_audio_announcement.subgroups:
                     print(color('    Subgroup:', 'magenta'))
@@ -184,17 +219,22 @@ class BroadcastScanner(pyee.EventEmitter):
                         color('        Vendor Specific Codec ID:', 'green'),
                         subgroup.codec_id.vendor_specific_codec_id,
                     )
+                    print(color('      Codec Config:', 'yellow'))
                     print(
-                        color('      Codec Config:', 'yellow'),
-                        subgroup.codec_specific_configuration,
+                        codec_config_string(
+                            subgroup.codec_specific_configuration, '        '
+                        ),
                     )
-                    print(color('      Metadata:    ', 'yellow'), subgroup.metadata)
+                    print(color('      Metadata:    ', 'yellow'))
+                    print(subgroup.metadata.pretty_print('        '))
 
                     for bis in subgroup.bis:
                         print(color(f'      BIS [{bis.index}]:', 'yellow'))
+                        print(color('       Codec Config:', 'green'))
                         print(
-                            color('       Codec Config:', 'green'),
-                            bis.codec_specific_configuration,
+                            codec_config_string(
+                                bis.codec_specific_configuration, '         '
+                            ),
                         )
 
             if self.biginfo:
@@ -494,7 +534,7 @@ async def run_assist(
             except core.ProtocolError as error:
                 print(
                     color(
-                        f'!!! Failed to subscribe to Broadcast Receive State characteristic:',
+                        '!!! Failed to subscribe to Broadcast Receive State characteristic',
                         'red',
                     ),
                     error,
@@ -625,11 +665,20 @@ async def run_pair(transport: str, address: str) -> None:
 
 async def run_receive(
     transport: str,
-    broadcast_id: int,
+    broadcast_id: Optional[int],
+    output: str,
     broadcast_code: str | None,
     sync_timeout: float,
     subgroup_index: int,
 ) -> None:
+    # Run a pre-flight check for the output.
+    try:
+        if not audio_io.check_audio_output(output):
+            return
+    except ValueError as error:
+        print(error)
+        return
+
     async with create_device(transport) as device:
         if not device.supports_le_periodic_advertising:
             print(color('Periodic advertising not supported', 'red'))
@@ -643,7 +692,7 @@ async def run_receive(
         def on_new_broadcast(broadcast: BroadcastScanner.Broadcast) -> None:
             if scan_result.done():
                 return
-            if broadcast.broadcast_id == broadcast_id:
+            if broadcast_id is None or broadcast.broadcast_id == broadcast_id:
                 scan_result.set_result(broadcast)
 
         scanner.on('new_broadcast', on_new_broadcast)
@@ -694,57 +743,95 @@ async def run_receive(
             sample_rate_hz=sampling_frequency.hz,
             num_channels=num_bis,
         )
-        sdus = [b''] * num_bis
-        subprocess = await asyncio.create_subprocess_shell(
-            f'stdbuf -i0 ffplay -ar {sampling_frequency.hz} -ac {num_bis} -f f32le pipe:0',
-            stdin=asyncio.subprocess.PIPE,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        for i, bis_link in enumerate(big_sync.bis_links):
-            print(f'Setup ISO for BIS {bis_link.handle}')
+        lc3_queues: list[Deque[bytes]] = [collections.deque() for i in range(num_bis)]
+        packet_stats = [0, 0]
 
-            def sink(index: int, packet: hci.HCI_IsoDataPacket):
-                nonlocal sdus
-                sdus[index] = packet.iso_sdu_fragment
-                if all(sdus) and subprocess.stdin:
-                    subprocess.stdin.write(decoder.decode(b''.join(sdus)).tobytes())
-                    sdus = [b''] * num_bis
-
-            bis_link.sink = functools.partial(sink, i)
-            await bis_link.setup_data_path(
-                direction=bis_link.Direction.CONTROLLER_TO_HOST
+        audio_output = await audio_io.create_audio_output(output)
+        # This try should be replaced with contextlib.aclosing() when python 3.9 is no
+        # longer needed.
+        try:
+            await audio_output.open(
+                audio_io.PcmFormat(
+                    audio_io.PcmFormat.Endianness.LITTLE,
+                    audio_io.PcmFormat.SampleType.FLOAT32,
+                    sampling_frequency.hz,
+                    num_bis,
+                )
             )
 
-        terminated = asyncio.Event()
-        big_sync.on(big_sync.Event.TERMINATION, lambda _: terminated.set())
-        await terminated.wait()
+            def sink(queue: Deque[bytes], packet: hci.HCI_IsoDataPacket):
+                # TODO: re-assemble fragments and detect errors
+                queue.append(packet.iso_sdu_fragment)
+
+                while all(lc3_queues):
+                    # This assumes SDUs contain one LC3 frame each, which may not
+                    # be correct for all cases. TODO: revisit this assumption.
+                    frame = b''.join([lc3_queue.popleft() for lc3_queue in lc3_queues])
+                    if not frame:
+                        print(color('!!! received empty frame', 'red'))
+                        continue
+
+                    packet_stats[0] += len(frame)
+                    packet_stats[1] += 1
+                    print(
+                        f'\rRECEIVED: {packet_stats[0]} bytes in '
+                        f'{packet_stats[1]} packets',
+                        end='',
+                    )
+
+                    try:
+                        pcm = decoder.decode(frame).tobytes()
+                    except lc3.BaseError as error:
+                        print(color(f'!!! LC3 decoding error: {error}'))
+                        continue
+
+                    audio_output.write(pcm)
+
+            for i, bis_link in enumerate(big_sync.bis_links):
+                print(f'Setup ISO for BIS {bis_link.handle}')
+                bis_link.sink = functools.partial(sink, lc3_queues[i])
+                await device.send_command(
+                    hci.HCI_LE_Setup_ISO_Data_Path_Command(
+                        connection_handle=bis_link.handle,
+                        data_path_direction=hci.HCI_LE_Setup_ISO_Data_Path_Command.Direction.CONTROLLER_TO_HOST,
+                        data_path_id=0,
+                        codec_id=hci.CodingFormat(codec_id=hci.CodecID.TRANSPARENT),
+                        controller_delay=0,
+                        codec_configuration=b'',
+                    ),
+                    check_result=True,
+                )
+
+            terminated = asyncio.Event()
+            big_sync.on(big_sync.Event.TERMINATION, lambda _: terminated.set())
+            await terminated.wait()
+        finally:
+            await audio_output.aclose()
 
 
-async def run_broadcast(
-    transport: str, broadcast_id: int, broadcast_code: str | None, wav_file_path: str
+async def run_transmit(
+    transport: str,
+    broadcast_id: int,
+    broadcast_code: str | None,
+    broadcast_name: str,
+    bitrate: int,
+    manufacturer_data: tuple[int, bytes] | None,
+    input: str,
+    input_format: str,
 ) -> None:
+    # Run a pre-flight check for the input.
+    try:
+        if not audio_io.check_audio_input(input):
+            return
+    except ValueError as error:
+        print(error)
+        return
+
     async with create_device(transport) as device:
         if not device.supports_le_periodic_advertising:
             print(color('Periodic advertising not supported', 'red'))
             return
 
-        with wave.open(wav_file_path, 'rb') as wav:
-            print('Encoding wav file into lc3...')
-            encoder = lc3.Encoder(
-                frame_duration_us=10000,
-                sample_rate_hz=48000,
-                num_channels=2,
-                input_sample_rate_hz=wav.getframerate(),
-            )
-            frames = list[bytes]()
-            while pcm := wav.readframes(encoder.get_frame_samples()):
-                frames.append(
-                    encoder.encode(pcm, num_bytes=200, bit_depth=wav.getsampwidth() * 8)
-                )
-            del encoder
-            print('Encoding complete.')
-
         basic_audio_announcement = bap.BasicAudioAnnouncement(
             presentation_delay=40000,
             subgroups=[
@@ -783,7 +870,23 @@ async def run_broadcast(
             ],
         )
         broadcast_audio_announcement = bap.BroadcastAudioAnnouncement(broadcast_id)
-        print('Start Advertising')
+
+        advertising_manufacturer_data = (
+            b''
+            if manufacturer_data is None
+            else bytes(
+                core.AdvertisingData(
+                    [
+                        (
+                            core.AdvertisingData.MANUFACTURER_SPECIFIC_DATA,
+                            struct.pack('<H', manufacturer_data[0])
+                            + manufacturer_data[1],
+                        )
+                    ]
+                )
+            )
+        )
+
         advertising_set = await device.create_advertising_set(
             advertising_parameters=bumble.device.AdvertisingParameters(
                 advertising_event_properties=bumble.device.AdvertisingEventProperties(
@@ -796,9 +899,10 @@ async def run_broadcast(
                 broadcast_audio_announcement.get_advertising_data()
                 + bytes(
                     core.AdvertisingData(
-                        [(core.AdvertisingData.BROADCAST_NAME, b'Bumble Auracast')]
+                        [(core.AdvertisingData.BROADCAST_NAME, broadcast_name.encode())]
                     )
                 )
+                + advertising_manufacturer_data
             ),
             periodic_advertising_parameters=bumble.device.PeriodicAdvertisingParameters(
                 periodic_advertising_interval_min=80,
@@ -808,47 +912,83 @@ async def run_broadcast(
             auto_restart=True,
             auto_start=True,
         )
+
         print('Start Periodic Advertising')
         await advertising_set.start_periodic()
-        print('Setup BIG')
-        big = await device.create_big(
-            advertising_set,
-            parameters=bumble.device.BigParameters(
-                num_bis=2,
-                sdu_interval=10000,
-                max_sdu=100,
-                max_transport_latency=65,
-                rtn=4,
-                broadcast_code=(
-                    bytes.fromhex(broadcast_code) if broadcast_code else None
-                ),
-            ),
-        )
-        print('Setup ISO Data Path')
 
-        def on_flow(packet_queue):
+        audio_input = await audio_io.create_audio_input(input, input_format)
+        pcm_format = await audio_input.open()
+        # This try should be replaced with contextlib.aclosing() when python 3.9 is no
+        # longer needed.
+        try:
+            if pcm_format.channels != 2:
+                print("Only 2 channels PCM configurations are supported")
+                return
+            if pcm_format.sample_type == audio_io.PcmFormat.SampleType.INT16:
+                pcm_bit_depth = 16
+            elif pcm_format.sample_type == audio_io.PcmFormat.SampleType.FLOAT32:
+                pcm_bit_depth = None
+            else:
+                print("Only INT16 and FLOAT32 sample types are supported")
+                return
+
+            encoder = lc3.Encoder(
+                frame_duration_us=AURACAST_DEFAULT_FRAME_DURATION,
+                sample_rate_hz=AURACAST_DEFAULT_SAMPLE_RATE,
+                num_channels=pcm_format.channels,
+                input_sample_rate_hz=pcm_format.sample_rate,
+            )
+            lc3_frame_samples = encoder.get_frame_samples()
+            lc3_frame_size = encoder.get_frame_bytes(bitrate)
             print(
-                f'\rPACKETS: pending={packet_queue.pending}, '
-                f'queued={packet_queue.queued}, completed={packet_queue.completed}',
-                end='',
+                f'Encoding with {lc3_frame_samples} '
+                f'PCM samples per {lc3_frame_size} byte frame'
             )
 
-        packet_queue = None
-        for bis_link in big.bis_links:
-            await bis_link.setup_data_path(
-                direction=bis_link.Direction.HOST_TO_CONTROLLER
+            print('Setup BIG')
+            big = await device.create_big(
+                advertising_set,
+                parameters=bumble.device.BigParameters(
+                    num_bis=pcm_format.channels,
+                    sdu_interval=AURACAST_DEFAULT_FRAME_DURATION,
+                    max_sdu=lc3_frame_size,
+                    max_transport_latency=65,
+                    rtn=4,
+                    broadcast_code=(
+                        bytes.fromhex(broadcast_code) if broadcast_code else None
+                    ),
+                ),
             )
-            if packet_queue is None:
-                packet_queue = bis_link.data_packet_queue
 
-        if packet_queue:
-            packet_queue.on('flow', lambda: on_flow(packet_queue))
+            iso_queues = [
+                bumble.device.IsoPacketStream(big.bis_links[0], 64),
+                bumble.device.IsoPacketStream(big.bis_links[1], 64),
+            ]
 
-        for frame in itertools.cycle(frames):
-            mid = len(frame) // 2
-            big.bis_links[0].write(frame[:mid])
-            big.bis_links[1].write(frame[mid:])
-            await asyncio.sleep(0.009)
+            def on_flow():
+                data_packet_queue = iso_queues[0].data_packet_queue
+                print(
+                    f'\rPACKETS: pending={data_packet_queue.pending}, '
+                    f'queued={data_packet_queue.queued}, '
+                    f'completed={data_packet_queue.completed}',
+                    end='',
+                )
+
+            iso_queues[0].data_packet_queue.on('flow', on_flow)
+
+            frame_count = 0
+            async for pcm_frame in audio_input.frames(lc3_frame_samples):
+                lc3_frame = encoder.encode(
+                    pcm_frame, num_bytes=2 * lc3_frame_size, bit_depth=pcm_bit_depth
+                )
+
+                mid = len(lc3_frame) // 2
+                await iso_queues[0].write(lc3_frame[:mid])
+                await iso_queues[1].write(lc3_frame[mid:])
+
+                frame_count += 1
+        finally:
+            await audio_input.aclose()
 
 
 def run_async(async_command: Coroutine) -> None:
@@ -917,7 +1057,7 @@ def scan(ctx, filter_duplicates, sync_timeout, transport):
 @click.argument('address')
 @click.pass_context
 def assist(ctx, broadcast_name, source_id, command, transport, address):
-    """Scan for broadcasts on behalf of a audio server"""
+    """Scan for broadcasts on behalf of an audio server"""
     run_async(run_assist(broadcast_name, source_id, command, transport, address))
 
 
@@ -932,7 +1072,24 @@ def pair(ctx, transport, address):
 
 @auracast.command('receive')
 @click.argument('transport')
-@click.argument('broadcast_id', type=int)
+@click.argument(
+    'broadcast_id',
+    type=int,
+    required=False,
+)
+@click.option(
+    '--output',
+    default='device',
+    help=(
+        "Audio output. "
+        "'device' -> use the host's default sound output device, "
+        "'device:<DEVICE_ID>' -> use one of the  host's sound output device "
+        "(specify 'device:?' to get a list of available sound output devices), "
+        "'stdout' -> send audio to stdout, "
+        "'file:<filename> -> write audio to a raw float32 PCM file, "
+        "'ffplay' -> pipe the audio to ffplay"
+    ),
+)
 @click.option(
     '--broadcast-code',
     metavar='BROADCAST_CODE',
@@ -954,16 +1111,57 @@ def pair(ctx, transport, address):
     help='Index of Subgroup',
 )
 @click.pass_context
-def receive(ctx, transport, broadcast_id, broadcast_code, sync_timeout, subgroup):
+def receive(
+    ctx,
+    transport,
+    broadcast_id,
+    output,
+    broadcast_code,
+    sync_timeout,
+    subgroup,
+):
     """Receive a broadcast source"""
     run_async(
-        run_receive(transport, broadcast_id, broadcast_code, sync_timeout, subgroup)
+        run_receive(
+            transport,
+            broadcast_id,
+            output,
+            broadcast_code,
+            sync_timeout,
+            subgroup,
+        )
     )
 
 
-@auracast.command('broadcast')
+@auracast.command('transmit')
 @click.argument('transport')
-@click.argument('wav_file_path', type=str)
+@click.option(
+    '--input',
+    required=True,
+    help=(
+        "Audio input. "
+        "'device' -> use the host's default sound input device, "
+        "'device:<DEVICE_ID>' -> use one of the host's sound input devices "
+        "(specify 'device:?' to get a list of available sound input devices), "
+        "'stdin' -> receive audio from stdin as int16 PCM, "
+        "'file:<filename> -> read audio from a .wav or raw int16 PCM file. "
+        "(The file: prefix may be omitted if the file path does not start with "
+        "the substring 'device:' or 'file:' and is not 'stdin')"
+    ),
+)
+@click.option(
+    '--input-format',
+    metavar="FORMAT",
+    default='auto',
+    help=(
+        "Audio input format. "
+        "Use 'auto' for .wav files, or for the default setting with the devices. "
+        "For other inputs, the format is specified as "
+        "<sample-type>,<sample-rate>,<channels> (supported <sample-type>: 'int16le' "
+        "for 16-bit signed integers with little-endian byte order or 'float32le' for "
+        "32-bit floating point with little-endian byte order)"
+    ),
+)
 @click.option(
     '--broadcast-id',
     metavar='BROADCAST_ID',
@@ -974,18 +1172,60 @@ def receive(ctx, transport, broadcast_id, broadcast_code, sync_timeout, subgroup
 @click.option(
     '--broadcast-code',
     metavar='BROADCAST_CODE',
-    type=str,
     help='Broadcast encryption code in hex format',
 )
+@click.option(
+    '--broadcast-name',
+    metavar='BROADCAST_NAME',
+    default='Bumble Auracast',
+    help='Broadcast name',
+)
+@click.option(
+    '--bitrate',
+    type=int,
+    default=AURACAST_DEFAULT_TRANSMIT_BITRATE,
+    help='Bitrate, per channel, in bps',
+)
+@click.option(
+    '--manufacturer-data',
+    metavar='VENDOR-ID:DATA-HEX',
+    help='Manufacturer data (specify as <vendor-id>:<data-hex>)',
+)
 @click.pass_context
-def broadcast(ctx, transport, broadcast_id, broadcast_code, wav_file_path):
-    """Start a broadcast as a source."""
+def transmit(
+    ctx,
+    transport,
+    broadcast_id,
+    broadcast_code,
+    manufacturer_data,
+    broadcast_name,
+    bitrate,
+    input,
+    input_format,
+):
+    """Transmit a broadcast source"""
+    if manufacturer_data:
+        vendor_id_str, data_hex = manufacturer_data.split(':')
+        vendor_id = int(vendor_id_str)
+        data = bytes.fromhex(data_hex)
+        manufacturer_data_tuple = (vendor_id, data)
+    else:
+        manufacturer_data_tuple = None
+
+    if (input == 'device' or input.startswith('device:')) and input_format == 'auto':
+        # Use a default format for device inputs
+        input_format = 'int16le,48000,1'
+
     run_async(
-        run_broadcast(
+        run_transmit(
             transport=transport,
             broadcast_id=broadcast_id,
             broadcast_code=broadcast_code,
-            wav_file_path=wav_file_path,
+            broadcast_name=broadcast_name,
+            bitrate=bitrate,
+            manufacturer_data=manufacturer_data_tuple,
+            input=input,
+            input_format=input_format,
         )
     )
 

apps/device_info.py

@@ -29,7 +29,9 @@ from bumble.gatt import Service
 from bumble.profiles.device_information_service import DeviceInformationServiceProxy
 from bumble.profiles.battery_service import BatteryServiceProxy
 from bumble.profiles.gap import GenericAccessServiceProxy
+from bumble.profiles.pacs import PublishedAudioCapabilitiesServiceProxy
 from bumble.profiles.tmap import TelephonyAndMediaAudioServiceProxy
+from bumble.profiles.vcs import VolumeControlServiceProxy
 from bumble.transport import open_transport_or_link
 
 
@@ -126,14 +128,52 @@ async def show_tmas(
     print(color('### Telephony And Media Audio Service', 'yellow'))
 
     if tmas.role:
-        print(
-            color('  Role:', 'green'),
-            await tmas.role.read_value(),
-        )
+        role = await tmas.role.read_value()
+        print(color('  Role:', 'green'), role)
 
     print()
 
 
+# -----------------------------------------------------------------------------
+async def show_pacs(pacs: PublishedAudioCapabilitiesServiceProxy) -> None:
+    print(color('### Published Audio Capabilities Service', 'yellow'))
+
+    contexts = await pacs.available_audio_contexts.read_value()
+    print(color('  Available Audio Contexts:', 'green'), contexts)
+
+    contexts = await pacs.supported_audio_contexts.read_value()
+    print(color('  Supported Audio Contexts:', 'green'), contexts)
+
+    if pacs.sink_pac:
+        pac = await pacs.sink_pac.read_value()
+        print(color('  Sink PAC:                ', 'green'), pac)
+
+    if pacs.sink_audio_locations:
+        audio_locations = await pacs.sink_audio_locations.read_value()
+        print(color('  Sink Audio Locations:    ', 'green'), audio_locations)
+
+    if pacs.source_pac:
+        pac = await pacs.source_pac.read_value()
+        print(color('  Source PAC:              ', 'green'), pac)
+
+    if pacs.source_audio_locations:
+        audio_locations = await pacs.source_audio_locations.read_value()
+        print(color('  Source Audio Locations:  ', 'green'), audio_locations)
+
+    print()
+
+
+# -----------------------------------------------------------------------------
+async def show_vcs(vcs: VolumeControlServiceProxy) -> None:
+    print(color('### Volume Control Service', 'yellow'))
+
+    volume_state = await vcs.volume_state.read_value()
+    print(color('  Volume State:', 'green'), volume_state)
+
+    volume_flags = await vcs.volume_flags.read_value()
+    print(color('  Volume Flags:', 'green'), volume_flags)
+
+
 # -----------------------------------------------------------------------------
 async def show_device_info(peer, done: Optional[asyncio.Future]) -> None:
     try:
@@ -161,6 +201,12 @@ async def show_device_info(peer, done: Optional[asyncio.Future]) -> None:
         if tmas := peer.create_service_proxy(TelephonyAndMediaAudioServiceProxy):
             await try_show(show_tmas, tmas)
 
+        if pacs := peer.create_service_proxy(PublishedAudioCapabilitiesServiceProxy):
+            await try_show(show_pacs, pacs)
+
+        if vcs := peer.create_service_proxy(VolumeControlServiceProxy):
+            await try_show(show_vcs, vcs)
+
         if done is not None:
             done.set_result(None)
     except asyncio.CancelledError:

bumble/audio/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------

bumble/audio/io.py

@@ -0,0 +1,553 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+from __future__ import annotations
+
+import asyncio
+import abc
+from concurrent.futures import ThreadPoolExecutor
+import dataclasses
+import enum
+import logging
+import pathlib
+from typing import (
+    AsyncGenerator,
+    BinaryIO,
+    TYPE_CHECKING,
+)
+import sys
+import wave
+
+from bumble.colors import color
+
+if TYPE_CHECKING:
+    import sounddevice  # type: ignore[import-untyped]
+
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Classes
+# -----------------------------------------------------------------------------
+@dataclasses.dataclass
+class PcmFormat:
+    class Endianness(enum.Enum):
+        LITTLE = 0
+        BIG = 1
+
+    class SampleType(enum.Enum):
+        FLOAT32 = 0
+        INT16 = 1
+
+    endianness: Endianness
+    sample_type: SampleType
+    sample_rate: int
+    channels: int
+
+    @classmethod
+    def from_str(cls, format_str: str) -> PcmFormat:
+        endianness = cls.Endianness.LITTLE  # Others not yet supported.
+        sample_type_str, sample_rate_str, channels_str = format_str.split(',')
+        if sample_type_str == 'int16le':
+            sample_type = cls.SampleType.INT16
+        elif sample_type_str == 'float32le':
+            sample_type = cls.SampleType.FLOAT32
+        else:
+            raise ValueError(f'sample type {sample_type_str} not supported')
+        sample_rate = int(sample_rate_str)
+        channels = int(channels_str)
+
+        return cls(endianness, sample_type, sample_rate, channels)
+
+    @property
+    def bytes_per_sample(self) -> int:
+        return 2 if self.sample_type == self.SampleType.INT16 else 4
+
+
+def check_audio_output(output: str) -> bool:
+    if output == 'device' or output.startswith('device:'):
+        try:
+            import sounddevice
+        except ImportError as exc:
+            raise ValueError(
+                'audio output not available (sounddevice python module not installed)'
+            ) from exc
+        except OSError as exc:
+            raise ValueError(
+                'audio output not available '
+                '(sounddevice python module failed to load: '
+                f'{exc})'
+            ) from exc
+
+        if output == 'device':
+            # Default device
+            return True
+
+        # Specific device
+        device = output[7:]
+        if device == '?':
+            print(color('Audio Devices:', 'yellow'))
+            for device_info in [
+                device_info
+                for device_info in sounddevice.query_devices()
+                if device_info['max_output_channels'] > 0
+            ]:
+                device_index = device_info['index']
+                is_default = (
+                    color(' [default]', 'green')
+                    if sounddevice.default.device[1] == device_index
+                    else ''
+                )
+                print(
+                    f'{color(device_index, "cyan")}: {device_info["name"]}{is_default}'
+                )
+            return False
+
+        try:
+            device_info = sounddevice.query_devices(int(device))
+        except sounddevice.PortAudioError as exc:
+            raise ValueError('No such audio device') from exc
+
+        if device_info['max_output_channels'] < 1:
+            raise ValueError(
+                f'Device {device} ({device_info["name"]}) does not have an output'
+            )
+
+    return True
+
+
+async def create_audio_output(output: str) -> AudioOutput:
+    if output == 'stdout':
+        return StreamAudioOutput(sys.stdout.buffer)
+
+    if output == 'device' or output.startswith('device:'):
+        device_name = '' if output == 'device' else output[7:]
+        return SoundDeviceAudioOutput(device_name)
+
+    if output == 'ffplay':
+        return SubprocessAudioOutput(
+            command=(
+                'ffplay -probesize 32 -fflags nobuffer -analyzeduration 0 '
+                '-ar {sample_rate} '
+                '-ch_layout {channel_layout} '
+                '-f f32le pipe:0'
+            )
+        )
+
+    if output.startswith('file:'):
+        return FileAudioOutput(output[5:])
+
+    raise ValueError('unsupported audio output')
+
+
+class AudioOutput(abc.ABC):
+    """Audio output to which PCM samples can be written."""
+
+    async def open(self, pcm_format: PcmFormat) -> None:
+        """Start the output."""
+
+    @abc.abstractmethod
+    def write(self, pcm_samples: bytes) -> None:
+        """Write PCM samples. Must not block."""
+
+    async def aclose(self) -> None:
+        """Close the output."""
+
+
+class ThreadedAudioOutput(AudioOutput):
+    """Base class for AudioOutput classes that may need to call blocking functions.
+
+    The actual writing is performed in a thread, so as to ensure that calling write()
+    does not block the caller.
+    """
+
+    def __init__(self) -> None:
+        self._thread_pool = ThreadPoolExecutor(1)
+        self._pcm_samples: asyncio.Queue[bytes] = asyncio.Queue()
+        self._write_task = asyncio.create_task(self._write_loop())
+
+    async def _write_loop(self) -> None:
+        while True:
+            pcm_samples = await self._pcm_samples.get()
+            await asyncio.get_running_loop().run_in_executor(
+                self._thread_pool, self._write, pcm_samples
+            )
+
+    @abc.abstractmethod
+    def _write(self, pcm_samples: bytes) -> None:
+        """This method does the actual writing and can block."""
+
+    def write(self, pcm_samples: bytes) -> None:
+        self._pcm_samples.put_nowait(pcm_samples)
+
+    def _close(self) -> None:
+        """This method does the actual closing and can block."""
+
+    async def aclose(self) -> None:
+        await asyncio.get_running_loop().run_in_executor(self._thread_pool, self._close)
+        self._write_task.cancel()
+        self._thread_pool.shutdown()
+
+
+class SoundDeviceAudioOutput(ThreadedAudioOutput):
+    def __init__(self, device_name: str) -> None:
+        super().__init__()
+        self._device = int(device_name) if device_name else None
+        self._stream: sounddevice.RawOutputStream | None = None
+
+    async def open(self, pcm_format: PcmFormat) -> None:
+        import sounddevice  # pylint: disable=import-error
+
+        self._stream = sounddevice.RawOutputStream(
+            samplerate=pcm_format.sample_rate,
+            device=self._device,
+            channels=pcm_format.channels,
+            dtype='float32',
+        )
+        self._stream.start()
+
+    def _write(self, pcm_samples: bytes) -> None:
+        if self._stream is None:
+            return
+
+        try:
+            self._stream.write(pcm_samples)
+        except Exception as error:
+            print(f'Sound device error: {error}')
+            raise
+
+    def _close(self):
+        self._stream.stop()
+        self._stream = None
+
+
+class StreamAudioOutput(ThreadedAudioOutput):
+    """AudioOutput where PCM samples are written to a stream that may block."""
+
+    def __init__(self, stream: BinaryIO) -> None:
+        super().__init__()
+        self._stream = stream
+
+    def _write(self, pcm_samples: bytes) -> None:
+        self._stream.write(pcm_samples)
+        self._stream.flush()
+
+
+class FileAudioOutput(StreamAudioOutput):
+    """AudioOutput where PCM samples are written to a file."""
+
+    def __init__(self, filename: str) -> None:
+        self._file = open(filename, "wb")
+        super().__init__(self._file)
+
+    async def shutdown(self):
+        self._file.close()
+        return await super().shutdown()
+
+
+class SubprocessAudioOutput(AudioOutput):
+    """AudioOutput where audio samples are written to a subprocess via stdin."""
+
+    def __init__(self, command: str) -> None:
+        self._command = command
+        self._subprocess: asyncio.subprocess.Process | None
+
+    async def open(self, pcm_format: PcmFormat) -> None:
+        if pcm_format.channels == 1:
+            channel_layout = 'mono'
+        elif pcm_format.channels == 2:
+            channel_layout = 'stereo'
+        else:
+            raise ValueError(f'{pcm_format.channels} channels not supported')
+
+        command = self._command.format(
+            sample_rate=pcm_format.sample_rate, channel_layout=channel_layout
+        )
+        self._subprocess = await asyncio.create_subprocess_shell(
+            command,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+    def write(self, pcm_samples: bytes) -> None:
+        if self._subprocess is None or self._subprocess.stdin is None:
+            return
+
+        self._subprocess.stdin.write(pcm_samples)
+
+    async def aclose(self):
+        if self._subprocess:
+            self._subprocess.terminate()
+
+
+def check_audio_input(input: str) -> bool:
+    if input == 'device' or input.startswith('device:'):
+        try:
+            import sounddevice  # pylint: disable=import-error
+        except ImportError as exc:
+            raise ValueError(
+                'audio input not available (sounddevice python module not installed)'
+            ) from exc
+        except OSError as exc:
+            raise ValueError(
+                'audio input not available '
+                '(sounddevice python module failed to load: '
+                f'{exc})'
+            ) from exc
+
+        if input == 'device':
+            # Default device
+            return True
+
+        # Specific device
+        device = input[7:]
+        if device == '?':
+            print(color('Audio Devices:', 'yellow'))
+            for device_info in [
+                device_info
+                for device_info in sounddevice.query_devices()
+                if device_info['max_input_channels'] > 0
+            ]:
+                device_index = device_info["index"]
+                is_mono = device_info['max_input_channels'] == 1
+                max_channels = color(f'[{"mono" if is_mono else "stereo"}]', 'cyan')
+                is_default = (
+                    color(' [default]', 'green')
+                    if sounddevice.default.device[0] == device_index
+                    else ''
+                )
+                print(
+                    f'{color(device_index, "cyan")}: {device_info["name"]}'
+                    f' {max_channels}{is_default}'
+                )
+            return False
+
+        try:
+            device_info = sounddevice.query_devices(int(device))
+        except sounddevice.PortAudioError as exc:
+            raise ValueError('No such audio device') from exc
+
+        if device_info['max_input_channels'] < 1:
+            raise ValueError(
+                f'Device {device} ({device_info["name"]}) does not have an input'
+            )
+
+    return True
+
+
+async def create_audio_input(input: str, input_format: str) -> AudioInput:
+    pcm_format: PcmFormat | None
+    if input_format == 'auto':
+        pcm_format = None
+    else:
+        pcm_format = PcmFormat.from_str(input_format)
+
+    if input == 'stdin':
+        if not pcm_format:
+            raise ValueError('input format details required for stdin')
+        return StreamAudioInput(sys.stdin.buffer, pcm_format)
+
+    if input == 'device' or input.startswith('device:'):
+        if not pcm_format:
+            raise ValueError('input format details required for device')
+        device_name = '' if input == 'device' else input[7:]
+        return SoundDeviceAudioInput(device_name, pcm_format)
+
+    # If there's no file: prefix, check if we can assume it is a file.
+    if pathlib.Path(input).is_file():
+        input = 'file:' + input
+
+    if input.startswith('file:'):
+        filename = input[5:]
+        if filename.endswith('.wav'):
+            if input_format != 'auto':
+                raise ValueError(".wav file only supported with 'auto' format")
+            return WaveAudioInput(filename)
+
+        if pcm_format is None:
+            raise ValueError('input format details required for raw PCM files')
+        return FileAudioInput(filename, pcm_format)
+
+    raise ValueError('input not supported')
+
+
+class AudioInput(abc.ABC):
+    """Audio input that produces PCM samples."""
+
+    @abc.abstractmethod
+    async def open(self) -> PcmFormat:
+        """Open the input."""
+
+    @abc.abstractmethod
+    def frames(self, frame_size: int) -> AsyncGenerator[bytes]:
+        """Generate one frame of PCM samples. Must not block."""
+
+    async def aclose(self) -> None:
+        """Close the input."""
+
+
+class ThreadedAudioInput(AudioInput):
+    """Base class for AudioInput implementation where reading samples may block."""
+
+    def __init__(self) -> None:
+        self._thread_pool = ThreadPoolExecutor(1)
+        self._pcm_samples: asyncio.Queue[bytes] = asyncio.Queue()
+
+    @abc.abstractmethod
+    def _read(self, frame_size: int) -> bytes:
+        pass
+
+    @abc.abstractmethod
+    def _open(self) -> PcmFormat:
+        pass
+
+    def _close(self) -> None:
+        pass
+
+    async def open(self) -> PcmFormat:
+        return await asyncio.get_running_loop().run_in_executor(
+            self._thread_pool, self._open
+        )
+
+    async def frames(self, frame_size: int) -> AsyncGenerator[bytes]:
+        while pcm_sample := await asyncio.get_running_loop().run_in_executor(
+            self._thread_pool, self._read, frame_size
+        ):
+            yield pcm_sample
+
+    async def aclose(self) -> None:
+        await asyncio.get_running_loop().run_in_executor(self._thread_pool, self._close)
+        self._thread_pool.shutdown()
+
+
+class WaveAudioInput(ThreadedAudioInput):
+    """Audio input that reads PCM samples from a .wav file."""
+
+    def __init__(self, filename: str) -> None:
+        super().__init__()
+        self._filename = filename
+        self._wav: wave.Wave_read | None = None
+        self._bytes_read = 0
+
+    def _open(self) -> PcmFormat:
+        self._wav = wave.open(self._filename, 'rb')
+        if self._wav.getsampwidth() != 2:
+            raise ValueError('sample width not supported')
+        return PcmFormat(
+            PcmFormat.Endianness.LITTLE,
+            PcmFormat.SampleType.INT16,
+            self._wav.getframerate(),
+            self._wav.getnchannels(),
+        )
+
+    def _read(self, frame_size: int) -> bytes:
+        if not self._wav:
+            return b''
+
+        pcm_samples = self._wav.readframes(frame_size)
+        if not pcm_samples and self._bytes_read:
+            # Loop around.
+            self._wav.rewind()
+            self._bytes_read = 0
+            pcm_samples = self._wav.readframes(frame_size)
+
+        self._bytes_read += len(pcm_samples)
+        return pcm_samples
+
+    def _close(self) -> None:
+        if self._wav:
+            self._wav.close()
+
+
+class StreamAudioInput(ThreadedAudioInput):
+    """AudioInput where samples are read from a raw PCM stream that may block."""
+
+    def __init__(self, stream: BinaryIO, pcm_format: PcmFormat) -> None:
+        super().__init__()
+        self._stream = stream
+        self._pcm_format = pcm_format
+
+    def _open(self) -> PcmFormat:
+        return self._pcm_format
+
+    def _read(self, frame_size: int) -> bytes:
+        return self._stream.read(
+            frame_size * self._pcm_format.channels * self._pcm_format.bytes_per_sample
+        )
+
+
+class FileAudioInput(StreamAudioInput):
+    """AudioInput where PCM samples are read from a raw PCM file."""
+
+    def __init__(self, filename: str, pcm_format: PcmFormat) -> None:
+        self._stream = open(filename, "rb")
+        super().__init__(self._stream, pcm_format)
+
+    def _close(self) -> None:
+        self._stream.close()
+
+
+class SoundDeviceAudioInput(ThreadedAudioInput):
+    def __init__(self, device_name: str, pcm_format: PcmFormat) -> None:
+        super().__init__()
+        self._device = int(device_name) if device_name else None
+        self._pcm_format = pcm_format
+        self._stream: sounddevice.RawInputStream | None = None
+
+    def _open(self) -> PcmFormat:
+        import sounddevice  # pylint: disable=import-error
+
+        self._stream = sounddevice.RawInputStream(
+            samplerate=self._pcm_format.sample_rate,
+            device=self._device,
+            channels=self._pcm_format.channels,
+            dtype='int16',
+        )
+        self._stream.start()
+
+        return PcmFormat(
+            PcmFormat.Endianness.LITTLE,
+            PcmFormat.SampleType.INT16,
+            self._pcm_format.sample_rate,
+            2,
+        )
+
+    def _read(self, frame_size: int) -> bytes:
+        if not self._stream:
+            return b''
+        pcm_buffer, overflowed = self._stream.read(frame_size)
+        if overflowed:
+            logger.warning("input overflow")
+
+        # Convert the buffer to stereo if needed
+        if self._pcm_format.channels == 1:
+            stereo_buffer = bytearray()
+            for i in range(frame_size):
+                sample = pcm_buffer[i * 2 : i * 2 + 2]
+                stereo_buffer += sample + sample
+            return stereo_buffer
+
+        return bytes(pcm_buffer)
+
+    def _close(self):
+        self._stream.stop()
+        self._stream = None

bumble/device.py

@@ -17,6 +17,7 @@
 # -----------------------------------------------------------------------------
 from __future__ import annotations
 import asyncio
+import collections
 from collections.abc import Iterable, Sequence
 from contextlib import (
     asynccontextmanager,
@@ -36,6 +37,7 @@ from typing import (
     Any,
     Callable,
     ClassVar,
+    Deque,
     Dict,
     Optional,
     Type,
@@ -93,7 +95,6 @@ from bumble import smp
 from bumble import sdp
 from bumble import l2cap
 from bumble import core
-from bumble.profiles import gatt_service
 
 if TYPE_CHECKING:
     from .transport.common import TransportSource, TransportSink
@@ -120,8 +121,6 @@ DEVICE_MIN_EXTENDED_ADVERTISING_SET_HANDLE    = 0x00
 DEVICE_MAX_EXTENDED_ADVERTISING_SET_HANDLE    = 0xEF
 DEVICE_MIN_BIG_HANDLE                         = 0x00
 DEVICE_MAX_BIG_HANDLE                         = 0xEF
-DEVICE_MIN_CS_CONFIG_ID                       = 0x00
-DEVICE_MAX_CS_CONFIG_ID                       = 0x03
 
 DEVICE_DEFAULT_ADDRESS                        = '00:00:00:00:00:00'
 DEVICE_DEFAULT_ADVERTISING_INTERVAL           = 1000  # ms
@@ -257,7 +256,7 @@ class ExtendedAdvertisement(Advertisement):
             secondary_phy    = report.secondary_phy,
             tx_power         = report.tx_power,
             sid              = report.advertising_sid,
-            data_bytes       = report.data,
+            data_bytes       = report.data
         )
         # fmt: on
 
@@ -383,12 +382,8 @@ class LegacyAdvertiser:
         # Set the advertising parameters
         await self.device.send_command(
             hci.HCI_LE_Set_Advertising_Parameters_Command(
-                advertising_interval_min=int(
-                    self.device.advertising_interval_min / 0.625
-                ),
-                advertising_interval_max=int(
-                    self.device.advertising_interval_max / 0.625
-                ),
+                advertising_interval_min=self.device.advertising_interval_min,
+                advertising_interval_max=self.device.advertising_interval_max,
                 advertising_type=int(self.advertising_type),
                 own_address_type=self.own_address_type,
                 peer_address_type=self.peer_address.address_type,
@@ -912,11 +907,11 @@ class PeriodicAdvertisingSync(EventEmitter):
 
     def on_establishment(
         self,
-        status: int,
-        sync_handle: int,
-        advertiser_phy: int,
-        periodic_advertising_interval: int,
-        advertiser_clock_accuracy: int,
+        status,
+        sync_handle,
+        advertiser_phy,
+        periodic_advertising_interval,
+        advertiser_clock_accuracy,
     ) -> None:
         self.status = status
 
@@ -1123,72 +1118,6 @@ class BigSync(EventEmitter):
             await terminated.wait()
 
 
-# -----------------------------------------------------------------------------
-@dataclass
-class ChannelSoundingCapabilities:
-    num_config_supported: int
-    max_consecutive_procedures_supported: int
-    num_antennas_supported: int
-    max_antenna_paths_supported: int
-    roles_supported: int
-    modes_supported: int
-    rtt_capability: int
-    rtt_aa_only_n: int
-    rtt_sounding_n: int
-    rtt_random_payload_n: int
-    nadm_sounding_capability: int
-    nadm_random_capability: int
-    cs_sync_phys_supported: int
-    subfeatures_supported: int
-    t_ip1_times_supported: int
-    t_ip2_times_supported: int
-    t_fcs_times_supported: int
-    t_pm_times_supported: int
-    t_sw_time_supported: int
-    tx_snr_capability: int
-
-
-# -----------------------------------------------------------------------------
-@dataclass
-class ChannelSoundingConfig:
-    config_id: int
-    main_mode_type: int
-    sub_mode_type: int
-    min_main_mode_steps: int
-    max_main_mode_steps: int
-    main_mode_repetition: int
-    mode_0_steps: int
-    role: int
-    rtt_type: int
-    cs_sync_phy: int
-    channel_map: bytes
-    channel_map_repetition: int
-    channel_selection_type: int
-    ch3c_shape: int
-    ch3c_jump: int
-    reserved: int
-    t_ip1_time: int
-    t_ip2_time: int
-    t_fcs_time: int
-    t_pm_time: int
-
-
-# -----------------------------------------------------------------------------
-@dataclass
-class ChannelSoundingProcedure:
-    config_id: int
-    state: int
-    tone_antenna_config_selection: int
-    selected_tx_power: int
-    subevent_len: int
-    subevents_per_event: int
-    subevent_interval: int
-    event_interval: int
-    procedure_interval: int
-    procedure_count: int
-    max_procedure_len: int
-
-
 # -----------------------------------------------------------------------------
 class LePhyOptions:
     # Coded PHY preference
@@ -1369,8 +1298,8 @@ class Peer:
 @dataclass
 class ConnectionParametersPreferences:
     default: ClassVar[ConnectionParametersPreferences]
-    connection_interval_min: float = DEVICE_DEFAULT_CONNECTION_INTERVAL_MIN
-    connection_interval_max: float = DEVICE_DEFAULT_CONNECTION_INTERVAL_MAX
+    connection_interval_min: int = DEVICE_DEFAULT_CONNECTION_INTERVAL_MIN
+    connection_interval_max: int = DEVICE_DEFAULT_CONNECTION_INTERVAL_MAX
     max_latency: int = DEVICE_DEFAULT_CONNECTION_MAX_LATENCY
     supervision_timeout: int = DEVICE_DEFAULT_CONNECTION_SUPERVISION_TIMEOUT
     min_ce_length: int = DEVICE_DEFAULT_CONNECTION_MIN_CE_LENGTH
@@ -1506,6 +1435,49 @@ class BisLink(_IsoLink):
         self.device = self.big.device
 
 
+# -----------------------------------------------------------------------------
+class IsoPacketStream:
+    """Async stream that can write SDUs to a CIS or BIS, with a maximum queue size."""
+
+    iso_link: _IsoLink
+    data_packet_queue: DataPacketQueue
+
+    def __init__(self, iso_link: _IsoLink, max_queue_size: int) -> None:
+        if iso_link.data_packet_queue is None:
+            raise ValueError('link has no data packet queue')
+
+        self.iso_link = iso_link
+        self.data_packet_queue = iso_link.data_packet_queue
+        self.data_packet_queue.on('flow', self._on_flow)
+        self._thresholds: Deque[int] = collections.deque()
+        self._semaphore = asyncio.Semaphore(max_queue_size)
+
+    def _on_flow(self) -> None:
+        # Release the semaphore once for each completed packet.
+        while (
+            self._thresholds and self.data_packet_queue.completed >= self._thresholds[0]
+        ):
+            self._thresholds.popleft()
+            self._semaphore.release()
+
+    async def write(self, sdu: bytes) -> None:
+        """
+        Write an SDU to the queue.
+
+        This method blocks until there are fewer than max_queue_size packets queued
+        but not yet completed.
+        """
+
+        # Wait until there's space in the queue.
+        await self._semaphore.acquire()
+
+        # Queue the packet.
+        self.iso_link.write(sdu)
+
+        # Remember the position of the packet so we can know when it is completed.
+        self._thresholds.append(self.data_packet_queue.queued)
+
+
 # -----------------------------------------------------------------------------
 class Connection(CompositeEventEmitter):
     device: Device
@@ -1524,8 +1496,6 @@ class Connection(CompositeEventEmitter):
     gatt_client: gatt_client.Client
     pairing_peer_io_capability: Optional[int]
     pairing_peer_authentication_requirements: Optional[int]
-    cs_configs: dict[int, ChannelSoundingConfig] = {}  # Config ID to Configuration
-    cs_procedures: dict[int, ChannelSoundingProcedure] = {}  # Config ID to Procedures
 
     @composite_listener
     class Listener:
@@ -1820,11 +1790,8 @@ class DeviceConfiguration:
     address_resolution_offload: bool = False
     address_generation_offload: bool = False
     cis_enabled: bool = False
-    channel_sounding_enabled: bool = False
     identity_address_type: Optional[int] = None
     io_capability: int = pairing.PairingDelegate.IoCapability.NO_OUTPUT_NO_INPUT
-    gap_service_enabled: bool = True
-    gatt_service_enabled: bool = True
 
     def __post_init__(self) -> None:
         self.gatt_services: list[Dict[str, Any]] = []
@@ -1991,7 +1958,6 @@ class Device(CompositeEventEmitter):
     gatt_server: gatt_server.Server
     advertising_data: bytes
     scan_response_data: bytes
-    cs_capabilities: ChannelSoundingCapabilities | None = None
     connections: Dict[int, Connection]
     pending_connections: Dict[hci.Address, Connection]
     classic_pending_accepts: Dict[
@@ -2008,7 +1974,6 @@ class Device(CompositeEventEmitter):
     bis_links = dict[int, BisLink]()
     big_syncs = dict[int, BigSync]()
     _pending_cis: Dict[int, tuple[int, int]]
-    gatt_service: gatt_service.GenericAttributeProfileService | None = None
 
     @composite_listener
     class Listener:
@@ -2075,6 +2040,7 @@ class Device(CompositeEventEmitter):
         address: Optional[hci.Address] = None,
         config: Optional[DeviceConfiguration] = None,
         host: Optional[Host] = None,
+        generic_access_service: bool = True,
     ) -> None:
         super().__init__()
 
@@ -2221,10 +2187,7 @@ class Device(CompositeEventEmitter):
         # Register the SDP server with the L2CAP Channel Manager
         self.sdp_server.register(self.l2cap_channel_manager)
 
-        self.add_default_services(
-            add_gap_service=config.gap_service_enabled,
-            add_gatt_service=config.gatt_service_enabled,
-        )
+        self.add_default_services(generic_access_service)
         self.l2cap_channel_manager.register_fixed_channel(ATT_CID, self.on_gatt_pdu)
 
         # Forward some events
@@ -2508,41 +2471,6 @@ class Device(CompositeEventEmitter):
                     check_result=True,
                 )
 
-            if self.config.channel_sounding_enabled:
-                await self.send_command(
-                    hci.HCI_LE_Set_Host_Feature_Command(
-                        bit_number=hci.LeFeature.CHANNEL_SOUNDING_HOST_SUPPORT,
-                        bit_value=1,
-                    ),
-                    check_result=True,
-                )
-                result = await self.send_command(
-                    hci.HCI_LE_CS_Read_Local_Supported_Capabilities_Command(),
-                    check_result=True,
-                )
-                self.cs_capabilities = ChannelSoundingCapabilities(
-                    num_config_supported=result.return_parameters.num_config_supported,
-                    max_consecutive_procedures_supported=result.return_parameters.max_consecutive_procedures_supported,
-                    num_antennas_supported=result.return_parameters.num_antennas_supported,
-                    max_antenna_paths_supported=result.return_parameters.max_antenna_paths_supported,
-                    roles_supported=result.return_parameters.roles_supported,
-                    modes_supported=result.return_parameters.modes_supported,
-                    rtt_capability=result.return_parameters.rtt_capability,
-                    rtt_aa_only_n=result.return_parameters.rtt_aa_only_n,
-                    rtt_sounding_n=result.return_parameters.rtt_sounding_n,
-                    rtt_random_payload_n=result.return_parameters.rtt_random_payload_n,
-                    nadm_sounding_capability=result.return_parameters.nadm_sounding_capability,
-                    nadm_random_capability=result.return_parameters.nadm_random_capability,
-                    cs_sync_phys_supported=result.return_parameters.cs_sync_phys_supported,
-                    subfeatures_supported=result.return_parameters.subfeatures_supported,
-                    t_ip1_times_supported=result.return_parameters.t_ip1_times_supported,
-                    t_ip2_times_supported=result.return_parameters.t_ip2_times_supported,
-                    t_fcs_times_supported=result.return_parameters.t_fcs_times_supported,
-                    t_pm_times_supported=result.return_parameters.t_pm_times_supported,
-                    t_sw_time_supported=result.return_parameters.t_sw_time_supported,
-                    tx_snr_capability=result.return_parameters.tx_snr_capability,
-                )
-
         if self.classic_enabled:
             await self.send_command(
                 hci.HCI_Write_Local_Name_Command(local_name=self.name.encode('utf8'))
@@ -2626,7 +2554,7 @@ class Device(CompositeEventEmitter):
         """Update the RPA periodically"""
         while self.le_rpa_timeout != 0:
             await asyncio.sleep(self.le_rpa_timeout)
-            if not await self.update_rpa():
+            if not self.update_rpa():
                 logger.debug("periodic RPA update failed")
 
     async def refresh_resolving_list(self) -> None:
@@ -2966,8 +2894,8 @@ class Device(CompositeEventEmitter):
         self,
         legacy: bool = False,
         active: bool = True,
-        scan_interval: float = DEVICE_DEFAULT_SCAN_INTERVAL,  # Scan interval in ms
-        scan_window: float = DEVICE_DEFAULT_SCAN_WINDOW,  # Scan window in ms
+        scan_interval: int = DEVICE_DEFAULT_SCAN_INTERVAL,  # Scan interval in ms
+        scan_window: int = DEVICE_DEFAULT_SCAN_WINDOW,  # Scan window in ms
         own_address_type: int = hci.OwnAddressType.RANDOM,
         filter_duplicates: bool = False,
         scanning_phys: Sequence[int] = (hci.HCI_LE_1M_PHY, hci.HCI_LE_CODED_PHY),
@@ -3183,41 +3111,6 @@ class Device(CompositeEventEmitter):
             "periodic advertising sync establishment for unknown address/sid"
         )
 
-    @host_event_handler
-    def on_periodic_advertising_sync_transfer(
-        self,
-        status: int,
-        connection_handle: int,
-        sync_handle: int,
-        advertising_sid: int,
-        advertiser_address: hci.Address,
-        advertiser_phy: int,
-        periodic_advertising_interval: int,
-        advertiser_clock_accuracy: int,
-    ) -> None:
-        if not (connection := self.lookup_connection(connection_handle)):
-            logger.error(
-                "Receive PAST from unknown connection 0x%04X", connection_handle
-            )
-
-        pa_sync = PeriodicAdvertisingSync(
-            device=self,
-            advertiser_address=advertiser_address,
-            sid=advertising_sid,
-            skip=0,
-            sync_timeout=0.0,
-            filter_duplicates=False,
-        )
-        self.periodic_advertising_syncs.append(pa_sync)
-        pa_sync.on_establishment(
-            status=status,
-            sync_handle=sync_handle,
-            advertiser_phy=advertiser_phy,
-            periodic_advertising_interval=periodic_advertising_interval,
-            advertiser_clock_accuracy=advertiser_clock_accuracy,
-        )
-        self.emit('periodic_advertising_sync_transfer', pa_sync, connection)
-
     @host_event_handler
     @with_periodic_advertising_sync_from_handle
     def on_periodic_advertising_sync_loss(
@@ -4624,213 +4517,6 @@ class Device(CompositeEventEmitter):
             )
             return await read_feature_future
 
-    @experimental('Only for testing.')
-    async def get_remote_cs_capabilities(
-        self, connection: Connection
-    ) -> ChannelSoundingCapabilities:
-        complete_future: asyncio.Future[ChannelSoundingCapabilities] = (
-            asyncio.get_running_loop().create_future()
-        )
-
-        with closing(EventWatcher()) as watcher:
-            watcher.once(
-                connection, 'channel_sounding_capabilities', complete_future.set_result
-            )
-            watcher.once(
-                connection,
-                'channel_sounding_capabilities_failure',
-                lambda status: complete_future.set_exception(hci.HCI_Error(status)),
-            )
-            await self.send_command(
-                hci.HCI_LE_CS_Read_Remote_Supported_Capabilities_Command(
-                    connection_handle=connection.handle
-                ),
-                check_result=True,
-            )
-            return await complete_future
-
-    @experimental('Only for testing.')
-    async def set_default_cs_settings(
-        self,
-        connection: Connection,
-        role_enable: int = (
-            hci.CsRoleMask.INITIATOR | hci.CsRoleMask.REFLECTOR
-        ),  # Both role
-        cs_sync_antenna_selection: int = 0xFF,  # No Preference
-        max_tx_power: int = 0x04,  # 4 dB
-    ) -> None:
-        await self.send_command(
-            hci.HCI_LE_CS_Set_Default_Settings_Command(
-                connection_handle=connection.handle,
-                role_enable=role_enable,
-                cs_sync_antenna_selection=cs_sync_antenna_selection,
-                max_tx_power=max_tx_power,
-            ),
-            check_result=True,
-        )
-
-    @experimental('Only for testing.')
-    async def create_cs_config(
-        self,
-        connection: Connection,
-        config_id: int | None = None,
-        create_context: int = 0x01,
-        main_mode_type: int = 0x02,
-        sub_mode_type: int = 0xFF,
-        min_main_mode_steps: int = 0x02,
-        max_main_mode_steps: int = 0x05,
-        main_mode_repetition: int = 0x00,
-        mode_0_steps: int = 0x03,
-        role: int = hci.CsRole.INITIATOR,
-        rtt_type: int = hci.RttType.AA_ONLY,
-        cs_sync_phy: int = hci.CsSyncPhy.LE_1M,
-        channel_map: bytes = b'\x54\x55\x55\x54\x55\x55\x55\x55\x55\x15',
-        channel_map_repetition: int = 0x01,
-        channel_selection_type: int = hci.HCI_LE_CS_Create_Config_Command.ChannelSelectionType.ALGO_3B,
-        ch3c_shape: int = hci.HCI_LE_CS_Create_Config_Command.Ch3cShape.HAT,
-        ch3c_jump: int = 0x03,
-    ) -> ChannelSoundingConfig:
-        complete_future: asyncio.Future[ChannelSoundingConfig] = (
-            asyncio.get_running_loop().create_future()
-        )
-        if config_id is None:
-            # Allocate an ID.
-            config_id = next(
-                (
-                    i
-                    for i in range(DEVICE_MIN_CS_CONFIG_ID, DEVICE_MAX_CS_CONFIG_ID + 1)
-                    if i not in connection.cs_configs
-                ),
-                None,
-            )
-        if config_id is None:
-            raise OutOfResourcesError("No available config ID on this connection!")
-
-        with closing(EventWatcher()) as watcher:
-            watcher.once(
-                connection, 'channel_sounding_config', complete_future.set_result
-            )
-            watcher.once(
-                connection,
-                'channel_sounding_config_failure',
-                lambda status: complete_future.set_exception(hci.HCI_Error(status)),
-            )
-            await self.send_command(
-                hci.HCI_LE_CS_Create_Config_Command(
-                    connection_handle=connection.handle,
-                    config_id=config_id,
-                    create_context=create_context,
-                    main_mode_type=main_mode_type,
-                    sub_mode_type=sub_mode_type,
-                    min_main_mode_steps=min_main_mode_steps,
-                    max_main_mode_steps=max_main_mode_steps,
-                    main_mode_repetition=main_mode_repetition,
-                    mode_0_steps=mode_0_steps,
-                    role=role,
-                    rtt_type=rtt_type,
-                    cs_sync_phy=cs_sync_phy,
-                    channel_map=channel_map,
-                    channel_map_repetition=channel_map_repetition,
-                    channel_selection_type=channel_selection_type,
-                    ch3c_shape=ch3c_shape,
-                    ch3c_jump=ch3c_jump,
-                    reserved=0x00,
-                ),
-                check_result=True,
-            )
-            return await complete_future
-
-    @experimental('Only for testing.')
-    async def enable_cs_security(self, connection: Connection) -> None:
-        complete_future: asyncio.Future[None] = (
-            asyncio.get_running_loop().create_future()
-        )
-        with closing(EventWatcher()) as watcher:
-
-            def on_event(event: hci.HCI_LE_CS_Security_Enable_Complete_Event) -> None:
-                if event.connection_handle != connection.handle:
-                    return
-                if event.status == hci.HCI_SUCCESS:
-                    complete_future.set_result(None)
-                else:
-                    complete_future.set_exception(hci.HCI_Error(event.status))
-
-            watcher.once(self.host, 'cs_security', on_event)
-            await self.send_command(
-                hci.HCI_LE_CS_Security_Enable_Command(
-                    connection_handle=connection.handle
-                ),
-                check_result=True,
-            )
-            return await complete_future
-
-    @experimental('Only for testing.')
-    async def set_cs_procedure_parameters(
-        self,
-        connection: Connection,
-        config: ChannelSoundingConfig,
-        tone_antenna_config_selection=0x00,
-        preferred_peer_antenna=0x00,
-        max_procedure_len=0x2710,  # 6.25s
-        min_procedure_interval=0x01,
-        max_procedure_interval=0xFF,
-        max_procedure_count=0x01,
-        min_subevent_len=0x0004E2,  # 1250us
-        max_subevent_len=0x1E8480,  # 2s
-        phy=hci.CsSyncPhy.LE_1M,
-        tx_power_delta=0x00,
-        snr_control_initiator=hci.CsSnr.NOT_APPLIED,
-        snr_control_reflector=hci.CsSnr.NOT_APPLIED,
-    ) -> None:
-        await self.send_command(
-            hci.HCI_LE_CS_Set_Procedure_Parameters_Command(
-                connection_handle=connection.handle,
-                config_id=config.config_id,
-                max_procedure_len=max_procedure_len,
-                min_procedure_interval=min_procedure_interval,
-                max_procedure_interval=max_procedure_interval,
-                max_procedure_count=max_procedure_count,
-                min_subevent_len=min_subevent_len,
-                max_subevent_len=max_subevent_len,
-                tone_antenna_config_selection=tone_antenna_config_selection,
-                phy=phy,
-                tx_power_delta=tx_power_delta,
-                preferred_peer_antenna=preferred_peer_antenna,
-                snr_control_initiator=snr_control_initiator,
-                snr_control_reflector=snr_control_reflector,
-            ),
-            check_result=True,
-        )
-
-    @experimental('Only for testing.')
-    async def enable_cs_procedure(
-        self,
-        connection: Connection,
-        config: ChannelSoundingConfig,
-        enabled: bool = True,
-    ) -> ChannelSoundingProcedure:
-        complete_future: asyncio.Future[ChannelSoundingProcedure] = (
-            asyncio.get_running_loop().create_future()
-        )
-        with closing(EventWatcher()) as watcher:
-            watcher.once(
-                connection, 'channel_sounding_procedure', complete_future.set_result
-            )
-            watcher.once(
-                connection,
-                'channel_sounding_procedure_failure',
-                lambda x: complete_future.set_exception(hci.HCI_Error(x)),
-            )
-            await self.send_command(
-                hci.HCI_LE_CS_Procedure_Enable_Command(
-                    connection_handle=connection.handle,
-                    config_id=config.config_id,
-                    enable=enabled,
-                ),
-                check_result=True,
-            )
-            return await complete_future
-
     @host_event_handler
     def on_flush(self):
         self.emit('flush')
@@ -4865,15 +4551,10 @@ class Device(CompositeEventEmitter):
     def add_services(self, services):
         self.gatt_server.add_services(services)
 
-    def add_default_services(
-        self, add_gap_service: bool = True, add_gatt_service: bool = True
-    ) -> None:
+    def add_default_services(self, generic_access_service=True):
         # Add a GAP Service if requested
-        if add_gap_service:
+        if generic_access_service:
             self.gatt_server.add_service(GenericAccessService(self.name))
-        if add_gatt_service:
-            self.gatt_service = gatt_service.GenericAttributeProfileService()
-            self.gatt_server.add_service(self.gatt_service)
 
     async def notify_subscriber(self, connection, attribute, value=None, force=False):
         await self.gatt_server.notify_subscriber(connection, attribute, value, force)
@@ -5794,106 +5475,6 @@ class Device(CompositeEventEmitter):
         )
         connection.emit('connection_data_length_change')
 
-    @host_event_handler
-    def on_cs_remote_supported_capabilities(
-        self, event: hci.HCI_LE_CS_Read_Remote_Supported_Capabilities_Complete_Event
-    ):
-        if not (connection := self.lookup_connection(event.connection_handle)):
-            return
-
-        if event.status != hci.HCI_SUCCESS:
-            connection.emit('channel_sounding_capabilities_failure', event.status)
-            return
-
-        capabilities = ChannelSoundingCapabilities(
-            num_config_supported=event.num_config_supported,
-            max_consecutive_procedures_supported=event.max_consecutive_procedures_supported,
-            num_antennas_supported=event.num_antennas_supported,
-            max_antenna_paths_supported=event.max_antenna_paths_supported,
-            roles_supported=event.roles_supported,
-            modes_supported=event.modes_supported,
-            rtt_capability=event.rtt_capability,
-            rtt_aa_only_n=event.rtt_aa_only_n,
-            rtt_sounding_n=event.rtt_sounding_n,
-            rtt_random_payload_n=event.rtt_random_payload_n,
-            nadm_sounding_capability=event.nadm_sounding_capability,
-            nadm_random_capability=event.nadm_random_capability,
-            cs_sync_phys_supported=event.cs_sync_phys_supported,
-            subfeatures_supported=event.subfeatures_supported,
-            t_ip1_times_supported=event.t_ip1_times_supported,
-            t_ip2_times_supported=event.t_ip2_times_supported,
-            t_fcs_times_supported=event.t_fcs_times_supported,
-            t_pm_times_supported=event.t_pm_times_supported,
-            t_sw_time_supported=event.t_sw_time_supported,
-            tx_snr_capability=event.tx_snr_capability,
-        )
-        connection.emit('channel_sounding_capabilities', capabilities)
-
-    @host_event_handler
-    def on_cs_config(self, event: hci.HCI_LE_CS_Config_Complete_Event):
-        if not (connection := self.lookup_connection(event.connection_handle)):
-            return
-
-        if event.status != hci.HCI_SUCCESS:
-            connection.emit('channel_sounding_config_failure', event.status)
-            return
-        if event.action == hci.HCI_LE_CS_Config_Complete_Event.Action.CREATED:
-            config = ChannelSoundingConfig(
-                config_id=event.config_id,
-                main_mode_type=event.main_mode_type,
-                sub_mode_type=event.sub_mode_type,
-                min_main_mode_steps=event.min_main_mode_steps,
-                max_main_mode_steps=event.max_main_mode_steps,
-                main_mode_repetition=event.main_mode_repetition,
-                mode_0_steps=event.mode_0_steps,
-                role=event.role,
-                rtt_type=event.rtt_type,
-                cs_sync_phy=event.cs_sync_phy,
-                channel_map=event.channel_map,
-                channel_map_repetition=event.channel_map_repetition,
-                channel_selection_type=event.channel_selection_type,
-                ch3c_shape=event.ch3c_shape,
-                ch3c_jump=event.ch3c_jump,
-                reserved=event.reserved,
-                t_ip1_time=event.t_ip1_time,
-                t_ip2_time=event.t_ip2_time,
-                t_fcs_time=event.t_fcs_time,
-                t_pm_time=event.t_pm_time,
-            )
-            connection.cs_configs[event.config_id] = config
-            connection.emit('channel_sounding_config', config)
-        elif event.action == hci.HCI_LE_CS_Config_Complete_Event.Action.REMOVED:
-            try:
-                config = connection.cs_configs.pop(event.config_id)
-                connection.emit('channel_sounding_config_removed', config.config_id)
-            except KeyError:
-                logger.error('Removing unknown config %d', event.config_id)
-
-    @host_event_handler
-    def on_cs_procedure(self, event: hci.HCI_LE_CS_Procedure_Enable_Complete_Event):
-        if not (connection := self.lookup_connection(event.connection_handle)):
-            return
-
-        if event.status != hci.HCI_SUCCESS:
-            connection.emit('channel_sounding_procedure_failure', event.status)
-            return
-
-        procedure = ChannelSoundingProcedure(
-            config_id=event.config_id,
-            state=event.state,
-            tone_antenna_config_selection=event.tone_antenna_config_selection,
-            selected_tx_power=event.selected_tx_power,
-            subevent_len=event.subevent_len,
-            subevents_per_event=event.subevents_per_event,
-            subevent_interval=event.subevent_interval,
-            event_interval=event.event_interval,
-            procedure_interval=event.procedure_interval,
-            procedure_count=event.procedure_count,
-            max_procedure_len=event.max_procedure_len,
-        )
-        connection.cs_procedures[procedure.config_id] = procedure
-        connection.emit('channel_sounding_procedure', procedure)
-
     # [Classic only]
     @host_event_handler
     @with_connection_from_address
@@ -5951,14 +5532,14 @@ class Device(CompositeEventEmitter):
         if att_pdu.op_code & 1:
             if connection.gatt_client is None:
                 logger.warning(
-                    'No GATT client for connection 0x%04X', connection.handle
+                    color('no GATT client for connection 0x{connection_handle:04X}')
                 )
                 return
             connection.gatt_client.on_gatt_pdu(att_pdu)
         else:
             if connection.gatt_server is None:
                 logger.warning(
-                    'No GATT server for connection 0x%04X', connection.handle
+                    color('no GATT server for connection 0x{connection_handle:04X}')
                 )
                 return
             connection.gatt_server.on_gatt_pdu(connection, att_pdu)

bumble/gatt.py

@@ -42,12 +42,13 @@ from typing import (
 )
 
 from bumble.colors import color
-from bumble.core import BaseBumbleError, UUID
+from bumble.core import BaseBumbleError, InvalidOperationError, UUID
 from bumble.att import Attribute, AttributeValue
 from bumble.utils import ByteSerializable
 
 if TYPE_CHECKING:
     from bumble.gatt_client import AttributeProxy
+    from bumble.device import Connection
 
 
 # -----------------------------------------------------------------------------
@@ -314,6 +315,7 @@ GATT_CENTRAL_ADDRESS_RESOLUTION__CHARACTERISTIC                = UUID.from_16_bi
 GATT_CLIENT_SUPPORTED_FEATURES_CHARACTERISTIC                  = UUID.from_16_bits(0x2B29, 'Client Supported Features')
 GATT_DATABASE_HASH_CHARACTERISTIC                              = UUID.from_16_bits(0x2B2A, 'Database Hash')
 GATT_SERVER_SUPPORTED_FEATURES_CHARACTERISTIC                  = UUID.from_16_bits(0x2B3A, 'Server Supported Features')
+GATT_LE_GATT_SECURITY_LEVELS_CHARACTERISTIC                    = UUID.from_16_bits(0x2BF5, 'E GATT Security Levels')
 
 # fmt: on
 # pylint: enable=line-too-long
@@ -322,8 +324,6 @@ GATT_SERVER_SUPPORTED_FEATURES_CHARACTERISTIC                  = UUID.from_16_bi
 # -----------------------------------------------------------------------------
 # Utils
 # -----------------------------------------------------------------------------
-
-
 def show_services(services: Iterable[Service]) -> None:
     for service in services:
         print(color(str(service), 'cyan'))
@@ -679,10 +679,14 @@ class DelegatedCharacteristicAdapter(CharacteristicAdapter):
         self.decode = decode
 
     def encode_value(self, value):
-        return self.encode(value) if self.encode else value
+        if self.encode is None:
+            raise InvalidOperationError('delegated adapter does not have an encoder')
+        return self.encode(value)
 
     def decode_value(self, value):
-        return self.decode(value) if self.decode else value
+        if self.decode is None:
+            raise InvalidOperationError('delegate adapter does not have a decoder')
+        return self.decode(value)
 
 
 # -----------------------------------------------------------------------------
@@ -801,23 +805,3 @@ class ClientCharacteristicConfigurationBits(enum.IntFlag):
     DEFAULT = 0x0000
     NOTIFICATION = 0x0001
     INDICATION = 0x0002
-
-
-# -----------------------------------------------------------------------------
-class ClientSupportedFeatures(enum.IntFlag):
-    '''
-    See Vol 3, Part G - 7.2 - Table 7.6: Client Supported Features bit assignments.
-    '''
-
-    ROBUST_CACHING = 0x01
-    ENHANCED_ATT_BEARER = 0x02
-    MULTIPLE_HANDLE_VALUE_NOTIFICATIONS = 0x04
-
-
-# -----------------------------------------------------------------------------
-class ServerSupportedFeatures(enum.IntFlag):
-    '''
-    See Vol 3, Part G - 7.4 - Table 7.11: Server Supported Features bit assignments.
-    '''
-
-    EATT_SUPPORTED = 0x01

bumble/gatt_client.py

@@ -78,6 +78,7 @@ from .gatt import (
     GATT_INCLUDE_ATTRIBUTE_TYPE,
     Characteristic,
     ClientCharacteristicConfigurationBits,
+    InvalidServiceError,
     TemplateService,
 )
 
@@ -162,12 +163,23 @@ class ServiceProxy(AttributeProxy):
         self.uuid = uuid
         self.characteristics = []
 
-    async def discover_characteristics(self, uuids=()):
+    async def discover_characteristics(self, uuids=()) -> list[CharacteristicProxy]:
         return await self.client.discover_characteristics(uuids, self)
 
-    def get_characteristics_by_uuid(self, uuid):
+    def get_characteristics_by_uuid(self, uuid: UUID) -> list[CharacteristicProxy]:
+        """Get all the characteristics with a specified UUID."""
         return self.client.get_characteristics_by_uuid(uuid, self)
 
+    def get_required_characteristic_by_uuid(self, uuid: UUID) -> CharacteristicProxy:
+        """
+        Get the first characteristic with a specified UUID.
+
+        If no characteristic with that UUID is found, an InvalidServiceError is raised.
+        """
+        if not (characteristics := self.get_characteristics_by_uuid(uuid)):
+            raise InvalidServiceError(f'{uuid} characteristic not found')
+        return characteristics[0]
+
     def __str__(self) -> str:
         return f'Service(handle=0x{self.handle:04X}, uuid={self.uuid})'
 

bumble/hci.py

@@ -791,27 +791,6 @@ class CsSnr(OpenIntEnum):
     NOT_APPLIED = 0xFF
 
 
-class CsDoneStatus(OpenIntEnum):
-    ALL_RESULTS_COMPLETED = 0x00
-    PARTIAL = 0x01
-    ABORTED = 0x0F
-
-
-class CsProcedureAbortReason(OpenIntEnum):
-    NO_ABORT = 0x00
-    LOCAL_HOST_OR_REMOTE_REQUEST = 0x01
-    CHANNEL_MAP_UPDATE_INSTANT_PASSED = 0x02
-    UNSPECIFIED = 0x0F
-
-
-class CsSubeventAbortReason(OpenIntEnum):
-    NO_ABORT = 0x00
-    LOCAL_HOST_OR_REMOTE_REQUEST = 0x01
-    NO_CS_SYNC_RECEIVED = 0x02
-    SCHEDULING_CONFLICT_OR_LIMITED_RESOURCES = 0x03
-    UNSPECIFIED = 0x0F
-
-
 # Connection Parameters
 HCI_CONNECTION_INTERVAL_MS_PER_UNIT = 1.25
 HCI_CONNECTION_LATENCY_MS_PER_UNIT  = 1.25
@@ -4878,62 +4857,6 @@ class HCI_LE_Periodic_Advertising_Sync_Transfer_Command(HCI_Command):
     '''
 
 
-# -----------------------------------------------------------------------------
-@HCI_Command.command(
-    fields=[
-        ('connection_handle', 2),
-        ('mode', 1),
-        ('skip', 2),
-        ('sync_timeout', 2),
-        (
-            'cte_type',
-            {
-                'size': 1,
-                'mapper': lambda x: HCI_LE_Periodic_Advertising_Report_Event.CteType(
-                    x
-                ).name,
-            },
-        ),
-    ],
-    return_parameters_fields=[
-        ('status', STATUS_SPEC),
-        ('connection_handle', 2),
-    ],
-)
-class HCI_LE_Set_Periodic_Advertising_Sync_Transfer_Parameters_Command(HCI_Command):
-    '''
-    See Bluetooth spec @ 7.8.91 LE Set Periodic Advertising Sync Transfer Parameters command
-    '''
-
-
-# -----------------------------------------------------------------------------
-@HCI_Command.command(
-    fields=[
-        ('mode', 1),
-        ('skip', 2),
-        ('sync_timeout', 2),
-        (
-            'cte_type',
-            {
-                'size': 1,
-                'mapper': lambda x: HCI_LE_Periodic_Advertising_Report_Event.CteType(
-                    x
-                ).name,
-            },
-        ),
-    ],
-    return_parameters_fields=[
-        ('status', STATUS_SPEC),
-    ],
-)
-class HCI_LE_Set_Default_Periodic_Advertising_Sync_Transfer_Parameters_Command(
-    HCI_Command
-):
-    '''
-    See Bluetooth spec @ 7.8.92 LE Set Default Periodic Advertising Sync Transfer Parameters command
-    '''
-
-
 # -----------------------------------------------------------------------------
 @HCI_Command.command(
     fields=[
@@ -6287,31 +6210,6 @@ class HCI_LE_Periodic_Advertising_Sync_Transfer_Received_Event(HCI_LE_Meta_Event
     '''
 
 
-# -----------------------------------------------------------------------------
-@HCI_LE_Meta_Event.event(
-    [
-        ('status', STATUS_SPEC),
-        ('connection_handle', 2),
-        ('service_data', 2),
-        ('sync_handle', 2),
-        ('advertising_sid', 1),
-        ('advertiser_address_type', Address.ADDRESS_TYPE_SPEC),
-        ('advertiser_address', Address.parse_address_preceded_by_type),
-        ('advertiser_phy', 1),
-        ('periodic_advertising_interval', 2),
-        ('advertiser_clock_accuracy', 1),
-        ('num_subevents', 1),
-        ('subevent_interval', 1),
-        ('response_slot_delay', 1),
-        ('response_slot_spacing', 1),
-    ]
-)
-class HCI_LE_Periodic_Advertising_Sync_Transfer_Received_V2_Event(HCI_LE_Meta_Event):
-    '''
-    See Bluetooth spec @ 7.7.65.24 LE Periodic Advertising Sync Transfer Received Event
-    '''
-
-
 # -----------------------------------------------------------------------------
 @HCI_LE_Meta_Event.event(
     [
@@ -6608,7 +6506,7 @@ class HCI_LE_CS_Config_Complete_Event(HCI_LE_Meta_Event):
         ('config_id', 1),
         ('state', 1),
         ('tone_antenna_config_selection', 1),
-        ('selected_tx_power', -1),
+        ('selected_tx_power', 1),
         ('subevent_len', 3),
         ('subevents_per_event', 1),
         ('subevent_interval', 2),
@@ -6650,7 +6548,7 @@ class HCI_LE_CS_Procedure_Enable_Complete_Event(HCI_LE_Meta_Event):
         ('start_acl_conn_event_counter', 2),
         ('procedure_counter', 2),
         ('frequency_compensation', 2),
-        ('reference_power_level', -1),
+        ('reference_power_level', 1),
         ('procedure_done_status', 1),
         ('subevent_done_status', 1),
         ('abort_reason', 1),
@@ -6667,7 +6565,7 @@ class HCI_LE_CS_Subevent_Result_Event(HCI_LE_Meta_Event):
     See Bluetooth spec @ 7.7.65.44 LE CS Subevent Result event
     '''
 
-    connection_handle: int
+    status: int
     config_id: int
     start_acl_conn_event_counter: int
     procedure_counter: int
@@ -6703,7 +6601,7 @@ class HCI_LE_CS_Subevent_Result_Continue_Event(HCI_LE_Meta_Event):
     See Bluetooth spec @ 7.7.65.45 LE CS Subevent Result Continue event
     '''
 
-    connection_handle: int
+    status: int
     config_id: int
     procedure_done_status: int
     subevent_done_status: int

bumble/host.py

@@ -476,12 +476,6 @@ class Host(AbortableEventEmitter):
                     hci.HCI_LE_TRANSMIT_POWER_REPORTING_EVENT,
                     hci.HCI_LE_BIGINFO_ADVERTISING_REPORT_EVENT,
                     hci.HCI_LE_SUBRATE_CHANGE_EVENT,
-                    hci.HCI_LE_CS_READ_REMOTE_SUPPORTED_CAPABILITIES_COMPLETE_EVENT,
-                    hci.HCI_LE_CS_PROCEDURE_ENABLE_COMPLETE_EVENT,
-                    hci.HCI_LE_CS_SECURITY_ENABLE_COMPLETE_EVENT,
-                    hci.HCI_LE_CS_CONFIG_COMPLETE_EVENT,
-                    hci.HCI_LE_CS_SUBEVENT_RESULT_EVENT,
-                    hci.HCI_LE_CS_SUBEVENT_RESULT_CONTINUE_EVENT,
                 ]
             )
 
@@ -1204,32 +1198,6 @@ class Host(AbortableEventEmitter):
         self.remove_big(event.big_handle)
         self.emit('big_termination', event.reason, event.big_handle)
 
-    def on_hci_le_periodic_advertising_sync_transfer_received_event(self, event):
-        self.emit(
-            'periodic_advertising_sync_transfer',
-            event.status,
-            event.connection_handle,
-            event.sync_handle,
-            event.advertising_sid,
-            event.advertiser_address,
-            event.advertiser_phy,
-            event.periodic_advertising_interval,
-            event.advertiser_clock_accuracy,
-        )
-
-    def on_hci_le_periodic_advertising_sync_transfer_received_v2_event(self, event):
-        self.emit(
-            'periodic_advertising_sync_transfer',
-            event.status,
-            event.connection_handle,
-            event.sync_handle,
-            event.advertising_sid,
-            event.advertiser_address,
-            event.advertiser_phy,
-            event.periodic_advertising_interval,
-            event.advertiser_clock_accuracy,
-        )
-
     def on_hci_le_cis_established_event(self, event):
         # The remaining parameters are unused for now.
         if event.status == hci.HCI_SUCCESS:
@@ -1527,23 +1495,5 @@ class Host(AbortableEventEmitter):
                 int.from_bytes(event.le_features, 'little'),
             )
 
-    def on_hci_le_cs_read_remote_supported_capabilities_complete_event(self, event):
-        self.emit('cs_remote_supported_capabilities', event)
-
-    def on_hci_le_cs_security_enable_complete_event(self, event):
-        self.emit('cs_security', event)
-
-    def on_hci_le_cs_config_complete_event(self, event):
-        self.emit('cs_config', event)
-
-    def on_hci_le_cs_procedure_enable_complete_event(self, event):
-        self.emit('cs_procedure', event)
-
-    def on_hci_le_cs_subevent_result_event(self, event):
-        self.emit('cs_subevent_result', event)
-
-    def on_hci_le_cs_subevent_result_continue_event(self, event):
-        self.emit('cs_subevent_result_continue', event)
-
     def on_hci_vendor_event(self, event):
         self.emit('vendor_event', event)

bumble/profiles/aics.py

@@ -451,54 +451,35 @@ class AICSServiceProxy(ProfileServiceProxy):
     def __init__(self, service_proxy: ServiceProxy) -> None:
         self.service_proxy = service_proxy
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_AUDIO_INPUT_STATE_CHARACTERISTIC
-            )
-        ):
-            raise gatt.InvalidServiceError("Audio Input State Characteristic not found")
         self.audio_input_state = SerializableCharacteristicAdapter(
-            characteristics[0], AudioInputState
+            service_proxy.get_required_characteristic_by_uuid(
+                GATT_AUDIO_INPUT_STATE_CHARACTERISTIC
+            ),
+            AudioInputState,
         )
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_GAIN_SETTINGS_ATTRIBUTE_CHARACTERISTIC
-            )
-        ):
-            raise gatt.InvalidServiceError(
-                "Gain Settings Attribute Characteristic not found"
-            )
         self.gain_settings_properties = SerializableCharacteristicAdapter(
-            characteristics[0], GainSettingsProperties
+            service_proxy.get_required_characteristic_by_uuid(
+                GATT_GAIN_SETTINGS_ATTRIBUTE_CHARACTERISTIC
+            ),
+            GainSettingsProperties,
         )
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
+        self.audio_input_status = PackedCharacteristicAdapter(
+            service_proxy.get_required_characteristic_by_uuid(
                 GATT_AUDIO_INPUT_STATUS_CHARACTERISTIC
-            )
-        ):
-            raise gatt.InvalidServiceError(
-                "Audio Input Status Characteristic not found"
-            )
-        self.audio_input_status = PackedCharacteristicAdapter(characteristics[0], 'B')
+            ),
+            'B',
+        )
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
+        self.audio_input_control_point = (
+            service_proxy.get_required_characteristic_by_uuid(
                 GATT_AUDIO_INPUT_CONTROL_POINT_CHARACTERISTIC
             )
-        ):
-            raise gatt.InvalidServiceError(
-                "Audio Input Control Point Characteristic not found"
-            )
-        self.audio_input_control_point = characteristics[0]
+        )
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
+        self.audio_input_description = UTF8CharacteristicAdapter(
+            service_proxy.get_required_characteristic_by_uuid(
                 GATT_AUDIO_INPUT_DESCRIPTION_CHARACTERISTIC
             )
-        ):
-            raise gatt.InvalidServiceError(
-                "Audio Input Description Characteristic not found"
-            )
-        self.audio_input_description = UTF8CharacteristicAdapter(characteristics[0])
+        )

bumble/profiles/asha.py

@@ -288,8 +288,8 @@ class AshaServiceProxy(gatt_client.ProfileServiceProxy):
                 'psm_characteristic',
             ),
         ):
-            if not (
-                characteristics := self.service_proxy.get_characteristics_by_uuid(uuid)
-            ):
-                raise gatt.InvalidServiceError(f"Missing {uuid} Characteristic")
-            setattr(self, attribute_name, characteristics[0])
+            setattr(
+                self,
+                attribute_name,
+                self.service_proxy.get_required_characteristic_by_uuid(uuid),
+            )

bumble/profiles/bass.py

@@ -354,34 +354,25 @@ class BroadcastAudioScanServiceProxy(gatt_client.ProfileServiceProxy):
     SERVICE_CLASS = BroadcastAudioScanService
 
     broadcast_audio_scan_control_point: gatt_client.CharacteristicProxy
-    broadcast_receive_states: List[gatt.SerializableCharacteristicAdapter]
+    broadcast_receive_states: List[gatt.DelegatedCharacteristicAdapter]
 
     def __init__(self, service_proxy: gatt_client.ServiceProxy):
         self.service_proxy = service_proxy
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
+        self.broadcast_audio_scan_control_point = (
+            service_proxy.get_required_characteristic_by_uuid(
                 gatt.GATT_BROADCAST_AUDIO_SCAN_CONTROL_POINT_CHARACTERISTIC
             )
-        ):
-            raise gatt.InvalidServiceError(
-                "Broadcast Audio Scan Control Point characteristic not found"
-            )
-        self.broadcast_audio_scan_control_point = characteristics[0]
+        )
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
+        self.broadcast_receive_states = [
+            gatt.DelegatedCharacteristicAdapter(
+                characteristic,
+                decode=lambda x: BroadcastReceiveState.from_bytes(x) if x else None,
+            )
+            for characteristic in service_proxy.get_characteristics_by_uuid(
                 gatt.GATT_BROADCAST_RECEIVE_STATE_CHARACTERISTIC
             )
-        ):
-            raise gatt.InvalidServiceError(
-                "Broadcast Receive State characteristic not found"
-            )
-        self.broadcast_receive_states = [
-            gatt.SerializableCharacteristicAdapter(
-                characteristic, BroadcastReceiveState
-            )
-            for characteristic in characteristics
         ]
 
     async def send_control_point_operation(

bumble/profiles/gatt_service.py

@@ -1,166 +0,0 @@
-# Copyright 2021-2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-import struct
-from typing import TYPE_CHECKING
-
-from bumble import att
-from bumble import gatt
-from bumble import gatt_client
-from bumble import crypto
-
-if TYPE_CHECKING:
-    from bumble import device
-
-
-# -----------------------------------------------------------------------------
-class GenericAttributeProfileService(gatt.TemplateService):
-    '''See Vol 3, Part G - 7 - DEFINED GENERIC ATTRIBUTE PROFILE SERVICE.'''
-
-    UUID = gatt.GATT_GENERIC_ATTRIBUTE_SERVICE
-
-    client_supported_features_characteristic: gatt.Characteristic | None = None
-    server_supported_features_characteristic: gatt.Characteristic | None = None
-    database_hash_characteristic: gatt.Characteristic | None = None
-    service_changed_characteristic: gatt.Characteristic | None = None
-
-    def __init__(
-        self,
-        server_supported_features: gatt.ServerSupportedFeatures | None = None,
-        database_hash_enabled: bool = True,
-        service_change_enabled: bool = True,
-    ) -> None:
-
-        if server_supported_features is not None:
-            self.server_supported_features_characteristic = gatt.Characteristic(
-                uuid=gatt.GATT_SERVER_SUPPORTED_FEATURES_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.READ,
-                permissions=gatt.Characteristic.Permissions.READABLE,
-                value=bytes([server_supported_features]),
-            )
-
-        if database_hash_enabled:
-            self.database_hash_characteristic = gatt.Characteristic(
-                uuid=gatt.GATT_DATABASE_HASH_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.READ,
-                permissions=gatt.Characteristic.Permissions.READABLE,
-                value=gatt.CharacteristicValue(read=self.get_database_hash),
-            )
-
-        if service_change_enabled:
-            self.service_changed_characteristic = gatt.Characteristic(
-                uuid=gatt.GATT_SERVICE_CHANGED_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.INDICATE,
-                permissions=gatt.Characteristic.Permissions(0),
-                value=b'',
-            )
-
-        if (database_hash_enabled and service_change_enabled) or (
-            server_supported_features
-            and (
-                server_supported_features & gatt.ServerSupportedFeatures.EATT_SUPPORTED
-            )
-        ):  # TODO: Support Multiple Handle Value Notifications
-            self.client_supported_features_characteristic = gatt.Characteristic(
-                uuid=gatt.GATT_CLIENT_SUPPORTED_FEATURES_CHARACTERISTIC,
-                properties=(
-                    gatt.Characteristic.Properties.READ
-                    | gatt.Characteristic.Properties.WRITE
-                ),
-                permissions=(
-                    gatt.Characteristic.Permissions.READABLE
-                    | gatt.Characteristic.Permissions.WRITEABLE
-                ),
-                value=bytes(1),
-            )
-
-        super().__init__(
-            characteristics=[
-                c
-                for c in (
-                    self.service_changed_characteristic,
-                    self.client_supported_features_characteristic,
-                    self.database_hash_characteristic,
-                    self.server_supported_features_characteristic,
-                )
-                if c is not None
-            ],
-            primary=True,
-        )
-
-    @classmethod
-    def get_attribute_data(cls, attribute: att.Attribute) -> bytes:
-        if attribute.type in (
-            gatt.GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE,
-            gatt.GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE,
-            gatt.GATT_INCLUDE_ATTRIBUTE_TYPE,
-            gatt.GATT_CHARACTERISTIC_ATTRIBUTE_TYPE,
-            gatt.GATT_CHARACTERISTIC_EXTENDED_PROPERTIES_DESCRIPTOR,
-        ):
-            return (
-                struct.pack("<H", attribute.handle)
-                + attribute.type.to_bytes()
-                + attribute.value
-            )
-        elif attribute.type in (
-            gatt.GATT_CHARACTERISTIC_USER_DESCRIPTION_DESCRIPTOR,
-            gatt.GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR,
-            gatt.GATT_SERVER_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR,
-            gatt.GATT_CHARACTERISTIC_PRESENTATION_FORMAT_DESCRIPTOR,
-            gatt.GATT_CHARACTERISTIC_AGGREGATE_FORMAT_DESCRIPTOR,
-        ):
-            return struct.pack("<H", attribute.handle) + attribute.type.to_bytes()
-
-        return b''
-
-    def get_database_hash(self, connection: device.Connection | None) -> bytes:
-        assert connection
-
-        m = b''.join(
-            [
-                self.get_attribute_data(attribute)
-                for attribute in connection.device.gatt_server.attributes
-            ]
-        )
-
-        return crypto.aes_cmac(m=m, k=bytes(16))
-
-
-class GenericAttributeProfileServiceProxy(gatt_client.ProfileServiceProxy):
-    SERVICE_CLASS = GenericAttributeProfileService
-
-    client_supported_features_characteristic: gatt_client.CharacteristicProxy | None = (
-        None
-    )
-    server_supported_features_characteristic: gatt_client.CharacteristicProxy | None = (
-        None
-    )
-    database_hash_characteristic: gatt_client.CharacteristicProxy | None = None
-    service_changed_characteristic: gatt_client.CharacteristicProxy | None = None
-
-    _CHARACTERISTICS = {
-        gatt.GATT_CLIENT_SUPPORTED_FEATURES_CHARACTERISTIC: 'client_supported_features_characteristic',
-        gatt.GATT_SERVER_SUPPORTED_FEATURES_CHARACTERISTIC: 'server_supported_features_characteristic',
-        gatt.GATT_DATABASE_HASH_CHARACTERISTIC: 'database_hash_characteristic',
-        gatt.GATT_SERVICE_CHANGED_CHARACTERISTIC: 'service_changed_characteristic',
-    }
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
-        self.service_proxy = service_proxy
-
-        for uuid, attribute_name in self._CHARACTERISTICS.items():
-            if characteristics := self.service_proxy.get_characteristics_by_uuid(uuid):
-                setattr(self, attribute_name, characteristics[0])

bumble/profiles/gmap.py

@@ -30,7 +30,6 @@ from bumble.gatt import (
     GATT_UGT_FEATURES_CHARACTERISTIC,
     GATT_BGS_FEATURES_CHARACTERISTIC,
     GATT_BGR_FEATURES_CHARACTERISTIC,
-    InvalidServiceError,
 )
 from bumble.gatt_client import ProfileServiceProxy, ServiceProxy
 from enum import IntFlag
@@ -154,14 +153,10 @@ class GamingAudioServiceProxy(ProfileServiceProxy):
     def __init__(self, service_proxy: ServiceProxy) -> None:
         self.service_proxy = service_proxy
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_GMAP_ROLE_CHARACTERISTIC
-            )
-        ):
-            raise InvalidServiceError("GMAP Role Characteristic not found")
         self.gmap_role = DelegatedCharacteristicAdapter(
-            characteristic=characteristics[0],
+            service_proxy.get_required_characteristic_by_uuid(
+                GATT_GMAP_ROLE_CHARACTERISTIC
+            ),
             decode=lambda value: GmapRole(value[0]),
         )
 

bumble/profiles/le_audio.py

@@ -17,23 +17,35 @@
 # -----------------------------------------------------------------------------
 from __future__ import annotations
 import dataclasses
+import enum
 import struct
-from typing import List, Type
+from typing import Any, List, Type
 from typing_extensions import Self
 
+from bumble.profiles import bap
 from bumble import utils
 
 
 # -----------------------------------------------------------------------------
 # Classes
 # -----------------------------------------------------------------------------
+class AudioActiveState(utils.OpenIntEnum):
+    NO_AUDIO_DATA_TRANSMITTED = 0x00
+    AUDIO_DATA_TRANSMITTED = 0x01
+
+
+class AssistedListeningStream(utils.OpenIntEnum):
+    UNSPECIFIED_AUDIO_ENHANCEMENT = 0x00
+
+
 @dataclasses.dataclass
 class Metadata:
     '''Bluetooth Assigned Numbers, Section 6.12.6 - Metadata LTV structures.
 
-    As Metadata fields may extend, and Spec doesn't forbid duplication, we don't parse
-    Metadata into a key-value style dataclass here. Rather, we encourage users to parse
-    again outside the lib.
+    As Metadata fields may extend, and the spec may not guarantee the uniqueness of
+    tags, we don't automatically parse the Metadata data into specific classes.
+    Users of this class may decode the data by themselves, or use the Entry.decode
+    method.
     '''
 
     class Tag(utils.OpenIntEnum):
@@ -57,6 +69,44 @@ class Metadata:
         tag: Metadata.Tag
         data: bytes
 
+        def decode(self) -> Any:
+            """
+            Decode the data into an object, if possible.
+
+            If no specific object class exists to represent the data, the raw data
+            bytes are returned.
+            """
+
+            if self.tag in (
+                Metadata.Tag.PREFERRED_AUDIO_CONTEXTS,
+                Metadata.Tag.STREAMING_AUDIO_CONTEXTS,
+            ):
+                return bap.ContextType(struct.unpack("<H", self.data)[0])
+
+            if self.tag in (
+                Metadata.Tag.PROGRAM_INFO,
+                Metadata.Tag.PROGRAM_INFO_URI,
+                Metadata.Tag.BROADCAST_NAME,
+            ):
+                return self.data.decode("utf-8")
+
+            if self.tag == Metadata.Tag.LANGUAGE:
+                return self.data.decode("ascii")
+
+            if self.tag == Metadata.Tag.CCID_LIST:
+                return list(self.data)
+
+            if self.tag == Metadata.Tag.PARENTAL_RATING:
+                return self.data[0]
+
+            if self.tag == Metadata.Tag.AUDIO_ACTIVE_STATE:
+                return AudioActiveState(self.data[0])
+
+            if self.tag == Metadata.Tag.ASSISTED_LISTENING_STREAM:
+                return AssistedListeningStream(self.data[0])
+
+            return self.data
+
         @classmethod
         def from_bytes(cls: Type[Self], data: bytes) -> Self:
             return cls(tag=Metadata.Tag(data[0]), data=data[1:])
@@ -66,6 +116,29 @@ class Metadata:
 
     entries: List[Entry] = dataclasses.field(default_factory=list)
 
+    def pretty_print(self, indent: str) -> str:
+        """Convenience method to generate a string with one key-value pair per line."""
+
+        max_key_length = 0
+        keys = []
+        values = []
+        for entry in self.entries:
+            key = entry.tag.name
+            max_key_length = max(max_key_length, len(key))
+            keys.append(key)
+            decoded = entry.decode()
+            if isinstance(decoded, enum.Enum):
+                values.append(decoded.name)
+            elif isinstance(decoded, bytes):
+                values.append(decoded.hex())
+            else:
+                values.append(str(decoded))
+
+        return '\n'.join(
+            f'{indent}{key}: {" " * (max_key_length-len(key))}{value}'
+            for key, value in zip(keys, values)
+        )
+
     @classmethod
     def from_bytes(cls: Type[Self], data: bytes) -> Self:
         entries = []
@@ -81,3 +154,13 @@ class Metadata:
 
     def __bytes__(self) -> bytes:
         return b''.join([bytes(entry) for entry in self.entries])
+
+    def __str__(self) -> str:
+        entries_str = []
+        for entry in self.entries:
+            decoded = entry.decode()
+            entries_str.append(
+                f'{entry.tag.name}: '
+                f'{decoded.hex() if isinstance(decoded, bytes) else decoded!r}'
+            )
+        return f'Metadata(entries={", ".join(entry_str for entry_str in entries_str)})'

bumble/profiles/pacs.py

@@ -72,6 +72,19 @@ class PacRecord:
             metadata=metadata,
         )
 
+    @classmethod
+    def list_from_bytes(cls, data: bytes) -> list[PacRecord]:
+        """Parse a serialized list of records preceded by a one byte list length."""
+        record_count = data[0]
+        records = []
+        offset = 1
+        for _ in range(record_count):
+            record = PacRecord.from_bytes(data[offset:])
+            offset += len(bytes(record))
+            records.append(record)
+
+        return records
+
     def __bytes__(self) -> bytes:
         capabilities_bytes = bytes(self.codec_specific_capabilities)
         metadata_bytes = bytes(self.metadata)
@@ -172,39 +185,58 @@ class PublishedAudioCapabilitiesService(gatt.TemplateService):
 class PublishedAudioCapabilitiesServiceProxy(gatt_client.ProfileServiceProxy):
     SERVICE_CLASS = PublishedAudioCapabilitiesService
 
-    sink_pac: Optional[gatt_client.CharacteristicProxy] = None
-    sink_audio_locations: Optional[gatt_client.CharacteristicProxy] = None
-    source_pac: Optional[gatt_client.CharacteristicProxy] = None
-    source_audio_locations: Optional[gatt_client.CharacteristicProxy] = None
-    available_audio_contexts: gatt_client.CharacteristicProxy
-    supported_audio_contexts: gatt_client.CharacteristicProxy
+    sink_pac: Optional[gatt.DelegatedCharacteristicAdapter] = None
+    sink_audio_locations: Optional[gatt.DelegatedCharacteristicAdapter] = None
+    source_pac: Optional[gatt.DelegatedCharacteristicAdapter] = None
+    source_audio_locations: Optional[gatt.DelegatedCharacteristicAdapter] = None
+    available_audio_contexts: gatt.DelegatedCharacteristicAdapter
+    supported_audio_contexts: gatt.DelegatedCharacteristicAdapter
 
     def __init__(self, service_proxy: gatt_client.ServiceProxy):
         self.service_proxy = service_proxy
 
-        self.available_audio_contexts = service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_AVAILABLE_AUDIO_CONTEXTS_CHARACTERISTIC
-        )[0]
-        self.supported_audio_contexts = service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_SUPPORTED_AUDIO_CONTEXTS_CHARACTERISTIC
-        )[0]
+        self.available_audio_contexts = gatt.DelegatedCharacteristicAdapter(
+            service_proxy.get_required_characteristic_by_uuid(
+                gatt.GATT_AVAILABLE_AUDIO_CONTEXTS_CHARACTERISTIC
+            ),
+            decode=lambda x: tuple(map(ContextType, struct.unpack('<HH', x))),
+        )
+
+        self.supported_audio_contexts = gatt.DelegatedCharacteristicAdapter(
+            service_proxy.get_required_characteristic_by_uuid(
+                gatt.GATT_SUPPORTED_AUDIO_CONTEXTS_CHARACTERISTIC
+            ),
+            decode=lambda x: tuple(map(ContextType, struct.unpack('<HH', x))),
+        )
 
         if characteristics := service_proxy.get_characteristics_by_uuid(
             gatt.GATT_SINK_PAC_CHARACTERISTIC
         ):
-            self.sink_pac = characteristics[0]
+            self.sink_pac = gatt.DelegatedCharacteristicAdapter(
+                characteristics[0],
+                decode=PacRecord.list_from_bytes,
+            )
 
         if characteristics := service_proxy.get_characteristics_by_uuid(
             gatt.GATT_SOURCE_PAC_CHARACTERISTIC
         ):
-            self.source_pac = characteristics[0]
+            self.source_pac = gatt.DelegatedCharacteristicAdapter(
+                characteristics[0],
+                decode=PacRecord.list_from_bytes,
+            )
 
         if characteristics := service_proxy.get_characteristics_by_uuid(
             gatt.GATT_SINK_AUDIO_LOCATION_CHARACTERISTIC
         ):
-            self.sink_audio_locations = characteristics[0]
+            self.sink_audio_locations = gatt.DelegatedCharacteristicAdapter(
+                characteristics[0],
+                decode=lambda x: AudioLocation(struct.unpack('<I', x)[0]),
+            )
 
         if characteristics := service_proxy.get_characteristics_by_uuid(
             gatt.GATT_SOURCE_AUDIO_LOCATION_CHARACTERISTIC
         ):
-            self.source_audio_locations = characteristics[0]
+            self.source_audio_locations = gatt.DelegatedCharacteristicAdapter(
+                characteristics[0],
+                decode=lambda x: AudioLocation(struct.unpack('<I', x)[0]),
+            )

bumble/profiles/tmap.py

@@ -25,7 +25,6 @@ from bumble.gatt import (
     TemplateService,
     Characteristic,
     DelegatedCharacteristicAdapter,
-    InvalidServiceError,
     GATT_TELEPHONY_AND_MEDIA_AUDIO_SERVICE,
     GATT_TMAP_ROLE_CHARACTERISTIC,
 )
@@ -74,15 +73,10 @@ class TelephonyAndMediaAudioServiceProxy(ProfileServiceProxy):
     def __init__(self, service_proxy: ServiceProxy):
         self.service_proxy = service_proxy
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_TMAP_ROLE_CHARACTERISTIC
-            )
-        ):
-            raise InvalidServiceError('TMAP Role characteristic not found')
-
         self.role = DelegatedCharacteristicAdapter(
-            characteristics[0],
+            service_proxy.get_required_characteristic_by_uuid(
+                GATT_TMAP_ROLE_CHARACTERISTIC
+            ),
             decode=lambda value: Role(
                 struct.unpack_from('<H', value, 0)[0],
             ),

bumble/profiles/vcs.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2024 Google LLC
+# Copyright 2021-2025 Google LLC
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,14 +17,16 @@
 # Imports
 # -----------------------------------------------------------------------------
 from __future__ import annotations
+import dataclasses
 import enum
 
+from typing import Optional, Sequence
+
 from bumble import att
 from bumble import device
 from bumble import gatt
 from bumble import gatt_client
 
-from typing import Optional, Sequence
 
 # -----------------------------------------------------------------------------
 # Constants
@@ -67,6 +69,20 @@ class VolumeControlPointOpcode(enum.IntEnum):
     MUTE                        = 0x06
 
 
+@dataclasses.dataclass
+class VolumeState:
+    volume_setting: int
+    mute: int
+    change_counter: int
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> VolumeState:
+        return cls(data[0], data[1], data[2])
+
+    def __bytes__(self) -> bytes:
+        return bytes([self.volume_setting, self.mute, self.change_counter])
+
+
 # -----------------------------------------------------------------------------
 # Server
 # -----------------------------------------------------------------------------
@@ -126,16 +142,8 @@ class VolumeControlService(gatt.TemplateService):
             included_services=list(included_services),
         )
 
-    @property
-    def volume_state_bytes(self) -> bytes:
-        return bytes([self.volume_setting, self.muted, self.change_counter])
-
-    @volume_state_bytes.setter
-    def volume_state_bytes(self, new_value: bytes) -> None:
-        self.volume_setting, self.muted, self.change_counter = new_value
-
     def _on_read_volume_state(self, _connection: Optional[device.Connection]) -> bytes:
-        return self.volume_state_bytes
+        return bytes(VolumeState(self.volume_setting, self.muted, self.change_counter))
 
     def _on_write_volume_control_point(
         self, connection: Optional[device.Connection], value: bytes
@@ -153,14 +161,9 @@ class VolumeControlService(gatt.TemplateService):
             self.change_counter = (self.change_counter + 1) % 256
             connection.abort_on(
                 'disconnection',
-                connection.device.notify_subscribers(
-                    attribute=self.volume_state,
-                    value=self.volume_state_bytes,
-                ),
-            )
-            self.emit(
-                'volume_state', self.volume_setting, self.muted, self.change_counter
+                connection.device.notify_subscribers(attribute=self.volume_state),
             )
+            self.emit('volume_state_change')
 
     def _on_relative_volume_down(self) -> bool:
         old_volume = self.volume_setting
@@ -207,24 +210,26 @@ class VolumeControlServiceProxy(gatt_client.ProfileServiceProxy):
     SERVICE_CLASS = VolumeControlService
 
     volume_control_point: gatt_client.CharacteristicProxy
+    volume_state: gatt.SerializableCharacteristicAdapter
+    volume_flags: gatt.DelegatedCharacteristicAdapter
 
     def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
         self.service_proxy = service_proxy
 
-        self.volume_state = gatt.PackedCharacteristicAdapter(
-            service_proxy.get_characteristics_by_uuid(
+        self.volume_state = gatt.SerializableCharacteristicAdapter(
+            service_proxy.get_required_characteristic_by_uuid(
                 gatt.GATT_VOLUME_STATE_CHARACTERISTIC
-            )[0],
-            'BBB',
+            ),
+            VolumeState,
         )
 
-        self.volume_control_point = service_proxy.get_characteristics_by_uuid(
+        self.volume_control_point = service_proxy.get_required_characteristic_by_uuid(
             gatt.GATT_VOLUME_CONTROL_POINT_CHARACTERISTIC
-        )[0]
-
-        self.volume_flags = gatt.PackedCharacteristicAdapter(
-            service_proxy.get_characteristics_by_uuid(
-                gatt.GATT_VOLUME_FLAGS_CHARACTERISTIC
-            )[0],
-            'B',
+        )
+
+        self.volume_flags = gatt.DelegatedCharacteristicAdapter(
+            service_proxy.get_required_characteristic_by_uuid(
+                gatt.GATT_VOLUME_FLAGS_CHARACTERISTIC
+            ),
+            decode=lambda data: VolumeFlags(data[0]),
         )

bumble/profiles/vocs.py

@@ -27,8 +27,8 @@ from bumble.gatt import (
     DelegatedCharacteristicAdapter,
     TemplateService,
     CharacteristicValue,
+    SerializableCharacteristicAdapter,
     UTF8CharacteristicAdapter,
-    InvalidServiceError,
     GATT_VOLUME_OFFSET_CONTROL_SERVICE,
     GATT_VOLUME_OFFSET_STATE_CHARACTERISTIC,
     GATT_AUDIO_LOCATION_CHARACTERISTIC,
@@ -82,9 +82,7 @@ class VolumeOffsetState:
 
     async def notify_subscribers_via_connection(self, connection: Connection) -> None:
         assert self.attribute_value is not None
-        await connection.device.notify_subscribers(
-            attribute=self.attribute_value, value=bytes(self)
-        )
+        await connection.device.notify_subscribers(attribute=self.attribute_value)
 
     def on_read(self, _connection: Optional[Connection]) -> bytes:
         return bytes(self)
@@ -111,9 +109,7 @@ class VocsAudioLocation:
         assert self.attribute_value
 
         self.audio_location = AudioLocation(int.from_bytes(value, 'little'))
-        await connection.device.notify_subscribers(
-            attribute=self.attribute_value, value=value
-        )
+        await connection.device.notify_subscribers(attribute=self.attribute_value)
 
 
 @dataclass
@@ -169,9 +165,7 @@ class AudioOutputDescription:
         assert self.attribute_value
 
         self.audio_output_description = value.decode('utf-8')
-        await connection.device.notify_subscribers(
-            attribute=self.attribute_value, value=value
-        )
+        await connection.device.notify_subscribers(attribute=self.attribute_value)
 
 
 # -----------------------------------------------------------------------------
@@ -203,37 +197,30 @@ class VolumeOffsetControlService(TemplateService):
             VolumeOffsetControlPoint(self.volume_offset_state)
         )
 
-        self.volume_offset_state_characteristic = DelegatedCharacteristicAdapter(
-            Characteristic(
-                uuid=GATT_VOLUME_OFFSET_STATE_CHARACTERISTIC,
-                properties=(
-                    Characteristic.Properties.READ | Characteristic.Properties.NOTIFY
-                ),
-                permissions=Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-                value=CharacteristicValue(read=self.volume_offset_state.on_read),
+        self.volume_offset_state_characteristic = Characteristic(
+            uuid=GATT_VOLUME_OFFSET_STATE_CHARACTERISTIC,
+            properties=(
+                Characteristic.Properties.READ | Characteristic.Properties.NOTIFY
             ),
-            encode=lambda value: bytes(value),
+            permissions=Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
+            value=CharacteristicValue(read=self.volume_offset_state.on_read),
         )
 
-        self.audio_location_characteristic = DelegatedCharacteristicAdapter(
-            Characteristic(
-                uuid=GATT_AUDIO_LOCATION_CHARACTERISTIC,
-                properties=(
-                    Characteristic.Properties.READ
-                    | Characteristic.Properties.NOTIFY
-                    | Characteristic.Properties.WRITE_WITHOUT_RESPONSE
-                ),
-                permissions=(
-                    Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
-                    | Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION
-                ),
-                value=CharacteristicValue(
-                    read=self.audio_location.on_read,
-                    write=self.audio_location.on_write,
-                ),
+        self.audio_location_characteristic = Characteristic(
+            uuid=GATT_AUDIO_LOCATION_CHARACTERISTIC,
+            properties=(
+                Characteristic.Properties.READ
+                | Characteristic.Properties.NOTIFY
+                | Characteristic.Properties.WRITE_WITHOUT_RESPONSE
+            ),
+            permissions=(
+                Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
+                | Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION
+            ),
+            value=CharacteristicValue(
+                read=self.audio_location.on_read,
+                write=self.audio_location.on_write,
             ),
-            encode=lambda value: bytes(value),
-            decode=VocsAudioLocation.from_bytes,
         )
         self.audio_location.attribute_value = self.audio_location_characteristic.value
 
@@ -244,25 +231,22 @@ class VolumeOffsetControlService(TemplateService):
             value=CharacteristicValue(write=self.volume_offset_control_point.on_write),
         )
 
-        self.audio_output_description_characteristic = DelegatedCharacteristicAdapter(
-            Characteristic(
-                uuid=GATT_AUDIO_OUTPUT_DESCRIPTION_CHARACTERISTIC,
-                properties=(
-                    Characteristic.Properties.READ
-                    | Characteristic.Properties.NOTIFY
-                    | Characteristic.Properties.WRITE_WITHOUT_RESPONSE
-                ),
-                permissions=(
-                    Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
-                    | Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION
-                ),
-                value=CharacteristicValue(
-                    read=self.audio_output_description.on_read,
-                    write=self.audio_output_description.on_write,
-                ),
-            )
+        self.audio_output_description_characteristic = Characteristic(
+            uuid=GATT_AUDIO_OUTPUT_DESCRIPTION_CHARACTERISTIC,
+            properties=(
+                Characteristic.Properties.READ
+                | Characteristic.Properties.NOTIFY
+                | Characteristic.Properties.WRITE_WITHOUT_RESPONSE
+            ),
+            permissions=(
+                Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
+                | Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION
+            ),
+            value=CharacteristicValue(
+                read=self.audio_output_description.on_read,
+                write=self.audio_output_description.on_write,
+            ),
         )
-
         self.audio_output_description.attribute_value = (
             self.audio_output_description_characteristic.value
         )
@@ -287,44 +271,29 @@ class VolumeOffsetControlServiceProxy(ProfileServiceProxy):
     def __init__(self, service_proxy: ServiceProxy) -> None:
         self.service_proxy = service_proxy
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
+        self.volume_offset_state = SerializableCharacteristicAdapter(
+            service_proxy.get_required_characteristic_by_uuid(
                 GATT_VOLUME_OFFSET_STATE_CHARACTERISTIC
-            )
-        ):
-            raise InvalidServiceError("Volume Offset State characteristic not found")
-        self.volume_offset_state = DelegatedCharacteristicAdapter(
-            characteristics[0], decode=VolumeOffsetState.from_bytes
+            ),
+            VolumeOffsetState,
         )
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_AUDIO_LOCATION_CHARACTERISTIC
-            )
-        ):
-            raise InvalidServiceError("Audio Location characteristic not found")
         self.audio_location = DelegatedCharacteristicAdapter(
-            characteristics[0],
-            encode=lambda value: bytes(value),
-            decode=VocsAudioLocation.from_bytes,
+            service_proxy.get_required_characteristic_by_uuid(
+                GATT_AUDIO_LOCATION_CHARACTERISTIC
+            ),
+            encode=lambda value: bytes([int(value)]),
+            decode=lambda data: AudioLocation(data[0]),
         )
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
+        self.volume_offset_control_point = (
+            service_proxy.get_required_characteristic_by_uuid(
                 GATT_VOLUME_OFFSET_CONTROL_POINT_CHARACTERISTIC
             )
-        ):
-            raise InvalidServiceError(
-                "Volume Offset Control Point characteristic not found"
-            )
-        self.volume_offset_control_point = characteristics[0]
+        )
 
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
+        self.audio_output_description = UTF8CharacteristicAdapter(
+            service_proxy.get_required_characteristic_by_uuid(
                 GATT_AUDIO_OUTPUT_DESCRIPTION_CHARACTERISTIC
             )
-        ):
-            raise InvalidServiceError(
-                "Audio Output Description characteristic not found"
-            )
-        self.audio_output_description = UTF8CharacteristicAdapter(characteristics[0])
+        )

bumble/sdp.py

@@ -130,7 +130,7 @@ SDP_ATTRIBUTE_ID_NAMES = {
 SDP_PUBLIC_BROWSE_ROOT = core.UUID.from_16_bits(0x1002, 'PublicBrowseRoot')
 
 # To be used in searches where an attribute ID list allows a range to be specified
-SDP_ALL_ATTRIBUTES_RANGE = (0x0000, 0xFFFF)
+SDP_ALL_ATTRIBUTES_RANGE = (0x0000FFFF, 4)  # Express this as tuple so we can convey the desired encoding size
 
 # fmt: on
 # pylint: enable=line-too-long

bumble/smp.py

@@ -1326,7 +1326,7 @@ class Session:
         self.connection.abort_on('disconnection', self.on_pairing())
 
     def on_connection_encryption_change(self) -> None:
-        if self.connection.is_encrypted and not self.completed:
+        if self.connection.is_encrypted:
             if self.is_responder:
                 # The responder distributes its keys first, the initiator later
                 self.distribute_keys()

bumble/utils.py

@@ -447,7 +447,7 @@ def deprecated(msg: str):
     def wrapper(function):
         @functools.wraps(function)
         def inner(*args, **kwargs):
-            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            warnings.warn(msg, DeprecationWarning)
             return function(*args, **kwargs)
 
         return inner
@@ -464,7 +464,7 @@ def experimental(msg: str):
     def wrapper(function):
         @functools.wraps(function)
         def inner(*args, **kwargs):
-            warnings.warn(msg, FutureWarning, stacklevel=2)
+            warnings.warn(msg, FutureWarning)
             return function(*args, **kwargs)
 
         return inner

docs/mkdocs/mkdocs.yml

@@ -39,12 +39,14 @@ nav:
   - Drivers:
     - drivers/index.md
     - Realtek: drivers/realtek.md
+    - Intel: drivers/intel.md
   - API:
     - Guide: api/guide.md
     - Examples: api/examples.md
     - Reference: api/reference.md
   - Apps & Tools:
     - apps_and_tools/index.md
+    - Auracast: apps_and_tools/auracast.md
     - Console: apps_and_tools/console.md
     - Bench: apps_and_tools/bench.md
     - Speaker: apps_and_tools/speaker.md
@@ -108,8 +110,8 @@ markdown_extensions:
   - pymdownx.details
   - pymdownx.superfences
   - pymdownx.emoji:
-      emoji_index: !!python/name:materialx.emoji.twemoji
-      emoji_generator: !!python/name:materialx.emoji.to_svg
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg
   - pymdownx.tabbed:
       alternate_style: true
   - codehilite:

docs/mkdocs/src/apps_and_tools/index.md

@@ -4,12 +4,13 @@ APPS & TOOLS
 Included in the project are a few apps and tools, built on top of the core libraries.
 These include:
 
-  * [Console](console.md) - an interactive text-based console
-  * [Bench](bench.md) - Speed and Latency benchmarking between two devices (LE and Classic)
-  * [Pair](pair.md) - Pair/bond two devices (LE and Classic)
-  * [Unbond](unbond.md) - Remove a previously established bond
-  * [HCI Bridge](hci_bridge.md) - a HCI transport bridge to connect two HCI transports and filter/snoop the HCI packets
-  * [Golden Gate Bridge](gg_bridge.md) - a bridge between GATT and UDP to use with the Golden Gate "stack tool"
-  * [Show](show.md) - Parse a file with HCI packets and print the details of each packet in a human readable form
+  * [Auracast](auracast.md) - Commands to broadcast, receive and/or control LE Audio.
+  * [Console](console.md) - An interactive text-based console.
+  * [Bench](bench.md) - Speed and Latency benchmarking between two devices (LE and Classic).
+  * [Pair](pair.md) - Pair/bond two devices (LE and Classic).
+  * [Unbond](unbond.md) - Remove a previously established bond.
+  * [HCI Bridge](hci_bridge.md) - An HCI transport bridge to connect two HCI transports and filter/snoop the HCI packets.
+  * [Golden Gate Bridge](gg_bridge.md) - Bridge between GATT and UDP to use with the Golden Gate "stack tool".
+  * [Show](show.md) - Parse a file with HCI packets and print the details of each packet in a human readable form.
   * [Speaker](speaker.md) - Virtual Bluetooth speaker, with a command line and browser-based UI.
   * [Link Relay](link_relay.md) - WebSocket relay for virtual RemoteLink instances to communicate with each other.

docs/mkdocs/src/getting_started.md

@@ -9,9 +9,9 @@ for your platform.
 Throughout the documentation, when shell commands are shown, it is assumed that you can
 invoke Python as
 ```
-$ python
+$ python3
 ```
-If invoking python is different on your platform (it may be `python3` for example, or just `py` or `py.exe`),
+If invoking python is different on your platform (it may be `python` for example, or just `py` or `py.exe`),
 adjust accordingly.
 
 You may be simply using Bumble as a module for your own application or as a dependency to your own
@@ -30,12 +30,18 @@ manager, or from source.
     python environment, or in a virtual environment, such as a `venv`, `pyenv` or `conda` environment.
     See the [Python Environments page](development/python_environments.md) page for details.
 
+### Install from PyPI
+
+```
+$ python3 -m pip install bumble
+```
+
 ### Install From Source
 
 Install with `pip`. Run in a command shell in the directory where you downloaded the source
 distribution
 ```
-$ python -m pip install -e .
+$ python3 -m pip install -e .
 ```
 
 ### Install from GitHub
@@ -44,21 +50,21 @@ You can install directly from GitHub without first downloading the repo.
 
 Install the latest commit from the main branch with `pip`:
 ```
-$ python -m pip install git+https://github.com/google/bumble.git
+$ python3 -m pip install git+https://github.com/google/bumble.git
 ```
 
 You can specify a specific tag.
 
 Install tag `v0.0.1` with `pip`:
 ```
-$ python -m pip install git+https://github.com/google/bumble.git@v0.0.1
+$ python3 -m pip install git+https://github.com/google/bumble.git@v0.0.1
 ```
 
 You can also specify a specific commit.
 
 Install commit `27c0551` with `pip`:
 ```
-$ python -m pip install git+https://github.com/google/bumble.git@27c0551
+$ python3 -m pip install git+https://github.com/google/bumble.git@27c0551
 ```
 
 # Working On The Bumble Code
@@ -78,21 +84,21 @@ directory of the project.
 
 ```bash
 $ export PYTHONPATH=.
-$ python apps/console.py serial:/dev/tty.usbmodem0006839912171
+$ python3 apps/console.py serial:/dev/tty.usbmodem0006839912171
 ```
 
 or running an example, with the working directory set to the `examples` subdirectory
 ```bash
 $ cd examples
 $ export PYTHONPATH=..
-$ python run_scanner.py usb:0
+$ python3 run_scanner.py usb:0
 ```
 
 Or course, `export PYTHONPATH` only needs to be invoked once, not before each app/script execution.
 
 Setting `PYTHONPATH` locally with each command would look something like:
 ```
-$ PYTHONPATH=. python examples/run_advertiser.py examples/device1.json serial:/dev/tty.usbmodem0006839912171
+$ PYTHONPATH=. python3 examples/run_advertiser.py examples/device1.json serial:/dev/tty.usbmodem0006839912171
 ```
 
 # Where To Go Next

docs/mkdocs/src/platforms/android.md

@@ -35,11 +35,11 @@ the command line.
     visit [this Android Studio user guide page](https://developer.android.com/studio/run/emulator-commandline)
 
 The `-packet-streamer-endpoint <endpoint>` command line option may be used to enable
-Bluetooth emulation and tell the emulator which virtual controller to connect to. 
+Bluetooth emulation and tell the emulator which virtual controller to connect to.
 
 ## Connecting to Netsim
 
-If the emulator doesn't have Bluetooth emulation enabled by default, use the 
+If the emulator doesn't have Bluetooth emulation enabled by default, use the
 `-packet-streamer-endpoint default` option to tell it to connect to Netsim.
 If Netsim is not running, the emulator will start it automatically.
 
@@ -60,17 +60,17 @@ the Bumble `android-netsim` transport in `host` mode (the default).
 
 !!! example "Run the example GATT server connected to the emulator via Netsim"
     ``` shell
-    $ python run_gatt_server.py device1.json android-netsim
+    $ python3 run_gatt_server.py device1.json android-netsim
     ```
 
 By default, the Bumble `android-netsim` transport will try to automatically discover
 the port number on which the netsim process is exposing its gRPC server interface. If
-that discovery process fails, or if you want to specify the interface manually, you 
+that discovery process fails, or if you want to specify the interface manually, you
 can pass a `hostname` and `port` as parameters to the transport, as: `android-netsim:<host>:<port>`.
 
 !!! example "Run the example GATT server connected to the emulator via Netsim on a localhost, port 8877"
     ``` shell
-    $ python run_gatt_server.py device1.json android-netsim:localhost:8877
+    $ python3 run_gatt_server.py device1.json android-netsim:localhost:8877
     ```
 
 ### Multiple Instances
@@ -84,7 +84,7 @@ For example: `android-netsim:localhost:8877,name=bumble1`
 This is an advanced use case, which may not be officially supported, but should work in recent
 versions of the emulator.
 
-The first step is to run the Bumble HCI bridge, specifying netsim as the "host" end of the 
+The first step is to run the Bumble HCI bridge, specifying netsim as the "host" end of the
 bridge, and another controller (typically a USB Bluetooth dongle, but any other supported
 transport can work as well) as the "controller" end of the bridge.
 

examples/cs_initiator.json

@@ -1,9 +0,0 @@
-{
-    "name": "Bumble CS Initiator",
-    "address": "F0:F1:F2:F3:F4:F5",
-    "advertising_interval": 100,
-    "keystore": "JsonKeyStore",
-    "irk": "865F81FF5A8B486EAAE29A27AD9F77DC",
-    "identity_address_type": 1,
-    "channel_sounding_enabled": true
-}

examples/cs_reflector.json

@@ -1,9 +0,0 @@
-{
-    "name": "Bumble CS Reflector",
-    "address": "F0:F1:F2:F3:F4:F6",
-    "advertising_interval": 100,
-    "keystore": "JsonKeyStore",
-    "irk": "0c7d74db03a1c98e7be691f76141d53d",
-    "identity_address_type": 1,
-    "channel_sounding_enabled": true
-}

examples/run_channel_sounding.py

@@ -1,154 +0,0 @@
-# Copyright 2024 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-
-import asyncio
-import logging
-import sys
-import os
-import functools
-
-from bumble import core
-from bumble import hci
-from bumble.device import Connection, Device, ChannelSoundingCapabilities
-from bumble.transport import open_transport_or_link
-
-# From https://cs.android.com/android/platform/superproject/main/+/main:packages/modules/Bluetooth/system/gd/hci/distance_measurement_manager.cc.
-CS_TONE_ANTENNA_CONFIG_MAPPING_TABLE = [
-    [0, 4, 5, 6],
-    [1, 7, 7, 7],
-    [2, 7, 7, 7],
-    [3, 7, 7, 7],
-]
-CS_PREFERRED_PEER_ANTENNA_MAPPING_TABLE = [1, 1, 1, 1, 3, 7, 15, 3]
-CS_ANTENNA_PERMUTATION_ARRAY = [
-    [1, 2, 3, 4],
-    [2, 1, 3, 4],
-    [1, 3, 2, 4],
-    [3, 1, 2, 4],
-    [3, 2, 1, 4],
-    [2, 3, 1, 4],
-    [1, 2, 4, 3],
-    [2, 1, 4, 3],
-    [1, 4, 2, 3],
-    [4, 1, 2, 3],
-    [4, 2, 1, 3],
-    [2, 4, 1, 3],
-    [1, 4, 3, 2],
-    [4, 1, 3, 2],
-    [1, 3, 4, 2],
-    [3, 1, 4, 2],
-    [3, 4, 1, 2],
-    [4, 3, 1, 2],
-    [4, 2, 3, 1],
-    [2, 4, 3, 1],
-    [4, 3, 2, 1],
-    [3, 4, 2, 1],
-    [3, 2, 4, 1],
-    [2, 3, 4, 1],
-]
-
-
-# -----------------------------------------------------------------------------
-async def main() -> None:
-    if len(sys.argv) < 3:
-        print(
-            'Usage: run_channel_sounding.py <config-file> <transport-spec-for-device>'
-            '[target_address](If missing, run as reflector)'
-        )
-        print('example: run_channel_sounding.py cs_reflector.json usb:0')
-        print(
-            'example: run_channel_sounding.py cs_initiator.json usb:0 F0:F1:F2:F3:F4:F5'
-        )
-        return
-
-    print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
-        print('<<< connected')
-
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
-        await device.power_on()
-        assert (local_cs_capabilities := device.cs_capabilities)
-
-        if len(sys.argv) == 3:
-            print('<<< Start Advertising')
-            await device.start_advertising(
-                own_address_type=hci.OwnAddressType.RANDOM, auto_restart=True
-            )
-
-            def on_cs_capabilities(
-                connection: Connection, capabilities: ChannelSoundingCapabilities
-            ):
-                del capabilities
-                print('<<< Set CS Settings')
-                asyncio.create_task(device.set_default_cs_settings(connection))
-
-            device.on(
-                'connection',
-                lambda connection: connection.on(
-                    'channel_sounding_capabilities',
-                    functools.partial(on_cs_capabilities, connection),
-                ),
-            )
-        else:
-            target_address = hci.Address(sys.argv[3])
-
-            print(f'<<< Connecting to {target_address}')
-            connection = await device.connect(
-                target_address, transport=core.BT_LE_TRANSPORT
-            )
-            print('<<< ACL Connected')
-            if not (await device.get_long_term_key(connection.handle, b'', 0)):
-                print('<<< No bond, start pairing')
-                await connection.pair()
-                print('<<< Pairing complete')
-
-            print('<<< Encrypting Connection')
-            await connection.encrypt()
-
-            print('<<< Getting remote CS Capabilities...')
-            remote_capabilities = await device.get_remote_cs_capabilities(connection)
-            print('<<< Set CS Settings...')
-            await device.set_default_cs_settings(connection)
-            print('<<< Set CS Config...')
-            config = await device.create_cs_config(connection)
-            print('<<< Enable CS Security...')
-            await device.enable_cs_security(connection)
-            tone_antenna_config_selection = CS_TONE_ANTENNA_CONFIG_MAPPING_TABLE[
-                local_cs_capabilities.num_antennas_supported - 1
-            ][remote_capabilities.num_antennas_supported - 1]
-            print('<<< Set CS Procedure Parameters...')
-            await device.set_cs_procedure_parameters(
-                connection=connection,
-                config=config,
-                tone_antenna_config_selection=tone_antenna_config_selection,
-                preferred_peer_antenna=CS_PREFERRED_PEER_ANTENNA_MAPPING_TABLE[
-                    tone_antenna_config_selection
-                ],
-            )
-            print('<<< Enable CS Procedure...')
-            await device.enable_cs_procedure(connection=connection, config=config)
-
-        await hci_transport.source.terminated
-
-
-# -----------------------------------------------------------------------------
-logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'DEBUG').upper())
-asyncio.run(main())

examples/run_gatt_with_adapters.py

@@ -25,7 +25,7 @@ import struct
 import sys
 from typing import Any, List, Union
 
-from bumble.device import Connection, Device, Peer
+from bumble.device import Device, Peer
 from bumble import transport
 from bumble import gatt
 from bumble import hci
@@ -82,19 +82,19 @@ async def client(device: Device, address: hci.Address) -> None:
     for index in range(1, 9):
         characteristics.append(
             service.get_characteristics_by_uuid(
-                CHARACTERISTIC_UUID_BASE + f"{index:02X}"
+                core.UUID(CHARACTERISTIC_UUID_BASE + f"{index:02X}")
             )[0]
         )
 
     # Read all characteristics as raw bytes.
     for characteristic in characteristics:
         value = await characteristic.read_value()
-        print(f"### {characteristic} = {value} ({value.hex()})")
+        print(f"### {characteristic} = {value!r} ({value.hex()})")
 
     # Static characteristic with a bytes value.
     c1 = characteristics[0]
     c1_value = await c1.read_value()
-    print(f"@@@ C1 {c1} value = {c1_value} (type={type(c1_value)})")
+    print(f"@@@ C1 {c1} value = {c1_value!r} (type={type(c1_value)})")
     await c1.write_value("happy π day".encode("utf-8"))
 
     # Static characteristic with a string value.
@@ -136,7 +136,7 @@ async def client(device: Device, address: hci.Address) -> None:
     # Dynamic characteristic with a bytes value.
     c7 = characteristics[6]
     c7_value = await c7.read_value()
-    print(f"@@@ C7 {c7} value = {c7_value} (type={type(c7_value)})")
+    print(f"@@@ C7 {c7} value = {c7_value!r} (type={type(c7_value)})")
     await c7.write_value(bytes.fromhex("01020304"))
 
     # Dynamic characteristic with a string value.

examples/run_vcp_renderer.py

@@ -42,7 +42,7 @@ from bumble.profiles.bap import (
 from bumble.profiles.pacs import PacRecord, PublishedAudioCapabilitiesService
 from bumble.profiles.cap import CommonAudioServiceService
 from bumble.profiles.csip import CoordinatedSetIdentificationService, SirkType
-from bumble.profiles.vcp import VolumeControlService
+from bumble.profiles.vcs import VolumeControlService
 
 from bumble.transport import open_transport_or_link
 
@@ -117,13 +117,17 @@ async def main() -> None:
 
         ws: Optional[websockets.WebSocketServerProtocol] = None
 
-        def on_volume_state(volume_setting: int, muted: int, change_counter: int):
+        def on_volume_state_change():
             if ws:
                 asyncio.create_task(
-                    ws.send(dumps_volume_state(volume_setting, muted, change_counter))
+                    ws.send(
+                        dumps_volume_state(
+                            vcs.volume_setting, vcs.muted, vcs.change_counter
+                        )
+                    )
                 )
 
-        vcs.on('volume_state', on_volume_state)
+        vcs.on('volume_state_change', on_volume_state_change)
 
         advertising_data = (
             bytes(
@@ -170,16 +174,10 @@ async def main() -> None:
             ws = websocket
             async for message in websocket:
                 volume_state = json.loads(message)
-                vcs.volume_state_bytes = bytes(
-                    [
-                        volume_state['volume_setting'],
-                        volume_state['muted'],
-                        volume_state['change_counter'],
-                    ]
-                )
-                await device.notify_subscribers(
-                    vcs.volume_state, vcs.volume_state_bytes
-                )
+                vcs.volume_setting = volume_state['volume_setting']
+                vcs.muted = volume_state['muted']
+                vcs.change_counter = volume_state['change_counter']
+                await device.notify_subscribers(vcs.volume_state)
             ws = None
 
         await websockets.serve(serve, 'localhost', 8989)

pyproject.toml

@@ -61,15 +61,17 @@ avatar = [
 ]
 pandora = ["bt-test-interfaces >= 0.0.6"]
 documentation = [
-    "mkdocs >= 1.4.0",
-    "mkdocs-material >= 8.5.6",
-    "mkdocstrings[python] >= 0.19.0",
+    "mkdocs >= 1.6.0",
+    "mkdocs-material >= 9.6",
+    "mkdocstrings[python] >= 0.27.0",
 ]
-lc3 = [
-    "lc3 @ git+https://github.com/google/liblc3.git",
+auracast = [
+    "lc3py ; python_version>='3.10' and platform_system=='Linux' and platform_machine=='x86_64'",
+    "sounddevice >= 0.5.1",
 ]
 
 [project.scripts]
+bumble-auracast = "bumble.apps.auracast:main"
 bumble-ble-rpa-tool = "bumble.apps.ble_rpa_tool:main"
 bumble-console = "bumble.apps.console:main"
 bumble-controller-info = "bumble.apps.controller_info:main"
@@ -190,6 +192,10 @@ ignore_missing_imports = true
 module = "serial_asyncio.*"
 ignore_missing_imports = true
 
+[[tool.mypy.overrides]]
+module = "sounddevice.*"
+ignore_missing_imports = true
+
 [[tool.mypy.overrides]]
 module = "usb.*"
 ignore_missing_imports = true

rust/README.md

@@ -69,68 +69,3 @@ To regenerate the assigned number tables based on the Python codebase:
 ```
 PYTHONPATH=.. cargo run --bin gen-assigned-numbers --features dev-tools
 ```
-
-## HCI packets
-
-Sending a command packet from a device is composed to of two major steps.
-There are more generalized ways of dealing with packets in other scenarios.
-
-### Construct the command
-Pick a command from `src/internal/hci/packets.pdl` and construct its associated "builder" struct.
-
-```rust
-// The "LE Set Scan Enable" command can be found in the Core Bluetooth Spec.
-// It can also be found in `packets.pdl` as `packet LeSetScanEnable : Command`
-fn main() {
-    let device = init_device_as_desired();
-    
-    let le_set_scan_enable_command_builder = LeSetScanEnableBuilder {
-        filter_duplicates: Enable::Disabled,
-        le_scan_enable: Enable::Enabled,
-    };
-}
-```
-
-### Send the command and interpret the event response
-Send the command from an initialized device, and then receive the response.
-
-```rust
-fn main() {
-    // ...
-    
-    // `check_result` to false to receive the event response even if the controller returns a failure code
-    let event = device.send_command(le_set_scan_enable_command_builder.into(), /*check_result*/ false);
-    // Coerce the event into the expected format. A `Command` should have an associated event response
-    // "<command name>Complete".
-    let le_set_scan_enable_complete_event: LeSetScanEnableComplete = event.try_into().unwrap();
-}
-```
-
-### Generic packet handling
-At the very least, you should expect to at least know _which_ kind of base packet you are dealing with. Base packets in 
-`packets.pdl` can be identified because they do not extend any other packet. They are easily found with the regex:
-`^packet [^:]* \{`. For Bluetooth LE (BLE) HCI, one should find some kind of header preceding the packet with the purpose of
-packet disambiguation. We do some of that disambiguation for H4 BLE packets using the `WithPacketHeader` trait at `internal/hci/mod.rs`.
-
-Say you've identified a series of bytes that are certainly an `Acl` packet. They can be parsed using the `Acl` struct.
-```rust
-fn main() {
-    let bytes = bytes_that_are_certainly_acl();
-    let acl_packet = Acl::parse(bytes).unwrap();
-}
-```
-
-Since you don't yet know what kind of `Acl` packet it is, you need to specialize it and then handle the various
-potential cases.
-```rust
-fn main() {
-    // ...
-    match acl_packet.specialize() {
-        Payload(bytes) => do_something(bytes),
-        None => do_something_else(),
-    }
-}
-```
-
-Some packets may yet further embed other packets, in which case you may need to further specialize until no more
-specialization is needed.

rust/examples/broadcast.rs

@@ -25,6 +25,7 @@ use clap::Parser as _;
 use pyo3::PyResult;
 use rand::Rng;
 use std::path;
+
 #[pyo3_asyncio::tokio::main]
 async fn main() -> PyResult<()> {
     env_logger::builder()

rust/pytests/wrapper/hci.rs

@@ -28,7 +28,7 @@ use bumble::wrapper::{
 };
 use pyo3::{
     exceptions::PyException,
-    FromPyObject, IntoPy, Python, {PyErr, PyResult},
+    {PyErr, PyResult},
 };
 
 #[pyo3_asyncio::tokio::test]
@@ -78,28 +78,6 @@ async fn test_hci_roundtrip_success_and_failure() -> PyResult<()> {
     Ok(())
 }
 
-#[pyo3_asyncio::tokio::test]
-fn valid_error_code_extraction_succeeds() -> PyResult<()> {
-    let error_code = Python::with_gil(|py| {
-        let python_error_code_success = 0x00_u8.into_py(py);
-        ErrorCode::extract(python_error_code_success.as_ref(py))
-    })?;
-
-    assert_eq!(ErrorCode::Success, error_code);
-    Ok(())
-}
-
-#[pyo3_asyncio::tokio::test]
-fn invalid_error_code_extraction_fails() -> PyResult<()> {
-    let failed_extraction = Python::with_gil(|py| {
-        let python_invalid_error_code = 0xFE_u8.into_py(py);
-        ErrorCode::extract(python_invalid_error_code.as_ref(py))
-    });
-
-    assert!(failed_extraction.is_err());
-    Ok(())
-}
-
 async fn create_local_device(address: Address) -> PyResult<Device> {
     let link = Link::new_local_link()?;
     let controller = Controller::new("C1", None, None, Some(link), Some(address.clone())).await?;

rust/src/wrapper/hci.rs

@@ -178,11 +178,7 @@ impl IntoPy<PyObject> for AddressType {
 
 impl<'source> FromPyObject<'source> for ErrorCode {
     fn extract(ob: &'source PyAny) -> PyResult<Self> {
-        // Bumble represents error codes simply as a single-byte number (in Rust, u8)
-        let value: u8 = ob.extract()?;
-        ErrorCode::try_from(value).map_err(|b| {
-            PyErr::new::<PyException, _>(format!("Failed to map {b} to an error code"))
-        })
+        ob.extract()
     }
 }
 

tests/aics_test.py

@@ -33,7 +33,7 @@ from bumble.profiles.aics import (
     AudioInputControlPointOpCode,
     ErrorCode,
 )
-from bumble.profiles.vcp import VolumeControlService, VolumeControlServiceProxy
+from bumble.profiles.vcs import VolumeControlService, VolumeControlServiceProxy
 
 from .test_utils import TwoDevices
 

tests/device_test.py

@@ -50,7 +50,12 @@ from bumble.hci import (
     HCI_Error,
     HCI_Packet,
 )
-from bumble import gatt
+from bumble.gatt import (
+    GATT_GENERIC_ACCESS_SERVICE,
+    GATT_CHARACTERISTIC_ATTRIBUTE_TYPE,
+    GATT_DEVICE_NAME_CHARACTERISTIC,
+    GATT_APPEARANCE_CHARACTERISTIC,
+)
 
 from .test_utils import TwoDevices, async_barrier
 
@@ -587,54 +592,32 @@ async def test_power_on_default_static_address_should_not_be_any():
 
 
 # -----------------------------------------------------------------------------
-def test_gatt_services_with_gas_and_gatt():
+def test_gatt_services_with_gas():
     device = Device(host=Host(None, None))
 
-    # there should be 2 service, 5 chars, and 1 descriptors, therefore 13 attributes
-    assert len(device.gatt_server.attributes) == 13
-    assert device.gatt_server.attributes[0].uuid == gatt.GATT_GENERIC_ACCESS_SERVICE
-    assert (
-        device.gatt_server.attributes[1].type == gatt.GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
-    )
-    assert device.gatt_server.attributes[2].uuid == gatt.GATT_DEVICE_NAME_CHARACTERISTIC
-    assert (
-        device.gatt_server.attributes[3].type == gatt.GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
-    )
-    assert device.gatt_server.attributes[4].uuid == gatt.GATT_APPEARANCE_CHARACTERISTIC
+    # there should be one service and two chars, therefore 5 attributes
+    assert len(device.gatt_server.attributes) == 5
+    assert device.gatt_server.attributes[0].uuid == GATT_GENERIC_ACCESS_SERVICE
+    assert device.gatt_server.attributes[1].type == GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
+    assert device.gatt_server.attributes[2].uuid == GATT_DEVICE_NAME_CHARACTERISTIC
+    assert device.gatt_server.attributes[3].type == GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
+    assert device.gatt_server.attributes[4].uuid == GATT_APPEARANCE_CHARACTERISTIC
 
-    assert device.gatt_server.attributes[5].uuid == gatt.GATT_GENERIC_ATTRIBUTE_SERVICE
-    assert (
-        device.gatt_server.attributes[6].type == gatt.GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
-    )
-    assert (
-        device.gatt_server.attributes[7].uuid
-        == gatt.GATT_SERVICE_CHANGED_CHARACTERISTIC
-    )
-    assert (
-        device.gatt_server.attributes[8].type
-        == gatt.GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR
-    )
-    assert (
-        device.gatt_server.attributes[9].type == gatt.GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
-    )
-    assert (
-        device.gatt_server.attributes[10].uuid
-        == gatt.GATT_CLIENT_SUPPORTED_FEATURES_CHARACTERISTIC
-    )
-    assert (
-        device.gatt_server.attributes[11].type
-        == gatt.GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
-    )
-    assert (
-        device.gatt_server.attributes[12].uuid == gatt.GATT_DATABASE_HASH_CHARACTERISTIC
-    )
+
+# -----------------------------------------------------------------------------
+def test_gatt_services_without_gas():
+    device = Device(host=Host(None, None), generic_access_service=False)
+
+    # there should be no services
+    assert len(device.gatt_server.attributes) == 0
 
 
 # -----------------------------------------------------------------------------
 async def run_test_device():
     await test_device_connect_parallel()
     await test_flush()
-    await test_gatt_services_with_gas_and_gatt()
+    await test_gatt_services_with_gas()
+    await test_gatt_services_without_gas()
 
 
 # -----------------------------------------------------------------------------

tests/gatt_service_test.py

@@ -1,140 +0,0 @@
-# Copyright 2021-2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-
-from . import test_utils
-
-from bumble import device
-from bumble import gatt
-from bumble.profiles import gatt_service
-
-
-# -----------------------------------------------------------------------------
-async def test_database_hash():
-    devices = await test_utils.TwoDevices.create_with_connection()
-    devices[0].gatt_server.services.clear()
-    devices[0].gatt_server.attributes.clear()
-    devices[0].gatt_server.attributes_by_handle.clear()
-    devices[0].add_service(
-        gatt.Service(
-            gatt.GATT_GENERIC_ACCESS_SERVICE,
-            characteristics=[
-                gatt.Characteristic(
-                    gatt.GATT_DEVICE_NAME_CHARACTERISTIC,
-                    (
-                        gatt.Characteristic.Properties.READ
-                        | gatt.Characteristic.Properties.WRITE
-                    ),
-                    gatt.Characteristic.Permissions.READ_REQUIRES_AUTHENTICATION,
-                ),
-                gatt.Characteristic(
-                    gatt.GATT_APPEARANCE_CHARACTERISTIC,
-                    gatt.Characteristic.Properties.READ,
-                    gatt.Characteristic.Permissions.READ_REQUIRES_AUTHENTICATION,
-                ),
-            ],
-        )
-    )
-    devices[0].add_service(
-        gatt_service.GenericAttributeProfileService(
-            server_supported_features=None,
-            database_hash_enabled=True,
-            service_change_enabled=True,
-        )
-    )
-    devices[0].gatt_server.add_attribute(
-        gatt.Service(gatt.GATT_GLUCOSE_SERVICE, characteristics=[])
-    )
-    # There is a special attribute order in the spec, so we need to add attribute one by
-    # one here.
-    battery_service = gatt.Service(
-        gatt.GATT_BATTERY_SERVICE,
-        characteristics=[
-            gatt.Characteristic(
-                gatt.GATT_BATTERY_LEVEL_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.READ,
-                permissions=gatt.Characteristic.Permissions.READ_REQUIRES_AUTHENTICATION,
-            )
-        ],
-        primary=False,
-    )
-    battery_service.handle = 0x0014
-    battery_service.end_group_handle = 0x0016
-    devices[0].gatt_server.add_attribute(
-        gatt.IncludedServiceDeclaration(battery_service)
-    )
-    c = gatt.Characteristic(
-        '2A18',
-        properties=(
-            gatt.Characteristic.Properties.READ
-            | gatt.Characteristic.Properties.INDICATE
-            | gatt.Characteristic.Properties.EXTENDED_PROPERTIES
-        ),
-        permissions=gatt.Characteristic.Permissions.READ_REQUIRES_AUTHENTICATION,
-    )
-    devices[0].gatt_server.add_attribute(
-        gatt.CharacteristicDeclaration(c, devices[0].gatt_server.next_handle() + 1)
-    )
-    devices[0].gatt_server.add_attribute(c)
-    devices[0].gatt_server.add_attribute(
-        gatt.Descriptor(
-            gatt.GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR,
-            gatt.Descriptor.Permissions.READ_REQUIRES_AUTHENTICATION,
-            b'\x02\x00',
-        ),
-    )
-    devices[0].gatt_server.add_attribute(
-        gatt.Descriptor(
-            gatt.GATT_CHARACTERISTIC_EXTENDED_PROPERTIES_DESCRIPTOR,
-            gatt.Descriptor.Permissions.READ_REQUIRES_AUTHENTICATION,
-            b'\x00\x00',
-        ),
-    )
-    devices[0].add_service(battery_service)
-
-    peer = device.Peer(devices.connections[1])
-    client = await peer.discover_service_and_create_proxy(
-        gatt_service.GenericAttributeProfileServiceProxy
-    )
-    assert client.database_hash_characteristic
-    assert await client.database_hash_characteristic.read_value() == bytes.fromhex(
-        'F1CA2D48ECF58BAC8A8830BBB9FBA990'
-    )
-
-
-# -----------------------------------------------------------------------------
-async def test_service_changed():
-    devices = await test_utils.TwoDevices.create_with_connection()
-    assert (service := devices[0].gatt_service)
-
-    peer = device.Peer(devices.connections[1])
-    assert (
-        client := await peer.discover_service_and_create_proxy(
-            gatt_service.GenericAttributeProfileServiceProxy
-        )
-    )
-    assert client.service_changed_characteristic
-    indications = []
-    await client.service_changed_characteristic.subscribe(
-        indications.append, prefer_notify=False
-    )
-    await devices[0].indicate_subscribers(
-        service.service_changed_characteristic, b'1234'
-    )
-    await test_utils.async_barrier()
-    assert indications[0] == b'1234'

tests/gatt_test.py

@@ -957,12 +957,11 @@ async def test_discover_all():
     peer = Peer(connection)
 
     await peer.discover_all()
-    assert len(peer.gatt_client.services) == 4
-    # service 1800 and 1801 get added automatically
+    assert len(peer.gatt_client.services) == 3
+    # service 1800 gets added automatically
     assert peer.gatt_client.services[0].uuid == UUID('1800')
-    assert peer.gatt_client.services[1].uuid == UUID('1801')
-    assert peer.gatt_client.services[2].uuid == service1.uuid
-    assert peer.gatt_client.services[3].uuid == service2.uuid
+    assert peer.gatt_client.services[1].uuid == service1.uuid
+    assert peer.gatt_client.services[2].uuid == service2.uuid
     s = peer.get_services_by_uuid(service1.uuid)
     assert len(s) == 1
     assert len(s[0].characteristics) == 2
@@ -1085,18 +1084,10 @@ CharacteristicDeclaration(handle=0x0002, value_handle=0x0003, uuid=UUID-16:2A00
 Characteristic(handle=0x0003, end=0x0003, uuid=UUID-16:2A00 (Device Name), READ)
 CharacteristicDeclaration(handle=0x0004, value_handle=0x0005, uuid=UUID-16:2A01 (Appearance), READ)
 Characteristic(handle=0x0005, end=0x0005, uuid=UUID-16:2A01 (Appearance), READ)
-Service(handle=0x0006, end=0x000D, uuid=UUID-16:1801 (Generic Attribute))
-CharacteristicDeclaration(handle=0x0007, value_handle=0x0008, uuid=UUID-16:2A05 (Service Changed), INDICATE)
-Characteristic(handle=0x0008, end=0x0009, uuid=UUID-16:2A05 (Service Changed), INDICATE)
-Descriptor(handle=0x0009, type=UUID-16:2902 (Client Characteristic Configuration), value=0000)
-CharacteristicDeclaration(handle=0x000A, value_handle=0x000B, uuid=UUID-16:2B29 (Client Supported Features), READ|WRITE)
-Characteristic(handle=0x000B, end=0x000B, uuid=UUID-16:2B29 (Client Supported Features), READ|WRITE)
-CharacteristicDeclaration(handle=0x000C, value_handle=0x000D, uuid=UUID-16:2B2A (Database Hash), READ)
-Characteristic(handle=0x000D, end=0x000D, uuid=UUID-16:2B2A (Database Hash), READ)
-Service(handle=0x000E, end=0x0011, uuid=3A657F47-D34F-46B3-B1EC-698E29B6B829)
-CharacteristicDeclaration(handle=0x000F, value_handle=0x0010, uuid=FDB159DB-036C-49E3-B3DB-6325AC750806, READ|WRITE|NOTIFY)
-Characteristic(handle=0x0010, end=0x0011, uuid=FDB159DB-036C-49E3-B3DB-6325AC750806, READ|WRITE|NOTIFY)
-Descriptor(handle=0x0011, type=UUID-16:2902 (Client Characteristic Configuration), value=0000)"""
+Service(handle=0x0006, end=0x0009, uuid=3A657F47-D34F-46B3-B1EC-698E29B6B829)
+CharacteristicDeclaration(handle=0x0007, value_handle=0x0008, uuid=FDB159DB-036C-49E3-B3DB-6325AC750806, READ|WRITE|NOTIFY)
+Characteristic(handle=0x0008, end=0x0009, uuid=FDB159DB-036C-49E3-B3DB-6325AC750806, READ|WRITE|NOTIFY)
+Descriptor(handle=0x0009, type=UUID-16:2902 (Client Characteristic Configuration), value=0000)"""
     )
 
 

tests/import_test.py

@@ -53,7 +53,7 @@ def test_import():
         le_audio,
         pacs,
         pbp,
-        vcp,
+        vcs,
     )
 
     assert att
@@ -87,7 +87,7 @@ def test_import():
     assert le_audio
     assert pacs
     assert pbp
-    assert vcp
+    assert vcs
 
 
 # -----------------------------------------------------------------------------

tests/vcp_test.py

@@ -20,7 +20,7 @@ import pytest_asyncio
 import logging
 
 from bumble import device
-from bumble.profiles import vcp
+from bumble.profiles import vcs
 from .test_utils import TwoDevices
 
 # -----------------------------------------------------------------------------
@@ -34,7 +34,7 @@ logger = logging.getLogger(__name__)
 async def vcp_client():
     devices = TwoDevices()
     devices[0].add_service(
-        vcp.VolumeControlService(volume_setting=32, muted=1, volume_flags=1)
+        vcs.VolumeControlService(volume_setting=32, muted=1, volume_flags=1)
     )
 
     await devices.setup_connection()
@@ -48,76 +48,76 @@ async def vcp_client():
 
     peer = device.Peer(devices.connections[1])
     vcp_client = await peer.discover_service_and_create_proxy(
-        vcp.VolumeControlServiceProxy
+        vcs.VolumeControlServiceProxy
     )
     yield vcp_client
 
 
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
-async def test_init_service(vcp_client: vcp.VolumeControlServiceProxy):
+async def test_init_service(vcp_client: vcs.VolumeControlServiceProxy):
     assert (await vcp_client.volume_flags.read_value()) == 1
-    assert (await vcp_client.volume_state.read_value()) == (32, 1, 0)
+    assert (await vcp_client.volume_state.read_value()) == vcs.VolumeState(32, 1, 0)
 
 
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
-async def test_relative_volume_down(vcp_client: vcp.VolumeControlServiceProxy):
+async def test_relative_volume_down(vcp_client: vcs.VolumeControlServiceProxy):
     await vcp_client.volume_control_point.write_value(
-        bytes([vcp.VolumeControlPointOpcode.RELATIVE_VOLUME_DOWN, 0])
+        bytes([vcs.VolumeControlPointOpcode.RELATIVE_VOLUME_DOWN, 0])
     )
-    assert (await vcp_client.volume_state.read_value()) == (16, 1, 1)
+    assert (await vcp_client.volume_state.read_value()) == vcs.VolumeState(16, 1, 1)
 
 
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
-async def test_relative_volume_up(vcp_client: vcp.VolumeControlServiceProxy):
+async def test_relative_volume_up(vcp_client: vcs.VolumeControlServiceProxy):
     await vcp_client.volume_control_point.write_value(
-        bytes([vcp.VolumeControlPointOpcode.RELATIVE_VOLUME_UP, 0])
+        bytes([vcs.VolumeControlPointOpcode.RELATIVE_VOLUME_UP, 0])
     )
-    assert (await vcp_client.volume_state.read_value()) == (48, 1, 1)
+    assert (await vcp_client.volume_state.read_value()) == vcs.VolumeState(48, 1, 1)
 
 
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
-async def test_unmute_relative_volume_down(vcp_client: vcp.VolumeControlServiceProxy):
+async def test_unmute_relative_volume_down(vcp_client: vcs.VolumeControlServiceProxy):
     await vcp_client.volume_control_point.write_value(
-        bytes([vcp.VolumeControlPointOpcode.UNMUTE_RELATIVE_VOLUME_DOWN, 0])
+        bytes([vcs.VolumeControlPointOpcode.UNMUTE_RELATIVE_VOLUME_DOWN, 0])
     )
-    assert (await vcp_client.volume_state.read_value()) == (16, 0, 1)
+    assert (await vcp_client.volume_state.read_value()) == vcs.VolumeState(16, 0, 1)
 
 
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
-async def test_unmute_relative_volume_up(vcp_client: vcp.VolumeControlServiceProxy):
+async def test_unmute_relative_volume_up(vcp_client: vcs.VolumeControlServiceProxy):
     await vcp_client.volume_control_point.write_value(
-        bytes([vcp.VolumeControlPointOpcode.UNMUTE_RELATIVE_VOLUME_UP, 0])
+        bytes([vcs.VolumeControlPointOpcode.UNMUTE_RELATIVE_VOLUME_UP, 0])
     )
-    assert (await vcp_client.volume_state.read_value()) == (48, 0, 1)
+    assert (await vcp_client.volume_state.read_value()) == vcs.VolumeState(48, 0, 1)
 
 
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
-async def test_set_absolute_volume(vcp_client: vcp.VolumeControlServiceProxy):
+async def test_set_absolute_volume(vcp_client: vcs.VolumeControlServiceProxy):
     await vcp_client.volume_control_point.write_value(
-        bytes([vcp.VolumeControlPointOpcode.SET_ABSOLUTE_VOLUME, 0, 255])
+        bytes([vcs.VolumeControlPointOpcode.SET_ABSOLUTE_VOLUME, 0, 255])
     )
-    assert (await vcp_client.volume_state.read_value()) == (255, 1, 1)
+    assert (await vcp_client.volume_state.read_value()) == vcs.VolumeState(255, 1, 1)
 
 
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
-async def test_mute(vcp_client: vcp.VolumeControlServiceProxy):
+async def test_mute(vcp_client: vcs.VolumeControlServiceProxy):
     await vcp_client.volume_control_point.write_value(
-        bytes([vcp.VolumeControlPointOpcode.MUTE, 0])
+        bytes([vcs.VolumeControlPointOpcode.MUTE, 0])
     )
-    assert (await vcp_client.volume_state.read_value()) == (32, 1, 0)
+    assert (await vcp_client.volume_state.read_value()) == vcs.VolumeState(32, 1, 0)
 
 
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
-async def test_unmute(vcp_client: vcp.VolumeControlServiceProxy):
+async def test_unmute(vcp_client: vcs.VolumeControlServiceProxy):
     await vcp_client.volume_control_point.write_value(
-        bytes([vcp.VolumeControlPointOpcode.UNMUTE, 0])
+        bytes([vcs.VolumeControlPointOpcode.UNMUTE, 0])
     )
-    assert (await vcp_client.volume_state.read_value()) == (32, 0, 1)
+    assert (await vcp_client.volume_state.read_value()) == vcs.VolumeState(32, 0, 1)

tests/vocs_test.py

@@ -32,9 +32,8 @@ from bumble.profiles.vocs import (
     SetVolumeOffsetOpCode,
     VolumeOffsetControlServiceProxy,
     VolumeOffsetState,
-    VocsAudioLocation,
 )
-from bumble.profiles.vcp import VolumeControlService, VolumeControlServiceProxy
+from bumble.profiles.vcs import VolumeControlService, VolumeControlServiceProxy
 from bumble.profiles.bap import AudioLocation
 
 from .test_utils import TwoDevices
@@ -81,9 +80,7 @@ async def test_init_service(vocs_client: VolumeOffsetControlServiceProxy):
         volume_offset=0,
         change_counter=0,
     )
-    assert await vocs_client.audio_location.read_value() == VocsAudioLocation(
-        audio_location=AudioLocation.NOT_ALLOWED
-    )
+    assert await vocs_client.audio_location.read_value() == AudioLocation.NOT_ALLOWED
     description = await vocs_client.audio_output_description.read_value()
     assert description == ''
 
@@ -162,11 +159,9 @@ async def test_set_volume_offset(vocs_client: VolumeOffsetControlServiceProxy):
 
 @pytest.mark.asyncio
 async def test_set_audio_channel_location(vocs_client: VolumeOffsetControlServiceProxy):
-    new_audio_location = VocsAudioLocation(audio_location=AudioLocation.FRONT_LEFT)
+    new_audio_location = AudioLocation.FRONT_LEFT
 
-    await vocs_client.audio_location.write_value(
-        struct.pack('<I', new_audio_location.audio_location)
-    )
+    await vocs_client.audio_location.write_value(new_audio_location)
 
     location = await vocs_client.audio_location.read_value()
     assert location == new_audio_location