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

bumble/device.py

@@ -61,7 +61,6 @@ from bumble.core import (
     BaseBumbleError,
     ConnectionParameterUpdateError,
     CommandTimeoutError,
-    ConnectionParameters,
     ConnectionPHY,
     InvalidArgumentError,
     InvalidOperationError,
@@ -484,7 +483,7 @@ class BIGInfoAdvertisement:
     sid: int
     num_bis: int
     nse: int
-    iso_interval: int
+    iso_interval: float
     bn: int
     pto: int
     irc: int
@@ -502,7 +501,7 @@ class BIGInfoAdvertisement:
             sid,
             report.num_bis,
             report.nse,
-            report.iso_interval,
+            report.iso_interval * 1.25,
             report.bn,
             report.pto,
             report.irc,
@@ -529,8 +528,8 @@ class AdvertisingParameters:
     advertising_event_properties: AdvertisingEventProperties = field(
         default_factory=AdvertisingEventProperties
     )
-    primary_advertising_interval_min: int = DEVICE_DEFAULT_ADVERTISING_INTERVAL
-    primary_advertising_interval_max: int = DEVICE_DEFAULT_ADVERTISING_INTERVAL
+    primary_advertising_interval_min: float = DEVICE_DEFAULT_ADVERTISING_INTERVAL
+    primary_advertising_interval_max: float = DEVICE_DEFAULT_ADVERTISING_INTERVAL
     primary_advertising_channel_map: (
         hci.HCI_LE_Set_Extended_Advertising_Parameters_Command.ChannelMap
     ) = (
@@ -554,8 +553,8 @@ class AdvertisingParameters:
 # -----------------------------------------------------------------------------
 @dataclass
 class PeriodicAdvertisingParameters:
-    periodic_advertising_interval_min: int = DEVICE_DEFAULT_ADVERTISING_INTERVAL
-    periodic_advertising_interval_max: int = DEVICE_DEFAULT_ADVERTISING_INTERVAL
+    periodic_advertising_interval_min: float = DEVICE_DEFAULT_ADVERTISING_INTERVAL
+    periodic_advertising_interval_max: float = DEVICE_DEFAULT_ADVERTISING_INTERVAL
     periodic_advertising_properties: (
         hci.HCI_LE_Set_Periodic_Advertising_Parameters_Command.Properties
     ) = field(
@@ -581,6 +580,12 @@ class AdvertisingSet(utils.EventEmitter):
     enabled: bool = False
     periodic_enabled: bool = False
 
+    EVENT_START = "start"
+    EVENT_STOP = "stop"
+    EVENT_START_PERIODIC = "start_periodic"
+    EVENT_STOP_PERIODIC = "stop_periodic"
+    EVENT_TERMINATION = "termination"
+
     def __post_init__(self) -> None:
         super().__init__()
 
@@ -679,8 +684,12 @@ class AdvertisingSet(utils.EventEmitter):
         await self.device.send_command(
             hci.HCI_LE_Set_Periodic_Advertising_Parameters_Command(
                 advertising_handle=self.advertising_handle,
-                periodic_advertising_interval_min=advertising_parameters.periodic_advertising_interval_min,
-                periodic_advertising_interval_max=advertising_parameters.periodic_advertising_interval_max,
+                periodic_advertising_interval_min=int(
+                    advertising_parameters.periodic_advertising_interval_min / 1.25
+                ),
+                periodic_advertising_interval_max=int(
+                    advertising_parameters.periodic_advertising_interval_max / 1.25
+                ),
                 periodic_advertising_properties=advertising_parameters.periodic_advertising_properties,
             ),
             check_result=True,
@@ -731,7 +740,7 @@ class AdvertisingSet(utils.EventEmitter):
         )
         self.enabled = True
 
-        self.emit('start')
+        self.emit(self.EVENT_START)
 
     async def stop(self) -> None:
         await self.device.send_command(
@@ -745,7 +754,7 @@ class AdvertisingSet(utils.EventEmitter):
         )
         self.enabled = False
 
-        self.emit('stop')
+        self.emit(self.EVENT_STOP)
 
     async def start_periodic(self, include_adi: bool = False) -> None:
         if self.periodic_enabled:
@@ -759,7 +768,7 @@ class AdvertisingSet(utils.EventEmitter):
         )
         self.periodic_enabled = True
 
-        self.emit('start_periodic')
+        self.emit(self.EVENT_START_PERIODIC)
 
     async def stop_periodic(self) -> None:
         if not self.periodic_enabled:
@@ -773,7 +782,7 @@ class AdvertisingSet(utils.EventEmitter):
         )
         self.periodic_enabled = False
 
-        self.emit('stop_periodic')
+        self.emit(self.EVENT_STOP_PERIODIC)
 
     async def remove(self) -> None:
         await self.device.send_command(
@@ -797,7 +806,7 @@ class AdvertisingSet(utils.EventEmitter):
 
     def on_termination(self, status: int) -> None:
         self.enabled = False
-        self.emit('termination', status)
+        self.emit(self.EVENT_TERMINATION, status)
 
 
 # -----------------------------------------------------------------------------
@@ -820,9 +829,17 @@ class PeriodicAdvertisingSync(utils.EventEmitter):
     filter_duplicates: bool
     status: int
     advertiser_phy: int
-    periodic_advertising_interval: int
+    periodic_advertising_interval: float  # Advertising interval, in milliseconds
     advertiser_clock_accuracy: int
 
+    EVENT_STATE_CHANGE = "state_change"
+    EVENT_ESTABLISHMENT = "establishment"
+    EVENT_CANCELLATION = "cancellation"
+    EVENT_ERROR = "error"
+    EVENT_LOSS = "loss"
+    EVENT_PERIODIC_ADVERTISEMENT = "periodic_advertisement"
+    EVENT_BIGINFO_ADVERTISEMENT = "biginfo_advertisement"
+
     def __init__(
         self,
         device: Device,
@@ -855,7 +872,7 @@ class PeriodicAdvertisingSync(utils.EventEmitter):
     def state(self, state: State) -> None:
         logger.debug(f'{self} -> {state.name}')
         self._state = state
-        self.emit('state_change')
+        self.emit(self.EVENT_STATE_CHANGE)
 
     async def establish(self) -> None:
         if self.state != self.State.INIT:
@@ -936,10 +953,10 @@ class PeriodicAdvertisingSync(utils.EventEmitter):
         if status == hci.HCI_SUCCESS:
             self.sync_handle = sync_handle
             self.advertiser_phy = advertiser_phy
-            self.periodic_advertising_interval = periodic_advertising_interval
+            self.periodic_advertising_interval = periodic_advertising_interval * 1.25
             self.advertiser_clock_accuracy = advertiser_clock_accuracy
             self.state = self.State.ESTABLISHED
-            self.emit('establishment')
+            self.emit(self.EVENT_ESTABLISHMENT)
             return
 
         # We don't need to keep a reference anymore
@@ -948,15 +965,15 @@ class PeriodicAdvertisingSync(utils.EventEmitter):
 
         if status == hci.HCI_OPERATION_CANCELLED_BY_HOST_ERROR:
             self.state = self.State.CANCELLED
-            self.emit('cancellation')
+            self.emit(self.EVENT_CANCELLATION)
             return
 
         self.state = self.State.ERROR
-        self.emit('error')
+        self.emit(self.EVENT_ERROR)
 
     def on_loss(self):
         self.state = self.State.LOST
-        self.emit('loss')
+        self.emit(self.EVENT_LOSS)
 
     def on_periodic_advertising_report(self, report) -> None:
         self.data_accumulator += report.data
@@ -967,7 +984,7 @@ class PeriodicAdvertisingSync(utils.EventEmitter):
             return
 
         self.emit(
-            'periodic_advertisement',
+            self.EVENT_PERIODIC_ADVERTISEMENT,
             PeriodicAdvertisement(
                 self.advertiser_address,
                 self.sid,
@@ -984,7 +1001,7 @@ class PeriodicAdvertisingSync(utils.EventEmitter):
 
     def on_biginfo_advertising_report(self, report) -> None:
         self.emit(
-            'biginfo_advertisement',
+            self.EVENT_BIGINFO_ADVERTISEMENT,
             BIGInfoAdvertisement.from_report(self.advertiser_address, self.sid, report),
         )
 
@@ -1041,7 +1058,7 @@ class Big(utils.EventEmitter):
     pto: int = 0
     irc: int = 0
     max_pdu: int = 0
-    iso_interval: int = 0
+    iso_interval: float = 0.0
     bis_links: Sequence[BisLink] = ()
 
     def __post_init__(self) -> None:
@@ -1102,7 +1119,7 @@ class BigSync(utils.EventEmitter):
     pto: int = 0
     irc: int = 0
     max_pdu: int = 0
-    iso_interval: int = 0
+    iso_interval: float = 0.0
     bis_links: Sequence[BisLink] = ()
 
     def __post_init__(self) -> None:
@@ -1183,11 +1200,11 @@ class ChannelSoundingProcedure:
     selected_tx_power: int
     subevent_len: int
     subevents_per_event: int
-    subevent_interval: int
+    subevent_interval: float  # milliseconds.
     event_interval: int
     procedure_interval: int
     procedure_count: int
-    max_procedure_len: int
+    max_procedure_len: float  # milliseconds.
 
 
 # -----------------------------------------------------------------------------
@@ -1212,9 +1229,8 @@ class Peer:
     def __init__(self, connection: Connection) -> None:
         self.connection = connection
 
-        # Create a GATT client for the connection
-        self.gatt_client = gatt_client.Client(connection)
-        connection.gatt_client = self.gatt_client
+        # Shortcut to the connection's GATT client
+        self.gatt_client = connection.gatt_client
 
     @property
     def services(self) -> list[gatt_client.ServiceProxy]:
@@ -1222,7 +1238,7 @@ class Peer:
 
     async def request_mtu(self, mtu: int) -> int:
         mtu = await self.gatt_client.request_mtu(mtu)
-        self.connection.emit('connection_att_mtu_update')
+        self.connection.emit(self.connection.EVENT_CONNECTION_ATT_MTU_UPDATE)
         return mtu
 
     async def discover_service(
@@ -1390,6 +1406,9 @@ class ScoLink(utils.CompositeEventEmitter):
     link_type: int
     sink: Optional[Callable[[hci.HCI_SynchronousDataPacket], Any]] = None
 
+    EVENT_DISCONNECTION: ClassVar[str] = "disconnection"
+    EVENT_DISCONNECTION_FAILURE: ClassVar[str] = "disconnection_failure"
+
     def __post_init__(self) -> None:
         super().__init__()
 
@@ -1487,6 +1506,11 @@ class CisLink(utils.EventEmitter, _IsoLink):
     state: State = State.PENDING
     sink: Callable[[hci.HCI_IsoDataPacket], Any] | None = None
 
+    EVENT_DISCONNECTION: ClassVar[str] = "disconnection"
+    EVENT_DISCONNECTION_FAILURE: ClassVar[str] = "disconnection_failure"
+    EVENT_ESTABLISHMENT: ClassVar[str] = "establishment"
+    EVENT_ESTABLISHMENT_FAILURE: ClassVar[str] = "establishment_failure"
+
     def __post_init__(self) -> None:
         super().__init__()
 
@@ -1562,15 +1586,50 @@ class Connection(utils.CompositeEventEmitter):
     peer_le_features: Optional[hci.LeFeatureMask]
     role: hci.Role
     encryption: int
+    encryption_key_size: int
     authenticated: bool
     sc: bool
-    link_key_type: int
     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
 
+    EVENT_CONNECTION_ATT_MTU_UPDATE = "connection_att_mtu_update"
+    EVENT_DISCONNECTION = "disconnection"
+    EVENT_DISCONNECTION_FAILURE = "disconnection_failure"
+    EVENT_CONNECTION_AUTHENTICATION = "connection_authentication"
+    EVENT_CONNECTION_AUTHENTICATION_FAILURE = "connection_authentication_failure"
+    EVENT_REMOTE_NAME = "remote_name"
+    EVENT_REMOTE_NAME_FAILURE = "remote_name_failure"
+    EVENT_CONNECTION_ENCRYPTION_CHANGE = "connection_encryption_change"
+    EVENT_CONNECTION_ENCRYPTION_FAILURE = "connection_encryption_failure"
+    EVENT_CONNECTION_ENCRYPTION_KEY_REFRESH = "connection_encryption_key_refresh"
+    EVENT_CONNECTION_PARAMETERS_UPDATE = "connection_parameters_update"
+    EVENT_CONNECTION_PARAMETERS_UPDATE_FAILURE = "connection_parameters_update_failure"
+    EVENT_CONNECTION_PHY_UPDATE = "connection_phy_update"
+    EVENT_CONNECTION_PHY_UPDATE_FAILURE = "connection_phy_update_failure"
+    EVENT_CONNECTION_ATT_MTU_UPDATE = "connection_att_mtu_update"
+    EVENT_CONNECTION_DATA_LENGTH_CHANGE = "connection_data_length_change"
+    EVENT_CHANNEL_SOUNDING_CAPABILITIES_FAILURE = (
+        "channel_sounding_capabilities_failure"
+    )
+    EVENT_CHANNEL_SOUNDING_CAPABILITIES = "channel_sounding_capabilities"
+    EVENT_CHANNEL_SOUNDING_CONFIG_FAILURE = "channel_sounding_config_failure"
+    EVENT_CHANNEL_SOUNDING_CONFIG = "channel_sounding_config"
+    EVENT_CHANNEL_SOUNDING_CONFIG_REMOVED = "channel_sounding_config_removed"
+    EVENT_CHANNEL_SOUNDING_PROCEDURE_FAILURE = "channel_sounding_procedure_failure"
+    EVENT_CHANNEL_SOUNDING_PROCEDURE = "channel_sounding_procedure"
+    EVENT_ROLE_CHANGE = "role_change"
+    EVENT_ROLE_CHANGE_FAILURE = "role_change_failure"
+    EVENT_CLASSIC_PAIRING = "classic_pairing"
+    EVENT_CLASSIC_PAIRING_FAILURE = "classic_pairing_failure"
+    EVENT_PAIRING_START = "pairing_start"
+    EVENT_PAIRING = "pairing"
+    EVENT_PAIRING_FAILURE = "pairing_failure"
+    EVENT_SECURITY_REQUEST = "security_request"
+    EVENT_LINK_KEY = "link_key"
+
     @utils.composite_listener
     class Listener:
         def on_disconnection(self, reason):
@@ -1600,17 +1659,23 @@ class Connection(utils.CompositeEventEmitter):
         def on_connection_encryption_key_refresh(self):
             pass
 
+    @dataclass
+    class Parameters:
+        connection_interval: float  # Connection interval, in milliseconds. [LE only]
+        peripheral_latency: int  # Peripheral latency, in number of intervals. [LE only]
+        supervision_timeout: float  # Supervision timeout, in milliseconds.
+
     def __init__(
         self,
-        device,
-        handle,
-        transport,
-        self_address,
-        self_resolvable_address,
-        peer_address,
-        peer_resolvable_address,
-        role,
-        parameters,
+        device: Device,
+        handle: int,
+        transport: core.PhysicalTransport,
+        self_address: hci.Address,
+        self_resolvable_address: Optional[hci.Address],
+        peer_address: hci.Address,
+        peer_resolvable_address: Optional[hci.Address],
+        role: hci.Role,
+        parameters: Parameters,
     ):
         super().__init__()
         self.device = device
@@ -1624,12 +1689,12 @@ class Connection(utils.CompositeEventEmitter):
         self.role = role
         self.parameters = parameters
         self.encryption = 0
+        self.encryption_key_size = 0
         self.authenticated = False
         self.sc = False
-        self.link_key_type = None
         self.att_mtu = ATT_DEFAULT_MTU
         self.data_length = DEVICE_DEFAULT_DATA_LENGTH
-        self.gatt_client = None  # Per-connection client
+        self.gatt_client = gatt_client.Client(self)  # Per-connection client
         self.gatt_server = (
             device.gatt_server
         )  # By default, use the device's shared server
@@ -1740,28 +1805,38 @@ class Connection(utils.CompositeEventEmitter):
         """Idles the current task waiting for a disconnect or timeout"""
 
         abort = asyncio.get_running_loop().create_future()
-        self.on('disconnection', abort.set_result)
-        self.on('disconnection_failure', abort.set_exception)
+        self.on(self.EVENT_DISCONNECTION, abort.set_result)
+        self.on(self.EVENT_DISCONNECTION_FAILURE, abort.set_exception)
 
         try:
             await asyncio.wait_for(
-                utils.cancel_on_event(self.device, 'flush', abort), timeout
+                utils.cancel_on_event(self.device, Device.EVENT_FLUSH, abort), timeout
             )
         finally:
-            self.remove_listener('disconnection', abort.set_result)
-            self.remove_listener('disconnection_failure', abort.set_exception)
+            self.remove_listener(self.EVENT_DISCONNECTION, abort.set_result)
+            self.remove_listener(self.EVENT_DISCONNECTION_FAILURE, abort.set_exception)
 
     async def set_data_length(self, tx_octets, tx_time) -> None:
         return await self.device.set_data_length(self, tx_octets, tx_time)
 
     async def update_parameters(
         self,
-        connection_interval_min,
-        connection_interval_max,
-        max_latency,
-        supervision_timeout,
+        connection_interval_min: float,
+        connection_interval_max: float,
+        max_latency: int,
+        supervision_timeout: float,
         use_l2cap=False,
-    ):
+    ) -> None:
+        """
+        Request an update of the connection parameters.
+
+        Args:
+          connection_interval_min: Minimum interval, in milliseconds.
+          connection_interval_max: Maximum interval, in milliseconds.
+          max_latency: Latency, in number of intervals.
+          supervision_timeout: Timeout, in milliseconds.
+          use_l2cap: Request the update via L2CAP.
+        """
         return await self.device.update_connection_parameters(
             self,
             connection_interval_min,
@@ -1848,8 +1923,8 @@ class DeviceConfiguration:
     address: hci.Address = hci.Address(DEVICE_DEFAULT_ADDRESS)
     class_of_device: int = DEVICE_DEFAULT_CLASS_OF_DEVICE
     scan_response_data: bytes = DEVICE_DEFAULT_SCAN_RESPONSE_DATA
-    advertising_interval_min: int = DEVICE_DEFAULT_ADVERTISING_INTERVAL
-    advertising_interval_max: int = DEVICE_DEFAULT_ADVERTISING_INTERVAL
+    advertising_interval_min: float = DEVICE_DEFAULT_ADVERTISING_INTERVAL
+    advertising_interval_max: float = DEVICE_DEFAULT_ADVERTISING_INTERVAL
     le_enabled: bool = True
     le_simultaneous_enabled: bool = False
     le_privacy_enabled: bool = False
@@ -2062,6 +2137,26 @@ class Device(utils.CompositeEventEmitter):
     _pending_cis: Dict[int, tuple[int, int]]
     gatt_service: gatt_service.GenericAttributeProfileService | None = None
 
+    EVENT_ADVERTISEMENT = "advertisement"
+    EVENT_PERIODIC_ADVERTISING_SYNC_TRANSFER = "periodic_advertising_sync_transfer"
+    EVENT_KEY_STORE_UPDATE = "key_store_update"
+    EVENT_FLUSH = "flush"
+    EVENT_CONNECTION = "connection"
+    EVENT_CONNECTION_FAILURE = "connection_failure"
+    EVENT_SCO_REQUEST = "sco_request"
+    EVENT_INQUIRY_COMPLETE = "inquiry_complete"
+    EVENT_REMOTE_NAME = "remote_name"
+    EVENT_REMOTE_NAME_FAILURE = "remote_name_failure"
+    EVENT_SCO_CONNECTION = "sco_connection"
+    EVENT_SCO_CONNECTION_FAILURE = "sco_connection_failure"
+    EVENT_CIS_REQUEST = "cis_request"
+    EVENT_CIS_ESTABLISHMENT = "cis_establishment"
+    EVENT_CIS_ESTABLISHMENT_FAILURE = "cis_establishment_failure"
+    EVENT_ROLE_CHANGE_FAILURE = "role_change_failure"
+    EVENT_INQUIRY_RESULT = "inquiry_result"
+    EVENT_REMOTE_NAME = "remote_name"
+    EVENT_REMOTE_NAME_FAILURE = "remote_name_failure"
+
     @utils.composite_listener
     class Listener:
         def on_advertisement(self, advertisement):
@@ -2748,8 +2843,8 @@ class Device(utils.CompositeEventEmitter):
         auto_restart: bool = False,
         advertising_data: Optional[bytes] = None,
         scan_response_data: Optional[bytes] = None,
-        advertising_interval_min: Optional[int] = None,
-        advertising_interval_max: Optional[int] = None,
+        advertising_interval_min: Optional[float] = None,
+        advertising_interval_max: Optional[float] = None,
     ) -> None:
         """Start legacy advertising.
 
@@ -3149,7 +3244,7 @@ class Device(utils.CompositeEventEmitter):
             accumulator = AdvertisementDataAccumulator(passive=self.scanning_is_passive)
             self.advertisement_accumulators[report.address] = accumulator
         if advertisement := accumulator.update(report):
-            self.emit('advertisement', advertisement)
+            self.emit(self.EVENT_ADVERTISEMENT, advertisement)
 
     async def create_periodic_advertising_sync(
         self,
@@ -3273,7 +3368,7 @@ class Device(utils.CompositeEventEmitter):
             periodic_advertising_interval=periodic_advertising_interval,
             advertiser_clock_accuracy=advertiser_clock_accuracy,
         )
-        self.emit('periodic_advertising_sync_transfer', pa_sync, connection)
+        self.emit(self.EVENT_PERIODIC_ADVERTISING_SYNC_TRANSFER, pa_sync, connection)
 
     @host_event_handler
     @with_periodic_advertising_sync_from_handle
@@ -3331,7 +3426,7 @@ class Device(utils.CompositeEventEmitter):
     @host_event_handler
     def on_inquiry_result(self, address, class_of_device, data, rssi):
         self.emit(
-            'inquiry_result',
+            self.EVENT_INQUIRY_RESULT,
             address,
             class_of_device,
             AdvertisingData.from_bytes(data),
@@ -3508,8 +3603,8 @@ class Device(utils.CompositeEventEmitter):
 
         # Create a future so that we can wait for the connection's result
         pending_connection = asyncio.get_running_loop().create_future()
-        self.on('connection', on_connection)
-        self.on('connection_failure', on_connection_failure)
+        self.on(self.EVENT_CONNECTION, on_connection)
+        self.on(self.EVENT_CONNECTION_FAILURE, on_connection_failure)
 
         try:
             # Tell the controller to connect
@@ -3662,7 +3757,9 @@ class Device(utils.CompositeEventEmitter):
                 self.le_connecting = True
 
             if timeout is None:
-                return await utils.cancel_on_event(self, 'flush', pending_connection)
+                return await utils.cancel_on_event(
+                    self, Device.EVENT_FLUSH, pending_connection
+                )
 
             try:
                 return await asyncio.wait_for(
@@ -3680,13 +3777,13 @@ class Device(utils.CompositeEventEmitter):
 
                 try:
                     return await utils.cancel_on_event(
-                        self, 'flush', pending_connection
+                        self, Device.EVENT_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)
+            self.remove_listener(self.EVENT_CONNECTION, on_connection)
+            self.remove_listener(self.EVENT_CONNECTION_FAILURE, on_connection_failure)
             if transport == PhysicalTransport.LE:
                 self.le_connecting = False
                 self.connect_own_address_type = None
@@ -3737,7 +3834,9 @@ class Device(utils.CompositeEventEmitter):
 
         try:
             # Wait for a request or a completed connection
-            pending_request = utils.cancel_on_event(self, 'flush', pending_request_fut)
+            pending_request = utils.cancel_on_event(
+                self, Device.EVENT_FLUSH, pending_request_fut
+            )
             result = await (
                 asyncio.wait_for(pending_request, timeout)
                 if timeout
@@ -3779,8 +3878,8 @@ class Device(utils.CompositeEventEmitter):
             ):
                 pending_connection.set_exception(error)
 
-        self.on('connection', on_connection)
-        self.on('connection_failure', on_connection_failure)
+        self.on(self.EVENT_CONNECTION, on_connection)
+        self.on(self.EVENT_CONNECTION_FAILURE, on_connection_failure)
 
         # Save pending connection, with the Peripheral hci.role.
         # Even if we requested a role switch in the hci.HCI_Accept_Connection_Request
@@ -3799,11 +3898,13 @@ class Device(utils.CompositeEventEmitter):
             )
 
             # Wait for connection complete
-            return await utils.cancel_on_event(self, 'flush', pending_connection)
+            return await utils.cancel_on_event(
+                self, Device.EVENT_FLUSH, pending_connection
+            )
 
         finally:
-            self.remove_listener('connection', on_connection)
-            self.remove_listener('connection_failure', on_connection_failure)
+            self.remove_listener(self.EVENT_CONNECTION, on_connection)
+            self.remove_listener(self.EVENT_CONNECTION_FAILURE, on_connection_failure)
             self.pending_connections.pop(peer_address, None)
 
     @asynccontextmanager
@@ -3857,8 +3958,10 @@ class Device(utils.CompositeEventEmitter):
     ) -> None:
         # Create a future so that we can wait for the disconnection's result
         pending_disconnection = asyncio.get_running_loop().create_future()
-        connection.on('disconnection', pending_disconnection.set_result)
-        connection.on('disconnection_failure', pending_disconnection.set_exception)
+        connection.on(connection.EVENT_DISCONNECTION, pending_disconnection.set_result)
+        connection.on(
+            connection.EVENT_DISCONNECTION_FAILURE, pending_disconnection.set_exception
+        )
 
         # Request a disconnection
         result = await self.send_command(
@@ -3873,13 +3976,16 @@ class Device(utils.CompositeEventEmitter):
 
             # Wait for the disconnection process to complete
             self.disconnecting = True
-            return await utils.cancel_on_event(self, 'flush', pending_disconnection)
+            return await utils.cancel_on_event(
+                self, Device.EVENT_FLUSH, pending_disconnection
+            )
         finally:
             connection.remove_listener(
-                'disconnection', pending_disconnection.set_result
+                connection.EVENT_DISCONNECTION, pending_disconnection.set_result
             )
             connection.remove_listener(
-                'disconnection_failure', pending_disconnection.set_exception
+                connection.EVENT_DISCONNECTION_FAILURE,
+                pending_disconnection.set_exception,
             )
             self.disconnecting = False
 
@@ -3901,20 +4007,39 @@ class Device(utils.CompositeEventEmitter):
 
     async def update_connection_parameters(
         self,
-        connection,
-        connection_interval_min,
-        connection_interval_max,
-        max_latency,
-        supervision_timeout,
-        min_ce_length=0,
-        max_ce_length=0,
-        use_l2cap=False,
+        connection: Connection,
+        connection_interval_min: float,
+        connection_interval_max: float,
+        max_latency: int,
+        supervision_timeout: float,
+        min_ce_length: float = 0.0,
+        max_ce_length: float = 0.0,
+        use_l2cap: bool = False,
     ) -> None:
         '''
+        Request an update of the connection parameters.
+
+        Args:
+          connection: The connection to update
+          connection_interval_min: Minimum interval, in milliseconds.
+          connection_interval_max: Maximum interval, in milliseconds.
+          max_latency: Latency, in number of intervals.
+          supervision_timeout: Timeout, in milliseconds.
+          min_ce_length: Minimum connection event length, in milliseconds.
+          max_ce_length: Maximum connection event length, in milliseconds.
+          use_l2cap: Request the update via L2CAP.
+
         NOTE: the name of the parameters may look odd, but it just follows the names
         used in the Bluetooth spec.
         '''
 
+        # Convert the input parameters
+        connection_interval_min = int(connection_interval_min / 1.25)
+        connection_interval_max = int(connection_interval_max / 1.25)
+        supervision_timeout = int(supervision_timeout / 10)
+        min_ce_length = int(min_ce_length / 0.625)
+        max_ce_length = int(max_ce_length / 0.625)
+
         if use_l2cap:
             if connection.role != hci.Role.PERIPHERAL:
                 raise InvalidStateError(
@@ -3932,6 +4057,8 @@ class Device(utils.CompositeEventEmitter):
             if l2cap_result != l2cap.L2CAP_CONNECTION_PARAMETERS_ACCEPTED_RESULT:
                 raise ConnectionParameterUpdateError(l2cap_result)
 
+            return
+
         result = await self.send_command(
             hci.HCI_LE_Connection_Update_Command(
                 connection_handle=connection.handle,
@@ -3953,6 +4080,9 @@ class Device(utils.CompositeEventEmitter):
         return result.return_parameters.rssi
 
     async def get_connection_phy(self, connection: Connection) -> ConnectionPHY:
+        if not self.host.supports_command(hci.HCI_LE_READ_PHY_COMMAND):
+            return ConnectionPHY(hci.Phy.LE_1M, hci.Phy.LE_1M)
+
         result = await self.send_command(
             hci.HCI_LE_Read_PHY_Command(connection_handle=connection.handle),
             check_result=True,
@@ -4072,7 +4202,7 @@ class Device(utils.CompositeEventEmitter):
             else:
                 return None
 
-            return await utils.cancel_on_event(self, 'flush', peer_address)
+            return await utils.cancel_on_event(self, Device.EVENT_FLUSH, peer_address)
         finally:
             if listener is not None:
                 self.remove_listener(event_name, listener)
@@ -4122,7 +4252,7 @@ class Device(utils.CompositeEventEmitter):
             if not self.scanning:
                 await self.start_scanning(filter_duplicates=True)
 
-            return await utils.cancel_on_event(self, 'flush', peer_address)
+            return await utils.cancel_on_event(self, Device.EVENT_FLUSH, peer_address)
         finally:
             if listener is not None:
                 self.remove_listener(event_name, listener)
@@ -4198,7 +4328,7 @@ class Device(utils.CompositeEventEmitter):
         return keys.link_key.value
 
     # [Classic only]
-    async def authenticate(self, connection):
+    async def authenticate(self, connection: Connection) -> None:
         # Set up event handlers
         pending_authentication = asyncio.get_running_loop().create_future()
 
@@ -4208,8 +4338,11 @@ class Device(utils.CompositeEventEmitter):
         def on_authentication_failure(error_code):
             pending_authentication.set_exception(hci.HCI_Error(error_code))
 
-        connection.on('connection_authentication', on_authentication)
-        connection.on('connection_authentication_failure', on_authentication_failure)
+        connection.on(connection.EVENT_CONNECTION_AUTHENTICATION, on_authentication)
+        connection.on(
+            connection.EVENT_CONNECTION_AUTHENTICATION_FAILURE,
+            on_authentication_failure,
+        )
 
         # Request the authentication
         try:
@@ -4227,12 +4360,15 @@ class Device(utils.CompositeEventEmitter):
 
             # Wait for the authentication to complete
             await utils.cancel_on_event(
-                connection, 'disconnection', pending_authentication
+                connection, Connection.EVENT_DISCONNECTION, pending_authentication
             )
         finally:
-            connection.remove_listener('connection_authentication', on_authentication)
             connection.remove_listener(
-                'connection_authentication_failure', on_authentication_failure
+                connection.EVENT_CONNECTION_AUTHENTICATION, on_authentication
+            )
+            connection.remove_listener(
+                connection.EVENT_CONNECTION_AUTHENTICATION_FAILURE,
+                on_authentication_failure,
             )
 
     async def encrypt(self, connection, enable=True):
@@ -4248,8 +4384,12 @@ class Device(utils.CompositeEventEmitter):
         def on_encryption_failure(error_code):
             pending_encryption.set_exception(hci.HCI_Error(error_code))
 
-        connection.on('connection_encryption_change', on_encryption_change)
-        connection.on('connection_encryption_failure', on_encryption_failure)
+        connection.on(
+            connection.EVENT_CONNECTION_ENCRYPTION_CHANGE, on_encryption_change
+        )
+        connection.on(
+            connection.EVENT_CONNECTION_ENCRYPTION_FAILURE, on_encryption_failure
+        )
 
         # Request the encryption
         try:
@@ -4308,13 +4448,15 @@ class Device(utils.CompositeEventEmitter):
                     raise hci.HCI_StatusError(result)
 
             # Wait for the result
-            await utils.cancel_on_event(connection, 'disconnection', pending_encryption)
+            await utils.cancel_on_event(
+                connection, Connection.EVENT_DISCONNECTION, pending_encryption
+            )
         finally:
             connection.remove_listener(
-                'connection_encryption_change', on_encryption_change
+                connection.EVENT_CONNECTION_ENCRYPTION_CHANGE, on_encryption_change
             )
             connection.remove_listener(
-                'connection_encryption_failure', on_encryption_failure
+                connection.EVENT_CONNECTION_ENCRYPTION_FAILURE, on_encryption_failure
             )
 
     async def update_keys(self, address: str, keys: PairingKeys) -> None:
@@ -4327,7 +4469,7 @@ class Device(utils.CompositeEventEmitter):
         except Exception as error:
             logger.warning(f'!!! error while storing keys: {error}')
         else:
-            self.emit('key_store_update')
+            self.emit(self.EVENT_KEY_STORE_UPDATE)
 
     # [Classic only]
     async def switch_role(self, connection: Connection, role: hci.Role):
@@ -4339,8 +4481,8 @@ class Device(utils.CompositeEventEmitter):
         def on_role_change_failure(error_code):
             pending_role_change.set_exception(hci.HCI_Error(error_code))
 
-        connection.on('role_change', on_role_change)
-        connection.on('role_change_failure', on_role_change_failure)
+        connection.on(connection.EVENT_ROLE_CHANGE, on_role_change)
+        connection.on(connection.EVENT_ROLE_CHANGE_FAILURE, on_role_change_failure)
 
         try:
             result = await self.send_command(
@@ -4353,11 +4495,13 @@ class Device(utils.CompositeEventEmitter):
                 )
                 raise hci.HCI_StatusError(result)
             await utils.cancel_on_event(
-                connection, 'disconnection', pending_role_change
+                connection, Connection.EVENT_DISCONNECTION, pending_role_change
             )
         finally:
-            connection.remove_listener('role_change', on_role_change)
-            connection.remove_listener('role_change_failure', on_role_change_failure)
+            connection.remove_listener(connection.EVENT_ROLE_CHANGE, on_role_change)
+            connection.remove_listener(
+                connection.EVENT_ROLE_CHANGE_FAILURE, on_role_change_failure
+            )
 
     # [Classic only]
     async def request_remote_name(self, remote: Union[hci.Address, Connection]) -> str:
@@ -4369,7 +4513,7 @@ class Device(utils.CompositeEventEmitter):
         )
 
         handler = self.on(
-            'remote_name',
+            self.EVENT_REMOTE_NAME,
             lambda address, remote_name: (
                 pending_name.set_result(remote_name)
                 if address == peer_address
@@ -4377,7 +4521,7 @@ class Device(utils.CompositeEventEmitter):
             ),
         )
         failure_handler = self.on(
-            'remote_name_failure',
+            self.EVENT_REMOTE_NAME_FAILURE,
             lambda address, error_code: (
                 pending_name.set_exception(hci.HCI_Error(error_code))
                 if address == peer_address
@@ -4403,10 +4547,10 @@ class Device(utils.CompositeEventEmitter):
                 raise hci.HCI_StatusError(result)
 
             # Wait for the result
-            return await utils.cancel_on_event(self, 'flush', pending_name)
+            return await utils.cancel_on_event(self, Device.EVENT_FLUSH, pending_name)
         finally:
-            self.remove_listener('remote_name', handler)
-            self.remove_listener('remote_name_failure', failure_handler)
+            self.remove_listener(self.EVENT_REMOTE_NAME, handler)
+            self.remove_listener(self.EVENT_REMOTE_NAME_FAILURE, failure_handler)
 
     # [LE only]
     @utils.experimental('Only for testing.')
@@ -4497,8 +4641,10 @@ class Device(utils.CompositeEventEmitter):
                 if pending_future := pending_cis_establishments.get(cis_handle):
                     pending_future.set_exception(hci.HCI_Error(status))
 
-            watcher.on(self, 'cis_establishment', on_cis_establishment)
-            watcher.on(self, 'cis_establishment_failure', on_cis_establishment_failure)
+            watcher.on(self, self.EVENT_CIS_ESTABLISHMENT, on_cis_establishment)
+            watcher.on(
+                self, self.EVENT_CIS_ESTABLISHMENT_FAILURE, on_cis_establishment_failure
+            )
             await self.send_command(
                 hci.HCI_LE_Create_CIS_Command(
                     cis_connection_handle=[p[0] for p in cis_acl_pairs],
@@ -4541,8 +4687,12 @@ class Device(utils.CompositeEventEmitter):
                 def on_establishment_failure(status: int) -> None:
                     pending_establishment.set_exception(hci.HCI_Error(status))
 
-                watcher.on(cis_link, 'establishment', on_establishment)
-                watcher.on(cis_link, 'establishment_failure', on_establishment_failure)
+                watcher.on(cis_link, cis_link.EVENT_ESTABLISHMENT, on_establishment)
+                watcher.on(
+                    cis_link,
+                    cis_link.EVENT_ESTABLISHMENT_FAILURE,
+                    on_establishment_failure,
+                )
 
                 await self.send_command(
                     hci.HCI_LE_Accept_CIS_Request_Command(connection_handle=handle),
@@ -4910,33 +5060,33 @@ class Device(utils.CompositeEventEmitter):
 
     @host_event_handler
     def on_flush(self):
-        self.emit('flush')
+        self.emit(self.EVENT_FLUSH)
         for _, connection in self.connections.items():
-            connection.emit('disconnection', 0)
+            connection.emit(connection.EVENT_DISCONNECTION, 0)
         self.connections = {}
 
     # [Classic only]
     @host_event_handler
-    def on_link_key(self, bd_addr, link_key, key_type):
+    def on_link_key(self, bd_addr: hci.Address, link_key: bytes, key_type: int) -> None:
         # Store the keys in the key store
         if self.keystore:
             authenticated = key_type in (
                 hci.HCI_AUTHENTICATED_COMBINATION_KEY_GENERATED_FROM_P_192_TYPE,
                 hci.HCI_AUTHENTICATED_COMBINATION_KEY_GENERATED_FROM_P_256_TYPE,
             )
-            pairing_keys = PairingKeys()
-            pairing_keys.link_key = PairingKeys.Key(
-                value=link_key, authenticated=authenticated
+            pairing_keys = PairingKeys(
+                link_key=PairingKeys.Key(value=link_key, authenticated=authenticated),
+                link_key_type=key_type,
             )
 
             utils.cancel_on_event(
-                self, 'flush', self.update_keys(str(bd_addr), pairing_keys)
+                self, Device.EVENT_FLUSH, self.update_keys(str(bd_addr), pairing_keys)
             )
 
         if connection := self.find_connection_by_bd_addr(
             bd_addr, transport=PhysicalTransport.BR_EDR
         ):
-            connection.link_key_type = key_type
+            connection.emit(connection.EVENT_LINK_KEY)
 
     def add_service(self, service):
         self.gatt_server.add_service(service)
@@ -5108,7 +5258,7 @@ class Device(utils.CompositeEventEmitter):
         big.pto = pto
         big.irc = irc
         big.max_pdu = max_pdu
-        big.iso_interval = iso_interval
+        big.iso_interval = iso_interval * 1.25
         big.state = Big.State.ACTIVE
 
         for bis_link in big.bis_links:
@@ -5157,7 +5307,7 @@ class Device(utils.CompositeEventEmitter):
         big_sync.pto = pto
         big_sync.irc = irc
         big_sync.max_pdu = max_pdu
-        big_sync.iso_interval = iso_interval
+        big_sync.iso_interval = iso_interval * 1.25
         big_sync.bis_links = [
             BisLink(handle=handle, big=big_sync) for handle in bis_handles
         ]
@@ -5199,11 +5349,13 @@ class Device(utils.CompositeEventEmitter):
         # Setup auto-restart of the advertising set if needed.
         if advertising_set.auto_restart:
             connection.once(
-                'disconnection',
-                lambda _: utils.cancel_on_event(self, 'flush', advertising_set.start()),
+                Connection.EVENT_DISCONNECTION,
+                lambda _: utils.cancel_on_event(
+                    self, Device.EVENT_FLUSH, advertising_set.start()
+                ),
             )
 
-        self.emit('connection', connection)
+        self.emit(self.EVENT_CONNECTION, connection)
 
     @host_event_handler
     def on_connection(
@@ -5214,7 +5366,7 @@ class Device(utils.CompositeEventEmitter):
         self_resolvable_address: Optional[hci.Address],
         peer_resolvable_address: Optional[hci.Address],
         role: hci.Role,
-        connection_parameters: ConnectionParameters,
+        connection_parameters: Optional[core.ConnectionParameters],
     ) -> None:
         # Convert all-zeros addresses into None.
         if self_resolvable_address == hci.Address.ANY_RANDOM:
@@ -5241,10 +5393,12 @@ class Device(utils.CompositeEventEmitter):
             self.connections[connection_handle] = connection
 
             # Emit an event to notify listeners of the new connection
-            self.emit('connection', connection)
+            self.emit(self.EVENT_CONNECTION, connection)
 
             return
 
+        assert connection_parameters is not None
+
         if peer_resolvable_address is None:
             # Resolve the peer address if we can
             if self.address_resolver:
@@ -5300,7 +5454,11 @@ class Device(utils.CompositeEventEmitter):
             peer_address,
             peer_resolvable_address,
             role,
-            connection_parameters,
+            Connection.Parameters(
+                connection_parameters.connection_interval * 1.25,
+                connection_parameters.peripheral_latency,
+                connection_parameters.supervision_timeout * 10.0,
+            ),
         )
         self.connections[connection_handle] = connection
 
@@ -5308,15 +5466,17 @@ class Device(utils.CompositeEventEmitter):
             if self.legacy_advertiser.auto_restart:
                 advertiser = self.legacy_advertiser
                 connection.once(
-                    'disconnection',
-                    lambda _: utils.cancel_on_event(self, 'flush', advertiser.start()),
+                    Connection.EVENT_DISCONNECTION,
+                    lambda _: utils.cancel_on_event(
+                        self, Device.EVENT_FLUSH, advertiser.start()
+                    ),
                 )
             else:
                 self.legacy_advertiser = None
 
         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)
+            self.emit(self.EVENT_CONNECTION, connection)
             return
 
         if role == hci.Role.PERIPHERAL and self.supports_le_extended_advertising:
@@ -5350,7 +5510,7 @@ class Device(utils.CompositeEventEmitter):
             'hci',
             hci.HCI_Constant.error_name(error_code),
         )
-        self.emit('connection_failure', error)
+        self.emit(self.EVENT_CONNECTION_FAILURE, error)
 
     # FIXME: Explore a delegate-model for BR/EDR wait connection #56.
     @host_event_handler
@@ -5365,7 +5525,7 @@ class Device(utils.CompositeEventEmitter):
             if connection := self.find_connection_by_bd_addr(
                 bd_addr, transport=PhysicalTransport.BR_EDR
             ):
-                self.emit('sco_request', connection, link_type)
+                self.emit(self.EVENT_SCO_REQUEST, connection, link_type)
             else:
                 logger.error(f'SCO request from a non-connected device {bd_addr}')
             return
@@ -5409,14 +5569,14 @@ class Device(utils.CompositeEventEmitter):
                 f'*** Disconnection: [0x{connection.handle:04X}] '
                 f'{connection.peer_address} as {connection.role_name}, reason={reason}'
             )
-            connection.emit('disconnection', reason)
+            connection.emit(connection.EVENT_DISCONNECTION, reason)
 
             # Cleanup subsystems that maintain per-connection state
             self.gatt_server.on_disconnection(connection)
         elif sco_link := self.sco_links.pop(connection_handle, None):
-            sco_link.emit('disconnection', reason)
+            sco_link.emit(sco_link.EVENT_DISCONNECTION, reason)
         elif cis_link := self.cis_links.pop(connection_handle, None):
-            cis_link.emit('disconnection', reason)
+            cis_link.emit(cis_link.EVENT_DISCONNECTION, reason)
         else:
             logger.error(
                 f'*** Unknown disconnection handle=0x{connection_handle}, reason={reason} ***'
@@ -5424,7 +5584,7 @@ class Device(utils.CompositeEventEmitter):
 
     @host_event_handler
     @with_connection_from_handle
-    def on_disconnection_failure(self, connection, error_code):
+    def on_disconnection_failure(self, connection: Connection, error_code: int):
         logger.debug(f'*** Disconnection failed: {error_code}')
         error = core.ConnectionError(
             error_code,
@@ -5433,7 +5593,7 @@ class Device(utils.CompositeEventEmitter):
             'hci',
             hci.HCI_Constant.error_name(error_code),
         )
-        connection.emit('disconnection_failure', error)
+        connection.emit(connection.EVENT_DISCONNECTION_FAILURE, error)
 
     @host_event_handler
     @utils.AsyncRunner.run_in_task()
@@ -5444,7 +5604,7 @@ class Device(utils.CompositeEventEmitter):
         else:
             self.auto_restart_inquiry = True
             self.discovering = False
-            self.emit('inquiry_complete')
+            self.emit(self.EVENT_INQUIRY_COMPLETE)
 
     @host_event_handler
     @with_connection_from_handle
@@ -5454,7 +5614,7 @@ class Device(utils.CompositeEventEmitter):
             f'{connection.peer_address} as {connection.role_name}'
         )
         connection.authenticated = True
-        connection.emit('connection_authentication')
+        connection.emit(connection.EVENT_CONNECTION_AUTHENTICATION)
 
     @host_event_handler
     @with_connection_from_handle
@@ -5463,7 +5623,7 @@ class Device(utils.CompositeEventEmitter):
             f'*** Connection Authentication Failure: [0x{connection.handle:04X}] '
             f'{connection.peer_address} as {connection.role_name}, error={error}'
         )
-        connection.emit('connection_authentication_failure', error)
+        connection.emit(connection.EVENT_CONNECTION_AUTHENTICATION_FAILURE, error)
 
     # [Classic only]
     @host_event_handler
@@ -5568,7 +5728,9 @@ class Device(utils.CompositeEventEmitter):
 
         async def reply() -> None:
             try:
-                if await utils.cancel_on_event(connection, 'disconnection', method()):
+                if await utils.cancel_on_event(
+                    connection, Connection.EVENT_DISCONNECTION, method()
+                ):
                     await self.host.send_command(
                         hci.HCI_User_Confirmation_Request_Reply_Command(
                             bd_addr=connection.peer_address
@@ -5596,7 +5758,9 @@ class Device(utils.CompositeEventEmitter):
         async def reply() -> None:
             try:
                 number = await utils.cancel_on_event(
-                    connection, 'disconnection', pairing_config.delegate.get_number()
+                    connection,
+                    Connection.EVENT_DISCONNECTION,
+                    pairing_config.delegate.get_number(),
                 )
                 if number is not None:
                     await self.host.send_command(
@@ -5630,7 +5794,9 @@ class Device(utils.CompositeEventEmitter):
             # Ask the user to enter a string
             async def get_pin_code():
                 pin_code = await utils.cancel_on_event(
-                    connection, 'disconnection', pairing_config.delegate.get_string(16)
+                    connection,
+                    Connection.EVENT_DISCONNECTION,
+                    pairing_config.delegate.get_string(16),
                 )
 
                 if pin_code is not None:
@@ -5669,7 +5835,9 @@ class Device(utils.CompositeEventEmitter):
 
         # Show the passkey to the user
         utils.cancel_on_event(
-            connection, 'disconnection', pairing_config.delegate.display_number(passkey)
+            connection,
+            Connection.EVENT_DISCONNECTION,
+            pairing_config.delegate.display_number(passkey, digits=6),
         )
 
     # [Classic only]
@@ -5681,22 +5849,22 @@ class Device(utils.CompositeEventEmitter):
             remote_name = remote_name.decode('utf-8')
             if connection:
                 connection.peer_name = remote_name
-                connection.emit('remote_name')
-            self.emit('remote_name', address, remote_name)
+                connection.emit(connection.EVENT_REMOTE_NAME)
+            self.emit(self.EVENT_REMOTE_NAME, address, remote_name)
         except UnicodeDecodeError as error:
             logger.warning('peer name is not valid UTF-8')
             if connection:
-                connection.emit('remote_name_failure', error)
+                connection.emit(connection.EVENT_REMOTE_NAME_FAILURE, error)
             else:
-                self.emit('remote_name_failure', address, error)
+                self.emit(self.EVENT_REMOTE_NAME_FAILURE, address, error)
 
     # [Classic only]
     @host_event_handler
     @try_with_connection_from_address
     def on_remote_name_failure(self, connection: Connection, address, error):
         if connection:
-            connection.emit('remote_name_failure', error)
-        self.emit('remote_name_failure', address, error)
+            connection.emit(connection.EVENT_REMOTE_NAME_FAILURE, error)
+        self.emit(self.EVENT_REMOTE_NAME_FAILURE, address, error)
 
     # [Classic only]
     @host_event_handler
@@ -5716,7 +5884,7 @@ class Device(utils.CompositeEventEmitter):
             handle=sco_handle,
             link_type=link_type,
         )
-        self.emit('sco_connection', sco_link)
+        self.emit(self.EVENT_SCO_CONNECTION, sco_link)
 
     # [Classic only]
     @host_event_handler
@@ -5726,7 +5894,7 @@ class Device(utils.CompositeEventEmitter):
         self, acl_connection: Connection, status: int
     ) -> None:
         logger.debug(f'*** SCO connection failure: {acl_connection.peer_address}***')
-        self.emit('sco_connection_failure')
+        self.emit(self.EVENT_SCO_CONNECTION_FAILURE)
 
     # [Classic only]
     @host_event_handler
@@ -5763,7 +5931,7 @@ class Device(utils.CompositeEventEmitter):
             cig_id=cig_id,
             cis_id=cis_id,
         )
-        self.emit('cis_request', acl_connection, cis_handle, cig_id, cis_id)
+        self.emit(self.EVENT_CIS_REQUEST, acl_connection, cis_handle, cig_id, cis_id)
 
     # [LE only]
     @host_event_handler
@@ -5782,8 +5950,8 @@ class Device(utils.CompositeEventEmitter):
             f'cis_id=[0x{cis_link.cis_id:02X}] ***'
         )
 
-        cis_link.emit('establishment')
-        self.emit('cis_establishment', cis_link)
+        cis_link.emit(cis_link.EVENT_ESTABLISHMENT)
+        self.emit(self.EVENT_CIS_ESTABLISHMENT, cis_link)
 
     # [LE only]
     @host_event_handler
@@ -5791,8 +5959,8 @@ class Device(utils.CompositeEventEmitter):
     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):
-            cis_link.emit('establishment_failure', status)
-        self.emit('cis_establishment_failure', cis_handle, status)
+            cis_link.emit(cis_link.EVENT_ESTABLISHMENT_FAILURE, status)
+        self.emit(self.EVENT_CIS_ESTABLISHMENT_FAILURE, cis_handle, status)
 
     # [LE only]
     @host_event_handler
@@ -5805,13 +5973,17 @@ class Device(utils.CompositeEventEmitter):
 
     @host_event_handler
     @with_connection_from_handle
-    def on_connection_encryption_change(self, connection, encryption):
+    def on_connection_encryption_change(
+        self, connection, encryption, encryption_key_size
+    ):
         logger.debug(
             f'*** Connection Encryption Change: [0x{connection.handle:04X}] '
             f'{connection.peer_address} as {connection.role_name}, '
-            f'encryption={encryption}'
+            f'encryption={encryption}, '
+            f'key_size={encryption_key_size}'
         )
         connection.encryption = encryption
+        connection.encryption_key_size = encryption_key_size
         if (
             not connection.authenticated
             and connection.transport == PhysicalTransport.BR_EDR
@@ -5826,7 +5998,7 @@ class Device(utils.CompositeEventEmitter):
         ):
             connection.authenticated = True
             connection.sc = True
-        connection.emit('connection_encryption_change')
+        connection.emit(connection.EVENT_CONNECTION_ENCRYPTION_CHANGE)
 
     @host_event_handler
     @with_connection_from_handle
@@ -5836,7 +6008,7 @@ class Device(utils.CompositeEventEmitter):
             f'{connection.peer_address} as {connection.role_name}, '
             f'error={error}'
         )
-        connection.emit('connection_encryption_failure', error)
+        connection.emit(connection.EVENT_CONNECTION_ENCRYPTION_FAILURE, error)
 
     @host_event_handler
     @with_connection_from_handle
@@ -5845,7 +6017,7 @@ class Device(utils.CompositeEventEmitter):
             f'*** Connection Key Refresh: [0x{connection.handle:04X}] '
             f'{connection.peer_address} as {connection.role_name}'
         )
-        connection.emit('connection_encryption_key_refresh')
+        connection.emit(connection.EVENT_CONNECTION_ENCRYPTION_KEY_REFRESH)
 
     @host_event_handler
     @with_connection_from_handle
@@ -5856,7 +6028,7 @@ class Device(utils.CompositeEventEmitter):
             f'{connection_parameters}'
         )
         connection.parameters = connection_parameters
-        connection.emit('connection_parameters_update')
+        connection.emit(connection.EVENT_CONNECTION_PARAMETERS_UPDATE)
 
     @host_event_handler
     @with_connection_from_handle
@@ -5866,7 +6038,7 @@ class Device(utils.CompositeEventEmitter):
             f'{connection.peer_address} as {connection.role_name}, '
             f'error={error}'
         )
-        connection.emit('connection_parameters_update_failure', error)
+        connection.emit(connection.EVENT_CONNECTION_PARAMETERS_UPDATE_FAILURE, error)
 
     @host_event_handler
     @with_connection_from_handle
@@ -5876,7 +6048,7 @@ class Device(utils.CompositeEventEmitter):
             f'{connection.peer_address} as {connection.role_name}, '
             f'{phy}'
         )
-        connection.emit('connection_phy_update', phy)
+        connection.emit(connection.EVENT_CONNECTION_PHY_UPDATE, phy)
 
     @host_event_handler
     @with_connection_from_handle
@@ -5886,7 +6058,7 @@ class Device(utils.CompositeEventEmitter):
             f'{connection.peer_address} as {connection.role_name}, '
             f'error={error}'
         )
-        connection.emit('connection_phy_update_failure', error)
+        connection.emit(connection.EVENT_CONNECTION_PHY_UPDATE_FAILURE, error)
 
     @host_event_handler
     @with_connection_from_handle
@@ -5897,7 +6069,7 @@ class Device(utils.CompositeEventEmitter):
             f'{att_mtu}'
         )
         connection.att_mtu = att_mtu
-        connection.emit('connection_att_mtu_update')
+        connection.emit(connection.EVENT_CONNECTION_ATT_MTU_UPDATE)
 
     @host_event_handler
     @with_connection_from_handle
@@ -5914,7 +6086,7 @@ class Device(utils.CompositeEventEmitter):
             max_rx_octets,
             max_rx_time,
         )
-        connection.emit('connection_data_length_change')
+        connection.emit(connection.EVENT_CONNECTION_DATA_LENGTH_CHANGE)
 
     @host_event_handler
     def on_cs_remote_supported_capabilities(
@@ -5924,7 +6096,9 @@ class Device(utils.CompositeEventEmitter):
             return
 
         if event.status != hci.HCI_SUCCESS:
-            connection.emit('channel_sounding_capabilities_failure', event.status)
+            connection.emit(
+                connection.EVENT_CHANNEL_SOUNDING_CAPABILITIES_FAILURE, event.status
+            )
             return
 
         capabilities = ChannelSoundingCapabilities(
@@ -5949,7 +6123,7 @@ class Device(utils.CompositeEventEmitter):
             t_sw_time_supported=event.t_sw_time_supported,
             tx_snr_capability=event.tx_snr_capability,
         )
-        connection.emit('channel_sounding_capabilities', capabilities)
+        connection.emit(connection.EVENT_CHANNEL_SOUNDING_CAPABILITIES, capabilities)
 
     @host_event_handler
     def on_cs_config(self, event: hci.HCI_LE_CS_Config_Complete_Event):
@@ -5957,7 +6131,9 @@ class Device(utils.CompositeEventEmitter):
             return
 
         if event.status != hci.HCI_SUCCESS:
-            connection.emit('channel_sounding_config_failure', event.status)
+            connection.emit(
+                connection.EVENT_CHANNEL_SOUNDING_CONFIG_FAILURE, event.status
+            )
             return
         if event.action == hci.HCI_LE_CS_Config_Complete_Event.Action.CREATED:
             config = ChannelSoundingConfig(
@@ -5983,11 +6159,13 @@ class Device(utils.CompositeEventEmitter):
                 t_pm_time=event.t_pm_time,
             )
             connection.cs_configs[event.config_id] = config
-            connection.emit('channel_sounding_config', config)
+            connection.emit(connection.EVENT_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)
+                connection.emit(
+                    connection.EVENT_CHANNEL_SOUNDING_CONFIG_REMOVED, config.config_id
+                )
             except KeyError:
                 logger.error('Removing unknown config %d', event.config_id)
 
@@ -5997,7 +6175,9 @@ class Device(utils.CompositeEventEmitter):
             return
 
         if event.status != hci.HCI_SUCCESS:
-            connection.emit('channel_sounding_procedure_failure', event.status)
+            connection.emit(
+                connection.EVENT_CHANNEL_SOUNDING_PROCEDURE_FAILURE, event.status
+            )
             return
 
         procedure = ChannelSoundingProcedure(
@@ -6014,37 +6194,37 @@ class Device(utils.CompositeEventEmitter):
             max_procedure_len=event.max_procedure_len,
         )
         connection.cs_procedures[procedure.config_id] = procedure
-        connection.emit('channel_sounding_procedure', procedure)
+        connection.emit(connection.EVENT_CHANNEL_SOUNDING_PROCEDURE, procedure)
 
     # [Classic only]
     @host_event_handler
     @with_connection_from_address
     def on_role_change(self, connection, new_role):
         connection.role = new_role
-        connection.emit('role_change', 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, address, error):
         if connection:
-            connection.emit('role_change_failure', error)
-        self.emit('role_change_failure', address, error)
+            connection.emit(connection.EVENT_ROLE_CHANGE_FAILURE, error)
+        self.emit(self.EVENT_ROLE_CHANGE_FAILURE, address, error)
 
     # [Classic only]
     @host_event_handler
     @with_connection_from_address
     def on_classic_pairing(self, connection: Connection) -> None:
-        connection.emit('classic_pairing')
+        connection.emit(connection.EVENT_CLASSIC_PAIRING)
 
     # [Classic only]
     @host_event_handler
     @with_connection_from_address
     def on_classic_pairing_failure(self, connection: Connection, status) -> None:
-        connection.emit('classic_pairing_failure', status)
+        connection.emit(connection.EVENT_CLASSIC_PAIRING_FAILURE, status)
 
     def on_pairing_start(self, connection: Connection) -> None:
-        connection.emit('pairing_start')
+        connection.emit(connection.EVENT_PAIRING_START)
 
     def on_pairing(
         self,
@@ -6058,10 +6238,10 @@ class Device(utils.CompositeEventEmitter):
             connection.peer_address = identity_address
         connection.sc = sc
         connection.authenticated = True
-        connection.emit('pairing', keys)
+        connection.emit(connection.EVENT_PAIRING, keys)
 
     def on_pairing_failure(self, connection: Connection, reason: int) -> None:
-        connection.emit('pairing_failure', reason)
+        connection.emit(connection.EVENT_PAIRING_FAILURE, reason)
 
     @with_connection_from_handle
     def on_gatt_pdu(self, connection, pdu):