bumble 0.0.209__py3-none-any.whl → 0.0.210__py3-none-any.whl

bumble/device.py

@@ -49,16 +49,14 @@ from typing import (
 )
 from typing_extensions import Self
 
-from pyee import EventEmitter
-
-from .colors import color
-from .att import ATT_CID, ATT_DEFAULT_MTU, ATT_PDU
-from .gatt import Attribute, Characteristic, Descriptor, Service
-from .host import DataPacketQueue, Host
-from .profiles.gap import GenericAccessService
-from .core import (
-    BT_BR_EDR_TRANSPORT,
-    BT_LE_TRANSPORT,
+
+from bumble.colors import color
+from bumble.att import ATT_CID, ATT_DEFAULT_MTU, ATT_PDU
+from bumble.gatt import Attribute, Characteristic, Descriptor, Service
+from bumble.host import DataPacketQueue, Host
+from bumble.profiles.gap import GenericAccessService
+from bumble.core import (
+    PhysicalTransport,
     AdvertisingData,
     BaseBumbleError,
     ConnectionParameterUpdateError,
@@ -72,16 +70,8 @@ from .core import (
     OutOfResourcesError,
     UnreachableError,
 )
-from .utils import (
-    AsyncRunner,
-    CompositeEventEmitter,
-    EventWatcher,
-    setup_event_forwarding,
-    composite_listener,
-    deprecated,
-    experimental,
-)
-from .keys import (
+from bumble import utils
+from bumble.keys import (
     KeyStore,
     PairingKeys,
 )
@@ -96,7 +86,7 @@ from bumble import core
 from bumble.profiles import gatt_service
 
 if TYPE_CHECKING:
-    from .transport.common import TransportSource, TransportSink
+    from bumble.transport.common import TransportSource, TransportSink
 
 
 # -----------------------------------------------------------------------------
@@ -577,7 +567,7 @@ class PeriodicAdvertisingParameters:
 
 # -----------------------------------------------------------------------------
 @dataclass
-class AdvertisingSet(EventEmitter):
+class AdvertisingSet(utils.EventEmitter):
     device: Device
     advertising_handle: int
     auto_restart: bool
@@ -794,13 +784,24 @@ class AdvertisingSet(EventEmitter):
         )
         del self.device.extended_advertising_sets[self.advertising_handle]
 
+    async def transfer_periodic_info(
+        self, connection: Connection, service_data: int = 0
+    ) -> None:
+        if not self.periodic_enabled:
+            raise core.InvalidStateError(
+                f"Periodic Advertising is not enabled on Advertising Set 0x{self.advertising_handle:02X}"
+            )
+        await connection.transfer_periodic_set_info(
+            self.advertising_handle, service_data
+        )
+
     def on_termination(self, status: int) -> None:
         self.enabled = False
         self.emit('termination', status)
 
 
 # -----------------------------------------------------------------------------
-class PeriodicAdvertisingSync(EventEmitter):
+class PeriodicAdvertisingSync(utils.EventEmitter):
     class State(Enum):
         INIT = 0
         PENDING = 1
@@ -929,7 +930,7 @@ class PeriodicAdvertisingSync(EventEmitter):
                 "received established event for cancelled sync, will terminate"
             )
             self.state = self.State.ESTABLISHED
-            AsyncRunner.spawn(self.terminate())
+            utils.AsyncRunner.spawn(self.terminate())
             return
 
         if status == hci.HCI_SUCCESS:
@@ -1015,7 +1016,7 @@ class BigParameters:
 
 # -----------------------------------------------------------------------------
 @dataclass
-class Big(EventEmitter):
+class Big(utils.EventEmitter):
     class State(IntEnum):
         PENDING = 0
         ACTIVE = 1
@@ -1055,7 +1056,7 @@ class Big(EventEmitter):
             logger.error('BIG %d is not active.', self.big_handle)
             return
 
-        with closing(EventWatcher()) as watcher:
+        with closing(utils.EventWatcher()) as watcher:
             terminated = asyncio.Event()
             watcher.once(self, Big.Event.TERMINATION, lambda _: terminated.set())
             await self.device.send_command(
@@ -1078,7 +1079,7 @@ class BigSyncParameters:
 
 # -----------------------------------------------------------------------------
 @dataclass
-class BigSync(EventEmitter):
+class BigSync(utils.EventEmitter):
     class State(IntEnum):
         PENDING = 0
         ACTIVE = 1
@@ -1113,7 +1114,7 @@ class BigSync(EventEmitter):
             logger.error('BIG Sync %d is not active.', self.big_handle)
             return
 
-        with closing(EventWatcher()) as watcher:
+        with closing(utils.EventWatcher()) as watcher:
             terminated = asyncio.Event()
             watcher.once(self, BigSync.Event.TERMINATION, lambda _: terminated.set())
             await self.device.send_command(
@@ -1243,7 +1244,7 @@ class Peer:
         self,
         uuids: Iterable[Union[core.UUID, str]] = (),
         service: Optional[gatt_client.ServiceProxy] = None,
-    ) -> list[gatt_client.CharacteristicProxy]:
+    ) -> list[gatt_client.CharacteristicProxy[bytes]]:
         return await self.gatt_client.discover_characteristics(
             uuids=uuids, service=service
         )
@@ -1258,7 +1259,7 @@ class Peer:
             characteristic, start_handle, end_handle
         )
 
