bumble 0.0.215__tar.gz → 0.0.217__tar.gz

{bumble-0.0.215 → bumble-0.0.217}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bumble
-Version: 0.0.215
+Version: 0.0.217
 Summary: Bluetooth Stack for Apps, Emulation, Test and Experimentation
 Author-email: Google <bumble-dev@google.com>
 License-Expression: Apache-2.0

{bumble-0.0.215 → bumble-0.0.217}/bumble/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.215'
-__version_tuple__ = version_tuple = (0, 0, 215)
+__version__ = version = '0.0.217'
+__version_tuple__ = version_tuple = (0, 0, 217)
 
-__commit_id__ = commit_id = 'g768bbd95c'
+__commit_id__ = commit_id = 'gaec50ac61'

{bumble-0.0.215 → bumble-0.0.217}/bumble/device.py

@@ -2169,10 +2169,12 @@ def with_connection_from_handle(function):
 # Decorator that converts the first argument from a bluetooth address to a connection
 def with_connection_from_address(function):
     @functools.wraps(function)
-    def wrapper(self, address: hci.Address, *args, **kwargs):
-        for connection in self.connections.values():
+    def wrapper(device: Device, address: hci.Address, *args, **kwargs):
+        if connection := device.pending_connections.get(address):
+            return function(device, connection, *args, **kwargs)
+        for connection in device.connections.values():
             if connection.peer_address == address:
-                return function(self, connection, *args, **kwargs)
+                return function(device, connection, *args, **kwargs)
         raise ObjectLookupError('no connection for address')
 
     return wrapper
@@ -2182,11 +2184,13 @@ def with_connection_from_address(function):
 # connection
 def try_with_connection_from_address(function):
     @functools.wraps(function)
-    def wrapper(self, address, *args, **kwargs):
-        for connection in self.connections.values():
+    def wrapper(device: Device, address: hci.Address, *args, **kwargs):
+        if connection := device.pending_connections.get(address):
+            return function(device, connection, address, *args, **kwargs)
+        for connection in device.connections.values():
             if connection.peer_address == address:
-                return function(self, connection, address, *args, **kwargs)
-        return function(self, None, address, *args, **kwargs)
+                return function(device, connection, address, *args, **kwargs)
+        return function(device, None, address, *args, **kwargs)
 
     return wrapper
 
@@ -2234,7 +2238,7 @@ class Device(utils.CompositeEventEmitter):
     scan_response_data: bytes
     cs_capabilities: ChannelSoundingCapabilities | None = None
     connections: dict[int, Connection]
-    connection_roles: dict[hci.Address, hci.Role]
+    pending_connections: dict[hci.Address, Connection]
     classic_pending_accepts: dict[
         hci.Address,
         list[asyncio.Future[Union[Connection, tuple[hci.Address, int, int]]]],
@@ -2356,9 +2360,9 @@ class Device(utils.CompositeEventEmitter):
         self.le_connecting = False
         self.disconnecting = False
         self.connections = {}  # Connections, by connection handle
-        self.connection_roles = (
+        self.pending_connections = (
             {}
-        )  # Local connection roles, by BD address (BR/EDR only)
+        )  # Pending connections, by BD address (BR/EDR only)
         self.sco_links = {}  # ScoLinks, by connection handle (BR/EDR only)
         self.cis_links = {}  # CisLinks, by connection handle (LE only)
         self._pending_cis = {}  # (CIS_ID, CIG_ID), by CIS_handle
@@ -3827,7 +3831,17 @@ class Device(utils.CompositeEventEmitter):
                     )
             else:
                 # Save pending connection