-    async def discover_attributes(self) -> list[gatt_client.AttributeProxy]:
+    async def discover_attributes(self) -> list[gatt_client.AttributeProxy[bytes]]:
         return await self.gatt_client.discover_attributes()
 
     async def discover_all(self):
@@ -1312,7 +1313,7 @@ class Peer:
         self,
         uuid: core.UUID,
         service: Optional[Union[gatt_client.ServiceProxy, core.UUID]] = None,
-    ) -> list[gatt_client.CharacteristicProxy]:
+    ) -> list[gatt_client.CharacteristicProxy[bytes]]:
         if isinstance(service, core.UUID):
             return list(
                 itertools.chain(
@@ -1382,7 +1383,7 @@ ConnectionParametersPreferences.default = ConnectionParametersPreferences()
 
 # -----------------------------------------------------------------------------
 @dataclass
-class ScoLink(CompositeEventEmitter):
+class ScoLink(utils.CompositeEventEmitter):
     device: Device
     acl_connection: Connection
     handle: int
@@ -1473,7 +1474,7 @@ class _IsoLink:
 
 # -----------------------------------------------------------------------------
 @dataclass
-class CisLink(CompositeEventEmitter, _IsoLink):
+class CisLink(utils.EventEmitter, _IsoLink):
     class State(IntEnum):
         PENDING = 0
         ESTABLISHED = 1
@@ -1550,7 +1551,7 @@ class IsoPacketStream:
 
 
 # -----------------------------------------------------------------------------
-class Connection(CompositeEventEmitter):
+class Connection(utils.CompositeEventEmitter):
     device: Device
     handle: int
     transport: core.PhysicalTransport
@@ -1570,7 +1571,7 @@ class Connection(CompositeEventEmitter):
     cs_configs: dict[int, ChannelSoundingConfig]  # Config ID to Configuration
     cs_procedures: dict[int, ChannelSoundingProcedure]  # Config ID to Procedures
 
-    @composite_listener
+    @utils.composite_listener
     class Listener:
         def on_disconnection(self, reason):
             pass
@@ -1649,7 +1650,7 @@ class Connection(CompositeEventEmitter):
         return cls(
             device,
             None,
-            BT_BR_EDR_TRANSPORT,
+            PhysicalTransport.BR_EDR,
             device.public_address,
             None,
             peer_address,
@@ -1664,7 +1665,7 @@ class Connection(CompositeEventEmitter):
         Finish an incomplete connection upon completion.
         """
         assert self.handle is None
-        assert self.transport == BT_BR_EDR_TRANSPORT
+        assert self.transport == PhysicalTransport.BR_EDR
         self.handle = handle
         self.parameters = parameters
 
@@ -1689,7 +1690,7 @@ class Connection(CompositeEventEmitter):
     def send_l2cap_pdu(self, cid: int, pdu: bytes) -> None:
         self.device.send_l2cap_pdu(self.handle, cid, pdu)
 
-    @deprecated("Please use create_l2cap_channel()")
+    @utils.deprecated("Please use create_l2cap_channel()")
     async def open_l2cap_channel(
         self,
         psm,
@@ -1743,7 +1744,9 @@ class Connection(CompositeEventEmitter):
         self.on('disconnection_failure', abort.set_exception)
 
         try:
-            await asyncio.wait_for(self.device.abort_on('flush', abort), timeout)
+            await asyncio.wait_for(
+                utils.cancel_on_event(self.device, 'flush', abort), timeout
+            )
         finally:
             self.remove_listener('disconnection', abort.set_result)
             self.remove_listener('disconnection_failure', abort.set_exception)
@@ -1782,6 +1785,13 @@ class Connection(CompositeEventEmitter):
     ) -> None:
         await self.device.transfer_periodic_sync(self, sync_handle, service_data)
 
+    async def transfer_periodic_set_info(
+        self, advertising_handle: int, service_data: int = 0
+    ) -> None:
+        await self.device.transfer_periodic_set_info(
+            self, advertising_handle, service_data
+        )
+
     # [Classic only]
     async def request_remote_name(self):
         return await self.device.request_remote_name(self)
@@ -1812,7 +1822,7 @@ class Connection(CompositeEventEmitter):
                     raise
 
     def __str__(self):
-        if self.transport == BT_LE_TRANSPORT:
+        if self.transport == PhysicalTransport.LE:
             return (
                 f'Connection(transport=LE, handle=0x{self.handle:04X}, '
                 f'role={self.role_name}, '
@@ -2020,7 +2030,7 @@ device_host_event_handlers: list[str] = []
 
 
 # -----------------------------------------------------------------------------
-class Device(CompositeEventEmitter):
+class Device(utils.CompositeEventEmitter):
     # Incomplete list of fields.
     random_address: hci.Address  # Random private address that may change periodically
     public_address: (
@@ -2052,7 +2062,7 @@ class Device(CompositeEventEmitter):
     _pending_cis: Dict[int, tuple[int, int]]
     gatt_service: gatt_service.GenericAttributeProfileService | None = None
 
-    @composite_listener
+    @utils.composite_listener
     class Listener:
         def on_advertisement(self, advertisement):
             pass
@@ -2273,7 +2283,9 @@ class Device(CompositeEventEmitter):
         self.l2cap_channel_manager.register_fixed_channel(ATT_CID, self.on_gatt_pdu)
 
         # Forward some events
-        setup_event_forwarding(self.gatt_server, self, 'characteristic_subscription')
+        utils.setup_event_forwarding(
+            self.gatt_server, self, 'characteristic_subscription'
+        )
 
         # Set the initial host
         if host:
@@ -2362,11 +2374,11 @@ class Device(CompositeEventEmitter):
             None,
         )
 
-    @deprecated("Please use create_l2cap_server()")
+    @utils.deprecated("Please use create_l2cap_server()")
     def register_l2cap_server(self, psm, server) -> int:
         return self.l2cap_channel_manager.register_server(psm, server)
 
-    @deprecated("Please use create_l2cap_server()")
+    @utils.deprecated("Please use create_l2cap_server()")
     def register_l2cap_channel_server(
         self,
         psm,
@@ -2379,7 +2391,7 @@ class Device(CompositeEventEmitter):
             psm, server, max_credits, mtu, mps
         )
 
-    @deprecated("Please use create_l2cap_channel()")
+    @utils.deprecated("Please use create_l2cap_channel()")
     async def open_l2cap_channel(
         self,
         connection,
@@ -3220,7 +3232,7 @@ class Device(CompositeEventEmitter):
                     advertiser_clock_accuracy,
                 )
 
-                AsyncRunner.spawn(self._update_periodic_advertising_syncs())
+                utils.AsyncRunner.spawn(self._update_periodic_advertising_syncs())
 
                 return
 
@@ -3379,7 +3391,7 @@ class Device(CompositeEventEmitter):
     async def connect(
         self,
         peer_address: Union[hci.Address, str],
-        transport: core.PhysicalTransport = BT_LE_TRANSPORT,
+        transport: core.PhysicalTransport = PhysicalTransport.LE,
         connection_parameters_preferences: Optional[
             dict[hci.Phy, ConnectionParametersPreferences]
         ] = None,
@@ -3429,23 +3441,23 @@ class Device(CompositeEventEmitter):
         '''
 
         # Check parameters
-        if transport not in (BT_LE_TRANSPORT, BT_BR_EDR_TRANSPORT):
+        if transport not in (PhysicalTransport.LE, PhysicalTransport.BR_EDR):
             raise InvalidArgumentError('invalid transport')
         transport = core.PhysicalTransport(transport)
 
         # Adjust the transport automatically if we need to
-        if transport == BT_LE_TRANSPORT and not self.le_enabled:
-            transport = BT_BR_EDR_TRANSPORT
-        elif transport == BT_BR_EDR_TRANSPORT and not self.classic_enabled:
-            transport = BT_LE_TRANSPORT
+        if transport == PhysicalTransport.LE and not self.le_enabled:
+            transport = PhysicalTransport.BR_EDR
+        elif transport == PhysicalTransport.BR_EDR and not self.classic_enabled:
+            transport = PhysicalTransport.LE
 
         # Check that there isn't already a pending connection
-        if transport == BT_LE_TRANSPORT and self.is_le_connecting:
+        if transport == PhysicalTransport.LE and self.is_le_connecting:
             raise InvalidStateError('connection already pending')
 
         if isinstance(peer_address, str):
             try:
-                if transport == BT_LE_TRANSPORT and peer_address.endswith('@'):
+                if transport == PhysicalTransport.LE and peer_address.endswith('@'):
                     peer_address = hci.Address.from_string_for_transport(
                         peer_address[:-1], transport
                     )
@@ -3465,21 +3477,21 @@ class Device(CompositeEventEmitter):
         else:
             # All BR/EDR addresses should be public addresses
             if (
-                transport == BT_BR_EDR_TRANSPORT
+                transport == PhysicalTransport.BR_EDR
                 and peer_address.address_type != hci.Address.PUBLIC_DEVICE_ADDRESS
             ):
                 raise InvalidArgumentError('BR/EDR addresses must be PUBLIC')
 
         assert isinstance(peer_address, hci.Address)
 
-        if transport == BT_LE_TRANSPORT and always_resolve:
+        if transport == PhysicalTransport.LE and always_resolve:
             logger.debug('resolving address')
             peer_address = await self.find_peer_by_identity_address(
                 peer_address
             )  # TODO: timeout
 
         def on_connection(connection):
-            if transport == BT_LE_TRANSPORT or (
+            if transport == PhysicalTransport.LE or (
                 # match BR/EDR connection event against peer address
                 connection.transport == transport
                 and connection.peer_address == peer_address
@@ -3487,7 +3499,7 @@ class Device(CompositeEventEmitter):
                 pending_connection.set_result(connection)
 
         def on_connection_failure(error):
-            if transport == BT_LE_TRANSPORT or (
+            if transport == PhysicalTransport.LE or (
                 # match BR/EDR connection failure event against peer address
                 error.transport == transport
                 and error.peer_address == peer_address
@@ -3501,7 +3513,7 @@ class Device(CompositeEventEmitter):
 
         try:
             # Tell the controller to connect
-            if transport == BT_LE_TRANSPORT:
+            if transport == PhysicalTransport.LE:
                 if connection_parameters_preferences is None:
                     if connection_parameters_preferences is None:
                         connection_parameters_preferences = {
@@ -3646,18 +3658,18 @@ class Device(CompositeEventEmitter):
                 raise hci.HCI_StatusError(result)
 
             # Wait for the connection process to complete
-            if transport == BT_LE_TRANSPORT:
+            if transport == PhysicalTransport.LE:
                 self.le_connecting = True
 
             if timeout is None:
-                return await self.abort_on('flush', pending_connection)
+                return await utils.cancel_on_event(self, 'flush', pending_connection)
 
             try:
                 return await asyncio.wait_for(
                     asyncio.shield(pending_connection), timeout
                 )
             except asyncio.TimeoutError:
-                if transport == BT_LE_TRANSPORT:
+                if transport == PhysicalTransport.LE:
                     await self.send_command(
                         hci.HCI_LE_Create_Connection_Cancel_Command()
                     )
@@ -3667,13 +3679,15 @@ class Device(CompositeEventEmitter):
                     )
 
                 try:
-                    return await self.abort_on('flush', pending_connection)
+                    return await utils.cancel_on_event(
+                        self, 'flush', pending_connection
+                    )
                 except core.ConnectionError as error:
                     raise core.TimeoutError() from error
         finally:
             self.remove_listener('connection', on_connection)
             self.remove_listener('connection_failure', on_connection_failure)
-            if transport == BT_LE_TRANSPORT:
+            if transport == PhysicalTransport.LE:
                 self.le_connecting = False
                 self.connect_own_address_type = None
             else:
@@ -3703,7 +3717,7 @@ class Device(CompositeEventEmitter):
                 # If the address is not parsable, assume it is a name instead
                 logger.debug('looking for peer by name')
                 peer_address = await self.find_peer_by_name(
-                    peer_address, BT_BR_EDR_TRANSPORT
+                    peer_address, PhysicalTransport.BR_EDR
                 )  # TODO: timeout
 
         assert isinstance(peer_address, hci.Address)
@@ -3723,7 +3737,7 @@ class Device(CompositeEventEmitter):
 
         try:
             # Wait for a request or a completed connection
-            pending_request = self.abort_on('flush', pending_request_fut)
+            pending_request = utils.cancel_on_event(self, 'flush', pending_request_fut)
             result = await (
                 asyncio.wait_for(pending_request, timeout)
                 if timeout
@@ -3753,14 +3767,14 @@ class Device(CompositeEventEmitter):
 
         def on_connection(connection):
             if (
-                connection.transport == BT_BR_EDR_TRANSPORT
+                connection.transport == PhysicalTransport.BR_EDR
                 and connection.peer_address == peer_address
             ):
                 pending_connection.set_result(connection)
 
         def on_connection_failure(error):
             if (
-                error.transport == BT_BR_EDR_TRANSPORT
+                error.transport == PhysicalTransport.BR_EDR
                 and error.peer_address == peer_address
             ):
                 pending_connection.set_exception(error)
@@ -3785,7 +3799,7 @@ class Device(CompositeEventEmitter):
             )
 
             # Wait for connection complete
-            return await self.abort_on('flush', pending_connection)
+            return await utils.cancel_on_event(self, 'flush', pending_connection)
 
         finally:
             self.remove_listener('connection', on_connection)
@@ -3830,7 +3844,7 @@ class Device(CompositeEventEmitter):
                     # If the address is not parsable, assume it is a name instead
                     logger.debug('looking for peer by name')
                     peer_address = await self.find_peer_by_name(
-                        peer_address, BT_BR_EDR_TRANSPORT
+                        peer_address, PhysicalTransport.BR_EDR
                     )  # TODO: timeout
 
             await self.send_command(
@@ -3859,7 +3873,7 @@ class Device(CompositeEventEmitter):
 
             # Wait for the disconnection process to complete
             self.disconnecting = True
-            return await self.abort_on('flush', pending_disconnection)
+            return await utils.cancel_on_event(self, 'flush', pending_disconnection)
         finally:
             connection.remove_listener(
                 'disconnection', pending_disconnection.set_result
@@ -4001,7 +4015,19 @@ class Device(CompositeEventEmitter):
             check_result=True,
         )
 
-    async def find_peer_by_name(self, name, transport=BT_LE_TRANSPORT):
+    async def transfer_periodic_set_info(
+        self, connection: Connection, advertising_handle: int, service_data: int = 0
+    ) -> None:
+        return await self.send_command(
+            hci.HCI_LE_Periodic_Advertising_Set_Info_Transfer_Command(
+                connection_handle=connection.handle,
+                service_data=service_data,
+                advertising_handle=advertising_handle,
+            ),
+            check_result=True,
+        )
+
+    async def find_peer_by_name(self, name, transport=PhysicalTransport.LE):
         """
         Scan for a peer with a given name and return its address.
         """
@@ -4020,7 +4046,7 @@ class Device(CompositeEventEmitter):
         was_scanning = self.scanning
         was_discovering = self.discovering
         try:
-            if transport == BT_LE_TRANSPORT:
+            if transport == PhysicalTransport.LE:
                 event_name = 'advertisement'
                 listener = self.on(
                     event_name,
@@ -4032,7 +4058,7 @@ class Device(CompositeEventEmitter):
                 if not self.scanning:
                     await self.start_scanning(filter_duplicates=True)
 
-            elif transport == BT_BR_EDR_TRANSPORT:
+            elif transport == PhysicalTransport.BR_EDR:
                 event_name = 'inquiry_result'
                 listener = self.on(
                     event_name,
@@ -4046,14 +4072,14 @@ class Device(CompositeEventEmitter):
             else:
                 return None
 
-            return await self.abort_on('flush', peer_address)
+            return await utils.cancel_on_event(self, 'flush', peer_address)
         finally:
             if listener is not None:
                 self.remove_listener(event_name, listener)
 
-            if transport == BT_LE_TRANSPORT and not was_scanning:
+            if transport == PhysicalTransport.LE and not was_scanning:
                 await self.stop_scanning()
-            elif transport == BT_BR_EDR_TRANSPORT and not was_discovering:
+            elif transport == PhysicalTransport.BR_EDR and not was_discovering:
                 await self.stop_discovery()
 
     async def find_peer_by_identity_address(
@@ -4096,7 +4122,7 @@ class Device(CompositeEventEmitter):
             if not self.scanning:
                 await self.start_scanning(filter_duplicates=True)
 
-            return await self.abort_on('flush', peer_address)
+            return await utils.cancel_on_event(self, 'flush', peer_address)
         finally:
             if listener is not None:
                 self.remove_listener(event_name, listener)
@@ -4200,7 +4226,9 @@ class Device(CompositeEventEmitter):
                 raise hci.HCI_StatusError(result)
 
             # Wait for the authentication to complete
-            await connection.abort_on('disconnection', pending_authentication)
+            await utils.cancel_on_event(
+                connection, 'disconnection', pending_authentication
+            )
         finally:
             connection.remove_listener('connection_authentication', on_authentication)
             connection.remove_listener(
@@ -4208,7 +4236,7 @@ class Device(CompositeEventEmitter):
             )
 
     async def encrypt(self, connection, enable=True):
-        if not enable and connection.transport == BT_LE_TRANSPORT:
+        if not enable and connection.transport == PhysicalTransport.LE:
             raise InvalidArgumentError('`enable` parameter is classic only.')
 
         # Set up event handlers
@@ -4225,7 +4253,7 @@ class Device(CompositeEventEmitter):
 
         # Request the encryption
         try:
-            if connection.transport == BT_LE_TRANSPORT:
+            if connection.transport == PhysicalTransport.LE:
                 # Look for a key in the key store
                 if self.keystore is None:
                     raise InvalidOperationError('no key store')
@@ -4246,7 +4274,7 @@ class Device(CompositeEventEmitter):
                 else:
                     raise InvalidOperationError('no LTK found for peer')
 
-                if connection.role != hci.HCI_CENTRAL_ROLE:
+                if connection.role != hci.Role.CENTRAL:
                     raise InvalidStateError('only centrals can start encryption')
 
                 result = await self.send_command(
@@ -4280,7 +4308,7 @@ class Device(CompositeEventEmitter):
                     raise hci.HCI_StatusError(result)
 
             # Wait for the result
-            await connection.abort_on('disconnection', pending_encryption)
+            await utils.cancel_on_event(connection, 'disconnection', pending_encryption)
         finally:
             connection.remove_listener(
                 'connection_encryption_change', on_encryption_change
@@ -4324,7 +4352,9 @@ class Device(CompositeEventEmitter):
                     f'{hci.HCI_Constant.error_name(result.status)}'
                 )
                 raise hci.HCI_StatusError(result)
-            await connection.abort_on('disconnection', pending_role_change)
+            await utils.cancel_on_event(
+                connection, 'disconnection', pending_role_change
+            )
         finally:
             connection.remove_listener('role_change', on_role_change)
             connection.remove_listener('role_change_failure', on_role_change_failure)
@@ -4373,13 +4403,13 @@ class Device(CompositeEventEmitter):
                 raise hci.HCI_StatusError(result)
 
             # Wait for the result
-            return await self.abort_on('flush', pending_name)
+            return await utils.cancel_on_event(self, 'flush', pending_name)
         finally:
             self.remove_listener('remote_name', handler)
             self.remove_listener('remote_name_failure', failure_handler)
 
     # [LE only]
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def setup_cig(
         self,
         cig_id: int,
@@ -4437,7 +4467,7 @@ class Device(CompositeEventEmitter):
         return cis_handles
 
     # [LE only]
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def create_cis(
         self, cis_acl_pairs: Sequence[tuple[int, int]]
     ) -> list[CisLink]:
@@ -4453,7 +4483,7 @@ class Device(CompositeEventEmitter):
                 cig_id=cig_id,
             )
 
-        with closing(EventWatcher()) as watcher:
+        with closing(utils.EventWatcher()) as watcher:
             pending_cis_establishments = {
                 cis_handle: asyncio.get_running_loop().create_future()
                 for cis_handle, _ in cis_acl_pairs
@@ -4480,7 +4510,7 @@ class Device(CompositeEventEmitter):
             return await asyncio.gather(*pending_cis_establishments.values())
 
     # [LE only]
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def accept_cis_request(self, handle: int) -> CisLink:
         """[LE Only] Accepts an incoming CIS request.
 
@@ -4502,7 +4532,7 @@ class Device(CompositeEventEmitter):
             if cis_link.state == CisLink.State.ESTABLISHED:
                 return cis_link
 
-            with closing(EventWatcher()) as watcher:
+            with closing(utils.EventWatcher()) as watcher:
                 pending_establishment = asyncio.get_running_loop().create_future()
 
                 def on_establishment() -> None:
@@ -4526,7 +4556,7 @@ class Device(CompositeEventEmitter):
         raise UnreachableError()
 
     # [LE only]
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def reject_cis_request(
         self,
         handle: int,
@@ -4540,14 +4570,14 @@ class Device(CompositeEventEmitter):
         )
 
     # [LE only]
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def create_big(
         self, advertising_set: AdvertisingSet, parameters: BigParameters
     ) -> Big:
         if (big_handle := self.next_big_handle()) is None:
             raise core.OutOfResourcesError("All valid BIG handles already in use")
 
-        with closing(EventWatcher()) as watcher:
+        with closing(utils.EventWatcher()) as watcher:
             big = Big(
                 big_handle=big_handle,
                 parameters=parameters,
@@ -4590,7 +4620,7 @@ class Device(CompositeEventEmitter):
         return big
 
     # [LE only]
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def create_big_sync(
         self, pa_sync: PeriodicAdvertisingSync, parameters: BigSyncParameters
     ) -> BigSync:
@@ -4600,7 +4630,7 @@ class Device(CompositeEventEmitter):
         if (pa_sync_handle := pa_sync.sync_handle) is None:
             raise core.InvalidStateError("PA Sync is not established")
 
-        with closing(EventWatcher()) as watcher:
+        with closing(utils.EventWatcher()) as watcher:
             big_sync = BigSync(
                 big_handle=big_handle,
                 parameters=parameters,
@@ -4648,7 +4678,7 @@ class Device(CompositeEventEmitter):
         Returns:
             LE features supported by the remote device.
         """
-        with closing(EventWatcher()) as watcher:
+        with closing(utils.EventWatcher()) as watcher:
             read_feature_future: asyncio.Future[hci.LeFeatureMask] = (
                 asyncio.get_running_loop().create_future()
             )
@@ -4671,7 +4701,7 @@ class Device(CompositeEventEmitter):
             )
             return await read_feature_future
 
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def get_remote_cs_capabilities(
         self, connection: Connection
     ) -> ChannelSoundingCapabilities:
@@ -4679,7 +4709,7 @@ class Device(CompositeEventEmitter):
             asyncio.get_running_loop().create_future()
         )
 
-        with closing(EventWatcher()) as watcher:
+        with closing(utils.EventWatcher()) as watcher:
             watcher.once(
                 connection, 'channel_sounding_capabilities', complete_future.set_result
             )
@@ -4696,7 +4726,7 @@ class Device(CompositeEventEmitter):
             )
             return await complete_future
 
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def set_default_cs_settings(
         self,
         connection: Connection,
@@ -4716,7 +4746,7 @@ class Device(CompositeEventEmitter):
             check_result=True,
         )
 
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def create_cs_config(
         self,
         connection: Connection,
@@ -4753,7 +4783,7 @@ class Device(CompositeEventEmitter):
         if config_id is None:
             raise OutOfResourcesError("No available config ID on this connection!")
 
-        with closing(EventWatcher()) as watcher:
+        with closing(utils.EventWatcher()) as watcher:
             watcher.once(
                 connection, 'channel_sounding_config', complete_future.set_result
             )
@@ -4787,12 +4817,12 @@ class Device(CompositeEventEmitter):
             )
             return await complete_future
 
-    @experimental('Only for testing.')
+    @utils.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:
+        with closing(utils.EventWatcher()) as watcher:
 
             def on_event(event: hci.HCI_LE_CS_Security_Enable_Complete_Event) -> None:
                 if event.connection_handle != connection.handle:
@@ -4811,7 +4841,7 @@ class Device(CompositeEventEmitter):
             )
             return await complete_future
 
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def set_cs_procedure_parameters(
         self,
         connection: Connection,
@@ -4849,7 +4879,7 @@ class Device(CompositeEventEmitter):
             check_result=True,
         )
 
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     async def enable_cs_procedure(
         self,
         connection: Connection,
@@ -4859,7 +4889,7 @@ class Device(CompositeEventEmitter):
         complete_future: asyncio.Future[ChannelSoundingProcedure] = (
             asyncio.get_running_loop().create_future()
         )
-        with closing(EventWatcher()) as watcher:
+        with closing(utils.EventWatcher()) as watcher:
             watcher.once(
                 connection, 'channel_sounding_procedure', complete_future.set_result
             )
@@ -4899,10 +4929,12 @@ class Device(CompositeEventEmitter):
                 value=link_key, authenticated=authenticated
             )
 
-            self.abort_on('flush', self.update_keys(str(bd_addr), pairing_keys))
+            utils.cancel_on_event(
+                self, 'flush', self.update_keys(str(bd_addr), pairing_keys)
+            )
 
         if connection := self.find_connection_by_bd_addr(
-            bd_addr, transport=BT_BR_EDR_TRANSPORT
+            bd_addr, transport=PhysicalTransport.BR_EDR
         ):
             connection.link_key_type = key_type
 
@@ -5168,7 +5200,7 @@ class Device(CompositeEventEmitter):
         if advertising_set.auto_restart:
             connection.once(
                 'disconnection',
-                lambda _: self.abort_on('flush', advertising_set.start()),
+                lambda _: utils.cancel_on_event(self, 'flush', advertising_set.start()),
             )
 
         self.emit('connection', connection)
@@ -5202,7 +5234,7 @@ class Device(CompositeEventEmitter):
                 'new connection reuses the same handle as a previous connection'
             )
 
-        if transport == BT_BR_EDR_TRANSPORT:
+        if transport == PhysicalTransport.BR_EDR:
             # Create a new connection
             connection = self.pending_connections.pop(peer_address)
             connection.complete(connection_handle, connection_parameters)
@@ -5225,7 +5257,7 @@ class Device(CompositeEventEmitter):
 
         self_address = None
         own_address_type: Optional[hci.OwnAddressType] = None
-        if role == hci.HCI_CENTRAL_ROLE:
+        if role == hci.Role.CENTRAL:
             own_address_type = self.connect_own_address_type
             assert own_address_type is not None
         else:
@@ -5272,22 +5304,22 @@ class Device(CompositeEventEmitter):
         )
         self.connections[connection_handle] = connection
 
-        if role == hci.HCI_PERIPHERAL_ROLE and self.legacy_advertiser:
+        if role == hci.Role.PERIPHERAL and self.legacy_advertiser:
             if self.legacy_advertiser.auto_restart:
                 advertiser = self.legacy_advertiser
                 connection.once(
                     'disconnection',
-                    lambda _: self.abort_on('flush', advertiser.start()),
+                    lambda _: utils.cancel_on_event(self, 'flush', advertiser.start()),
                 )
             else:
                 self.legacy_advertiser = None
 
-        if role == hci.HCI_CENTRAL_ROLE or not self.supports_le_extended_advertising:
+        if role == hci.Role.CENTRAL or not self.supports_le_extended_advertising:
             # We can emit now, we have all the info we need
             self.emit('connection', connection)
             return
 
-        if role == hci.HCI_PERIPHERAL_ROLE and self.supports_le_extended_advertising:
+        if role == hci.Role.PERIPHERAL and self.supports_le_extended_advertising:
             if advertising_set := self.connecting_extended_advertising_sets.pop(
                 connection_handle, None
             ):
@@ -5304,7 +5336,7 @@ class Device(CompositeEventEmitter):
 
         # For directed advertising, this means a timeout
         if (
-            transport == BT_LE_TRANSPORT
+            transport == PhysicalTransport.LE
             and self.legacy_advertiser
             and self.legacy_advertiser.advertising_type.is_directed
         ):
@@ -5331,7 +5363,7 @@ class Device(CompositeEventEmitter):
             hci.HCI_Connection_Complete_Event.ESCO_LINK_TYPE,
         ):
             if connection := self.find_connection_by_bd_addr(
-                bd_addr, transport=BT_BR_EDR_TRANSPORT
+                bd_addr, transport=PhysicalTransport.BR_EDR
             ):
                 self.emit('sco_request', connection, link_type)
             else:
@@ -5404,7 +5436,7 @@ class Device(CompositeEventEmitter):
         connection.emit('disconnection_failure', error)
 
     @host_event_handler
-    @AsyncRunner.run_in_task()
+    @utils.AsyncRunner.run_in_task()
     async def on_inquiry_complete(self):
         if self.auto_restart_inquiry:
             # Inquire again
@@ -5536,7 +5568,7 @@ class Device(CompositeEventEmitter):
 
         async def reply() -> None:
             try:
-                if await connection.abort_on('disconnection', method()):
+                if await utils.cancel_on_event(connection, 'disconnection', method()):
                     await self.host.send_command(
                         hci.HCI_User_Confirmation_Request_Reply_Command(
                             bd_addr=connection.peer_address
@@ -5552,7 +5584,7 @@ class Device(CompositeEventEmitter):
                 )
             )
 
-        AsyncRunner.spawn(reply())
+        utils.AsyncRunner.spawn(reply())
 
     # [Classic only]
     @host_event_handler
@@ -5563,8 +5595,8 @@ class Device(CompositeEventEmitter):
 
         async def reply() -> None:
             try:
-                number = await connection.abort_on(
-                    'disconnection', pairing_config.delegate.get_number()
+                number = await utils.cancel_on_event(
+                    connection, 'disconnection', pairing_config.delegate.get_number()
                 )
                 if number is not None:
                     await self.host.send_command(
@@ -5582,7 +5614,7 @@ class Device(CompositeEventEmitter):
                 )
             )
 
-        AsyncRunner.spawn(reply())
+        utils.AsyncRunner.spawn(reply())
 
     # [Classic only]
     @host_event_handler
@@ -5597,8 +5629,8 @@ class Device(CompositeEventEmitter):
         if io_capability == hci.HCI_KEYBOARD_ONLY_IO_CAPABILITY:
             # Ask the user to enter a string
             async def get_pin_code():
-                pin_code = await connection.abort_on(
-                    'disconnection', pairing_config.delegate.get_string(16)
+                pin_code = await utils.cancel_on_event(
+                    connection, 'disconnection', pairing_config.delegate.get_string(16)
                 )
 
                 if pin_code is not None:
@@ -5636,8 +5668,8 @@ class Device(CompositeEventEmitter):
         pairing_config = self.pairing_config_factory(connection)
 
         # Show the passkey to the user
-        connection.abort_on(
-            'disconnection', pairing_config.delegate.display_number(passkey)
+        utils.cancel_on_event(
+            connection, 'disconnection', pairing_config.delegate.display_number(passkey)
         )
 
     # [Classic only]
@@ -5669,7 +5701,7 @@ class Device(CompositeEventEmitter):
     # [Classic only]
     @host_event_handler
     @with_connection_from_address
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     def on_sco_connection(
         self, acl_connection: Connection, sco_handle: int, link_type: int
     ) -> None:
@@ -5689,7 +5721,7 @@ class Device(CompositeEventEmitter):
     # [Classic only]
     @host_event_handler
     @with_connection_from_address
-    @experimental('Only for testing.')
+    @utils.experimental('Only for testing.')
     def on_sco_connection_failure(
         self, acl_connection: Connection, status: int
     ) -> None:
@@ -5698,7 +5730,7 @@ class Device(CompositeEventEmitter):
 
     # [Classic only]
     @host_event_handler
-    @experimental('Only for testing')
+    @utils.experimental('Only for testing')
     def on_sco_packet(
         self, sco_handle: int, packet: hci.HCI_SynchronousDataPacket
     ) -> None:
@@ -5708,7 +5740,7 @@ class Device(CompositeEventEmitter):
     # [LE only]
     @host_event_handler
     @with_connection_from_handle
-    @experimental('Only for testing')
+    @utils.experimental('Only for testing')
     def on_cis_request(
         self,
         acl_connection: Connection,
@@ -5735,7 +5767,7 @@ class Device(CompositeEventEmitter):
 
     # [LE only]
     @host_event_handler
-    @experimental('Only for testing')
+    @utils.experimental('Only for testing')
     def on_cis_establishment(self, cis_handle: int) -> None:
         cis_link = self.cis_links[cis_handle]
         cis_link.state = CisLink.State.ESTABLISHED
@@ -5755,7 +5787,7 @@ class Device(CompositeEventEmitter):
 
     # [LE only]
     @host_event_handler
-    @experimental('Only for testing')
+    @utils.experimental('Only for testing')
     def on_cis_establishment_failure(self, cis_handle: int, status: int) -> None:
         logger.debug(f'*** CIS Establishment Failure: cis=[0x{cis_handle:04X}] ***')
         if cis_link := self.cis_links.pop(cis_handle):
@@ -5764,7 +5796,7 @@ class Device(CompositeEventEmitter):
 
     # [LE only]
     @host_event_handler
-    @experimental('Only for testing')
+    @utils.experimental('Only for testing')
     def on_iso_packet(self, handle: int, packet: hci.HCI_IsoDataPacket) -> None:
         if (cis_link := self.cis_links.get(handle)) and cis_link.sink:
             cis_link.sink(packet)
@@ -5782,14 +5814,14 @@ class Device(CompositeEventEmitter):
         connection.encryption = encryption
         if (
             not connection.authenticated
-            and connection.transport == BT_BR_EDR_TRANSPORT
+            and connection.transport == PhysicalTransport.BR_EDR
             and encryption == hci.HCI_Encryption_Change_Event.AES_CCM
         ):
             connection.authenticated = True
             connection.sc = True
         if (
             not connection.authenticated
-            and connection.transport == BT_LE_TRANSPORT
+            and connection.transport == PhysicalTransport.LE
             and encryption == hci.HCI_Encryption_Change_Event.E0_OR_AES_CCM
         ):
             connection.authenticated = True