-                self.connection_roles[peer_address] = hci.Role.CENTRAL
+                self.pending_connections[peer_address] = Connection(
+                    device=self,
+                    handle=0,
+                    transport=core.PhysicalTransport.BR_EDR,
+                    self_address=self.public_address,
+                    self_resolvable_address=None,
+                    peer_address=peer_address,
+                    peer_resolvable_address=None,
+                    role=hci.Role.CENTRAL,
+                    parameters=Connection.Parameters(0, 0, 0),
+                )
 
                 # TODO: allow passing other settings
                 result = await self.send_command(
@@ -3880,7 +3894,7 @@ class Device(utils.CompositeEventEmitter):
                 self.le_connecting = False
                 self.connect_own_address_type = None
             else:
-                self.connection_roles.pop(peer_address, None)
+                self.pending_connections.pop(peer_address, None)
 
     async def accept(
         self,
@@ -3978,7 +3992,17 @@ class Device(utils.CompositeEventEmitter):
         # Even if we requested a role switch in the hci.HCI_Accept_Connection_Request
         # command, this connection is still considered Peripheral until an eventual
         # role change event.
-        self.connection_roles[peer_address] = hci.Role.PERIPHERAL
+        self.pending_connections[peer_address] = Connection(
+            device=self,
+            handle=0,
+            transport=core.PhysicalTransport.BR_EDR,
+            self_address=self.public_address,
+            self_resolvable_address=None,
+            peer_address=peer_address,
+            peer_resolvable_address=None,
+            role=hci.Role.PERIPHERAL,
+            parameters=Connection.Parameters(0, 0, 0),
+        )
 
         try:
             # Accept connection request
@@ -3996,7 +4020,7 @@ class Device(utils.CompositeEventEmitter):
         finally:
             self.remove_listener(self.EVENT_CONNECTION, on_connection)
             self.remove_listener(self.EVENT_CONNECTION_FAILURE, on_connection_failure)
-            self.connection_roles.pop(peer_address, None)
+            self.pending_connections.pop(peer_address, None)
 
     @asynccontextmanager
     async def connect_as_gatt(self, peer_address: Union[hci.Address, str]):
@@ -5441,29 +5465,27 @@ class Device(utils.CompositeEventEmitter):
         connection_handle: int,
         peer_address: hci.Address,
     ) -> None:
-        connection_role = self.connection_roles.pop(peer_address, hci.Role.PERIPHERAL)
+        if connection := self.pending_connections.pop(peer_address, None):
+            connection.handle = connection_handle
+        else:
+            # Create a new connection
+            connection = Connection(
+                device=self,
+                handle=connection_handle,
+                transport=PhysicalTransport.BR_EDR,
+                self_address=self.public_address,
+                self_resolvable_address=None,
+                peer_address=peer_address,
+                peer_resolvable_address=None,
+                role=hci.Role.PERIPHERAL,
+                parameters=Connection.Parameters(0.0, 0, 0.0),
+            )
 
-        logger.debug(
-            f'*** Connection: [0x{connection_handle:04X}] '
-            f'{peer_address} {hci.HCI_Constant.role_name(connection_role)}'
-        )
+        logger.debug('*** %s', connection)
         if connection_handle in self.connections:
             logger.warning(
                 'new connection reuses the same handle as a previous connection'
             )
-
-        # Create a new connection
-        connection = Connection(
-            device=self,
-            handle=connection_handle,
-            transport=PhysicalTransport.BR_EDR,
-            self_address=self.public_address,
-            self_resolvable_address=None,
-            peer_address=peer_address,
-            peer_resolvable_address=None,
-            role=connection_role,
-            parameters=Connection.Parameters(0.0, 0, 0.0),
-        )
         self.connections[connection_handle] = connection
 
         self.emit(self.EVENT_CONNECTION, connection)
@@ -5618,7 +5640,9 @@ class Device(utils.CompositeEventEmitter):
 
     # FIXME: Explore a delegate-model for BR/EDR wait connection #56.
     @host_event_handler
-    def on_connection_request(self, bd_addr, class_of_device, link_type):
+    def on_connection_request(
+        self, bd_addr: hci.Address, class_of_device: int, link_type: int
+    ):
         logger.debug(f'*** Connection request: {bd_addr}')
 
         # Handle SCO request.
@@ -5647,7 +5671,17 @@ class Device(utils.CompositeEventEmitter):
         # device configuration is set to accept any incoming connection
         elif self.classic_accept_any:
             # Save pending connection
-            self.connection_roles[bd_addr] = hci.Role.PERIPHERAL
+            self.pending_connections[bd_addr] = Connection(
+                device=self,
+                handle=0,
+                transport=core.PhysicalTransport.BR_EDR,
+                self_address=self.public_address,
+                self_resolvable_address=None,
+                peer_address=bd_addr,
+                peer_resolvable_address=None,
+                role=hci.Role.PERIPHERAL,
+                parameters=Connection.Parameters(0, 0, 0),
+            )
 
             self.host.send_command_sync(
                 hci.HCI_Accept_Connection_Request_Command(
@@ -5958,7 +5992,7 @@ class Device(utils.CompositeEventEmitter):
     @host_event_handler
     @try_with_connection_from_address
     def on_remote_name(
-        self, connection: Connection, address: hci.Address, remote_name: bytes
+        self, connection: Optional[Connection], address: hci.Address, remote_name: bytes
     ):
         # Try to decode the name
         try:
@@ -5977,7 +6011,7 @@ class Device(utils.CompositeEventEmitter):
     @host_event_handler
     @try_with_connection_from_address
     def on_remote_name_failure(
-        self, connection: Connection, address: hci.Address, error: int
+        self, connection: Optional[Connection], address: hci.Address, error: int
     ):
         if connection:
             connection.emit(connection.EVENT_REMOTE_NAME_FAILURE, error)
@@ -6409,21 +6443,20 @@ class Device(utils.CompositeEventEmitter):
 
     # [Classic only]
     @host_event_handler
-    @try_with_connection_from_address
+    @with_connection_from_address
     def on_role_change(
-        self, connection: Connection, peer_address: hci.Address, new_role: hci.Role
+        self,
+        connection: Connection,
+        new_role: hci.Role,
     ):
-        if connection:
-            connection.role = new_role
-            connection.emit(connection.EVENT_ROLE_CHANGE, new_role)
-        else:
-            self.connection_roles[peer_address] = new_role
+        connection.role = new_role
+        connection.emit(connection.EVENT_ROLE_CHANGE, new_role)
 
     # [Classic only]
     @host_event_handler
     @try_with_connection_from_address
     def on_role_change_failure(
-        self, connection: Connection, address: hci.Address, error: int
+        self, connection: Optional[Connection], address: hci.Address, error: int
     ):
         if connection:
             connection.emit(connection.EVENT_ROLE_CHANGE_FAILURE, error)

{bumble-0.0.215 → bumble-0.0.217}/bumble/host.py

@@ -550,7 +550,7 @@ class Host(utils.EventEmitter):
             logger.debug(
                 'HCI LE flow control: '
                 f'le_acl_data_packet_length={le_acl_data_packet_length},'
-                f'total_num_le_acl_data_packets={total_num_le_acl_data_packets}'
+                f'total_num_le_acl_data_packets={total_num_le_acl_data_packets},'
                 f'iso_data_packet_length={iso_data_packet_length},'
                 f'total_num_iso_data_packets={total_num_iso_data_packets}'
             )

{bumble-0.0.215 → bumble-0.0.217}/bumble/profiles/hap.py

@@ -273,12 +273,19 @@ class HearingAccessService(gatt.TemplateService):
             def on_disconnection(_reason) -> None:
                 self.currently_connected_clients.discard(connection)
 
+            @connection.on(connection.EVENT_CONNECTION_ATT_MTU_UPDATE)
+            def on_mtu_update(*_: Any) -> None:
+                self.on_incoming_connection(connection)
+
+            @connection.on(connection.EVENT_CONNECTION_ENCRYPTION_CHANGE)
+            def on_encryption_change(*_: Any) -> None:
+                self.on_incoming_connection(connection)
+
             @connection.on(connection.EVENT_PAIRING)
             def on_pairing(*_: Any) -> None:
-                self.on_incoming_paired_connection(connection)
+                self.on_incoming_connection(connection)
 
-            if connection.peer_resolvable_address:
-                self.on_incoming_paired_connection(connection)
+            self.on_incoming_connection(connection)
 
         self.hearing_aid_features_characteristic = gatt.Characteristic(
             uuid=gatt.GATT_HEARING_AID_FEATURES_CHARACTERISTIC,
@@ -315,9 +322,30 @@ class HearingAccessService(gatt.TemplateService):
             ]
         )
 
-    def on_incoming_paired_connection(self, connection: Connection):
+    def on_incoming_connection(self, connection: Connection):
         '''Setup initial operations to handle a remote bonded HAP device'''
         # TODO Should we filter on HAP device only ?
+
+        if not connection.is_encrypted:
+            logging.debug(f'HAS: {connection.peer_address} is not encrypted')
+            return
+
+        if not connection.peer_resolvable_address:
+            logging.debug(f'HAS: {connection.peer_address} is not paired')
+            return
+
+        if connection.att_mtu < 49:
+            logging.debug(
+                f'HAS: {connection.peer_address} invalid MTU={connection.att_mtu}'
+            )
+            return
+
+        if connection.peer_address in self.currently_connected_clients:
+            logging.debug(
+                f'HAS: Already connected to {connection.peer_address} nothing to do'
+            )
+            return
+
         self.currently_connected_clients.add(connection)
         if (
             connection.peer_address
@@ -457,6 +485,7 @@ class HearingAccessService(gatt.TemplateService):
                     connection,
                     self.hearing_aid_preset_control_point,
                     value=op_list[0].to_bytes(len(op_list) == 1),
+                    force=True,  # TODO GATT notification subscription should be persistent
                 )
                 # Remove item once sent, and keep the non sent item in the list
                 op_list.pop(0)

{bumble-0.0.215 → bumble-0.0.217}/bumble/transport/android_netsim.py

@@ -131,7 +131,11 @@ def publish_grpc_port(grpc_port: int, instance_number: int) -> bool:
 
         def cleanup():
             logger.debug("removing .ini file")
-            ini_file.unlink()
+            try:
+                ini_file.unlink()
+            except OSError as error:
+                # Don't log at exception level, since this may happen normally.
+                logger.debug(f'failed to remove .ini file ({error})')
 
         atexit.register(cleanup)
         return True

{bumble-0.0.215 → bumble-0.0.217}/bumble/transport/serial.py

@@ -17,6 +17,7 @@
 # -----------------------------------------------------------------------------
 import asyncio
 import logging
+from typing import Optional
 
 import serial_asyncio
 
@@ -28,25 +29,56 @@ from bumble.transport.common import StreamPacketSink, StreamPacketSource, Transp
 logger = logging.getLogger(__name__)
 
 
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+DEFAULT_POST_OPEN_DELAY = 0.5  # in seconds
+
+# -----------------------------------------------------------------------------
+# Classes and Functions
+# -----------------------------------------------------------------------------
+
+
+# -----------------------------------------------------------------------------
+class SerialPacketSource(StreamPacketSource):
+    def __init__(self) -> None:
+        super().__init__()
+        self._ready = asyncio.Event()
+
+    async def wait_until_ready(self) -> None:
+        await self._ready.wait()
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        logger.debug('connection made')
+        self._ready.set()
+
+    def connection_lost(self, exc: Optional[Exception]) -> None:
+        logger.debug('connection lost')
+        self.on_transport_lost()
+
+
 # -----------------------------------------------------------------------------
 async def open_serial_transport(spec: str) -> Transport:
     '''
     Open a serial port transport.
     The parameter string has this syntax:
-    <device-path>[,<speed>][,rtscts][,dsrdtr]
+    <device-path>[,<speed>][,rtscts][,dsrdtr][,delay]
     When <speed> is omitted, the default value of 1000000 is used
     When "rtscts" is specified, RTS/CTS hardware flow control is enabled
     When "dsrdtr" is specified, DSR/DTR hardware flow control is enabled
+    When "delay" is specified, a short delay is added after opening the port
 
     Examples:
     /dev/tty.usbmodem0006839912172
     /dev/tty.usbmodem0006839912172,1000000
     /dev/tty.usbmodem0006839912172,rtscts
+    /dev/tty.usbmodem0006839912172,rtscts,delay
     '''
 
     speed = 1000000
     rtscts = False
     dsrdtr = False
+    delay = 0.0
     if ',' in spec:
         parts = spec.split(',')
         device = parts[0]
@@ -55,13 +87,16 @@ async def open_serial_transport(spec: str) -> Transport:
                 rtscts = True
             elif part == 'dsrdtr':
                 dsrdtr = True
+            elif part == 'delay':
+                delay = DEFAULT_POST_OPEN_DELAY
             elif part.isnumeric():
                 speed = int(part)
     else:
         device = spec
+
     serial_transport, packet_source = await serial_asyncio.create_serial_connection(
         asyncio.get_running_loop(),
-        StreamPacketSource,
+        SerialPacketSource,
         device,
         baudrate=speed,
         rtscts=rtscts,
@@ -69,4 +104,23 @@ async def open_serial_transport(spec: str) -> Transport:
     )
     packet_sink = StreamPacketSink(serial_transport)
 
+    logger.debug('waiting for the port to be ready')
+    await packet_source.wait_until_ready()
+    logger.debug('port is ready')
+
+    # Try to assert DTR
+    assert serial_transport.serial is not None
+    try:
+        serial_transport.serial.dtr = True
+        logger.debug(
+            f"DSR={serial_transport.serial.dsr}, DTR={serial_transport.serial.dtr}"
+        )
+    except Exception as e:
+        logger.warning(f'could not assert DTR: {e}')
+
+    # Wait a bit after opening the port, if requested
+    if delay > 0.0:
+        logger.debug(f'waiting {delay} seconds after opening the port')
+        await asyncio.sleep(delay)
+
     return Transport(packet_source, packet_sink)

{bumble-0.0.215 → bumble-0.0.217}/bumble.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bumble
-Version: 0.0.215
+Version: 0.0.217
 Summary: Bluetooth Stack for Apps, Emulation, Test and Experimentation
 Author-email: Google <bumble-dev@google.com>
 License-Expression: Apache-2.0

bumble-0.0.217/docs/mkdocs/src/transports/serial.md

@@ -0,0 +1,21 @@
+SERIAL TRANSPORT
+================
+
+The serial transport implements sending/receiving HCI packets over a UART (a.k.a serial port).
+
+## Moniker
+The moniker syntax for a serial transport is:  
+    `<device-path>[,<speed>][,rtscts][,dsrdtr][,delay]`
+
+When `<speed>` is omitted, the default value of 1000000 is used.  
+When `rtscts` is specified, RTS/CTS hardware flow control is enabled.  
+When `dsrdtr` is specified, DSR/DTR hardware flow control is enabled.  
+When `delay` is specified, a short delay is added after opening the port.  
+
+!!! example
+    ```
+    /dev/tty.usbmodem0006839912172
+    /dev/tty.usbmodem0006839912172,1000000
+    /dev/tty.usbmodem0006839912172,rtscts
+    /dev/tty.usbmodem0006839912172,rtscts,delay
+    ```