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

bumble/device.py

@@ -35,12 +35,10 @@ import secrets
 import sys
 from typing import (
     Any,
+    Awaitable,
     Callable,
     ClassVar,
-    Deque,
-    Dict,
     Optional,
-    Type,
     TypeVar,
     Union,
     cast,
@@ -87,6 +85,7 @@ from bumble.profiles import gatt_service
 if TYPE_CHECKING:
     from bumble.transport.common import TransportSource, TransportSink
 
+_T = TypeVar('_T')
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -99,9 +98,9 @@ logger = logging.getLogger(__name__)
 # fmt: off
 # pylint: disable=line-too-long
 
-DEVICE_MIN_SCAN_INTERVAL                      = 25
+DEVICE_MIN_SCAN_INTERVAL                      = 2.5
 DEVICE_MAX_SCAN_INTERVAL                      = 10240
-DEVICE_MIN_SCAN_WINDOW                        = 25
+DEVICE_MIN_SCAN_WINDOW                        = 2.5
 DEVICE_MAX_SCAN_WINDOW                        = 10240
 DEVICE_MIN_LE_RSSI                            = -127
 DEVICE_MAX_LE_RSSI                            = 20
@@ -140,6 +139,9 @@ DEVICE_DEFAULT_ADVERTISING_TX_POWER           = (
 DEVICE_DEFAULT_PERIODIC_ADVERTISING_SYNC_SKIP = 0
 DEVICE_DEFAULT_PERIODIC_ADVERTISING_SYNC_TIMEOUT = 5.0
 DEVICE_DEFAULT_LE_RPA_TIMEOUT                 = 15 * 60 # 15 minutes (in seconds)
+DEVICE_DEFAULT_ISO_CIS_MAX_SDU                = 251
+DEVICE_DEFAULT_ISO_CIS_RTN                    = 10
+DEVICE_DEFAULT_ISO_CIS_MAX_TRANSPORT_LATENCY  = 100
 
 # fmt: on
 # pylint: enable=line-too-long
@@ -202,25 +204,35 @@ class Advertisement:
 # -----------------------------------------------------------------------------
 class LegacyAdvertisement(Advertisement):
     @classmethod
-    def from_advertising_report(cls, report):
+    def from_advertising_report(
+        cls, report: hci.HCI_LE_Advertising_Report_Event.Report
+    ) -> Self:
         return cls(
             address=report.address,
             rssi=report.rssi,
             is_legacy=True,
-            is_connectable=report.event_type
-            in (
-                hci.HCI_LE_Advertising_Report_Event.ADV_IND,
-                hci.HCI_LE_Advertising_Report_Event.ADV_DIRECT_IND,
+            is_connectable=(
+                report.event_type
+                in (
+                    hci.HCI_LE_Advertising_Report_Event.EventType.ADV_IND,
+                    hci.HCI_LE_Advertising_Report_Event.EventType.ADV_DIRECT_IND,
+                )
             ),
-            is_directed=report.event_type
-            == hci.HCI_LE_Advertising_Report_Event.ADV_DIRECT_IND,
-            is_scannable=report.event_type
-            in (
-                hci.HCI_LE_Advertising_Report_Event.ADV_IND,
-                hci.HCI_LE_Advertising_Report_Event.ADV_SCAN_IND,
+            is_directed=(
+                report.event_type
+                == hci.HCI_LE_Advertising_Report_Event.EventType.ADV_DIRECT_IND
+            ),
+            is_scannable=(
+                report.event_type
+                in (
+                    hci.HCI_LE_Advertising_Report_Event.EventType.ADV_IND,
+                    hci.HCI_LE_Advertising_Report_Event.EventType.ADV_SCAN_IND,
+                )
+            ),
+            is_scan_response=(
+                report.event_type
+                == hci.HCI_LE_Advertising_Report_Event.EventType.SCAN_RSP
             ),
-            is_scan_response=report.event_type
-            == hci.HCI_LE_Advertising_Report_Event.SCAN_RSP,
             data_bytes=report.data,
         )
 
@@ -228,18 +240,20 @@ class LegacyAdvertisement(Advertisement):
 # -----------------------------------------------------------------------------
 class ExtendedAdvertisement(Advertisement):
     @classmethod
-    def from_advertising_report(cls, report):
+    def from_advertising_report(
+        cls, report: hci.HCI_LE_Extended_Advertising_Report_Event.Report
+    ) -> Self:
         # fmt: off
         # pylint: disable=line-too-long
         return cls(
             address          = report.address,
             rssi             = report.rssi,
-            is_legacy        = report.event_type & (1 << hci.HCI_LE_Extended_Advertising_Report_Event.LEGACY_ADVERTISING_PDU_USED) != 0,
+            is_legacy        = (report.event_type & hci.HCI_LE_Extended_Advertising_Report_Event.EventType.LEGACY_ADVERTISING_PDU_USED) != 0,
             is_anonymous     = report.address.address_type == hci.HCI_LE_Extended_Advertising_Report_Event.ANONYMOUS_ADDRESS_TYPE,
-            is_connectable   = report.event_type & (1 << hci.HCI_LE_Extended_Advertising_Report_Event.CONNECTABLE_ADVERTISING) != 0,
-            is_directed      = report.event_type & (1 << hci.HCI_LE_Extended_Advertising_Report_Event.DIRECTED_ADVERTISING) != 0,
-            is_scannable     = report.event_type & (1 << hci.HCI_LE_Extended_Advertising_Report_Event.SCANNABLE_ADVERTISING) != 0,
-            is_scan_response = report.event_type & (1 << hci.HCI_LE_Extended_Advertising_Report_Event.SCAN_RESPONSE) != 0,
+            is_connectable   = (report.event_type & hci.HCI_LE_Extended_Advertising_Report_Event.EventType.CONNECTABLE_ADVERTISING) != 0,
+            is_directed      = (report.event_type & hci.HCI_LE_Extended_Advertising_Report_Event.EventType.DIRECTED_ADVERTISING) != 0,
+            is_scannable     = (report.event_type & hci.HCI_LE_Extended_Advertising_Report_Event.EventType.SCANNABLE_ADVERTISING) != 0,
+            is_scan_response = (report.event_type & hci.HCI_LE_Extended_Advertising_Report_Event.EventType.SCAN_RESPONSE) != 0,
             is_complete      = (report.event_type >> 5 & 3)  == hci.HCI_LE_Extended_Advertising_Report_Event.DATA_COMPLETE,
             is_truncated     = (report.event_type >> 5 & 3)  == hci.HCI_LE_Extended_Advertising_Report_Event.DATA_INCOMPLETE_TRUNCATED_NO_MORE_TO_COME,
             primary_phy      = report.primary_phy,
@@ -436,7 +450,7 @@ class AdvertisingEventProperties:
 
     @classmethod
     def from_advertising_type(
-        cls: Type[AdvertisingEventProperties],
+        cls: type[AdvertisingEventProperties],
         advertising_type: AdvertisingType,
     ) -> AdvertisingEventProperties:
         return cls(
@@ -478,7 +492,18 @@ class PeriodicAdvertisement:
 
 # -----------------------------------------------------------------------------
 @dataclass
-class BIGInfoAdvertisement:
+class BigInfoAdvertisement:
+    class Framing(utils.OpenIntEnum):
+        # fmt: off
+        UNFRAMED                = 0X00
+        FRAMED_SEGMENTABLE_MODE = 0X01
+        FRAMED_UNSEGMENTED_MODE = 0X02
+
+    class Encryption(utils.OpenIntEnum):
+        # fmt: off
+        UNENCRYPTED = 0x00
+        ENCRYPTED   = 0x01
+
     address: hci.Address
     sid: int
     num_bis: int
@@ -491,8 +516,8 @@ class BIGInfoAdvertisement:
     sdu_interval: int
     max_sdu: int
     phy: hci.Phy
-    framed: bool
-    encrypted: bool
+    framing: Framing
+    encryption: Encryption
 
     @classmethod
     def from_report(cls, address: hci.Address, sid: int, report) -> Self:
@@ -509,8 +534,8 @@ class BIGInfoAdvertisement:
             report.sdu_interval,
             report.max_sdu,
             hci.Phy(report.phy),
-            report.framing != 0,
-            report.encryption != 0,
+            cls.Framing(report.framing),
+            cls.Encryption(report.encryption),
         )
 
 
@@ -1002,7 +1027,7 @@ class PeriodicAdvertisingSync(utils.EventEmitter):
     def on_biginfo_advertising_report(self, report) -> None:
         self.emit(
             self.EVENT_BIGINFO_ADVERTISEMENT,
-            BIGInfoAdvertisement.from_report(self.advertiser_address, self.sid, report),
+            BigInfoAdvertisement.from_report(self.advertiser_address, self.sid, report),
         )
 
     def __str__(self) -> str:
@@ -1020,14 +1045,24 @@ class PeriodicAdvertisingSync(utils.EventEmitter):
 # -----------------------------------------------------------------------------
 @dataclass
 class BigParameters:
+    class Packing(utils.OpenIntEnum):
+        # fmt: off
+        SEQUENTIAL = 0x00
+        INTERLEAVED = 0x01
+
+    class Framing(utils.OpenIntEnum):
+        # fmt: off
+        UNFRAMED = 0x00
+        FRAMED   = 0x01
+
     num_bis: int
-    sdu_interval: int
+    sdu_interval: int  # SDU interval, in microseconds
     max_sdu: int
-    max_transport_latency: int
+    max_transport_latency: int  # Max transport latency, in milliseconds
     rtn: int
     phy: hci.PhyBit = hci.PhyBit.LE_2M
-    packing: int = 0
-    framing: int = 0
+    packing: Packing = Packing.SEQUENTIAL
+    framing: Framing = Framing.UNFRAMED
     broadcast_code: bytes | None = None
 
 
@@ -1050,15 +1085,15 @@ class Big(utils.EventEmitter):
     state: State = State.PENDING
 
     # Attributes provided by BIG Create Complete event
-    big_sync_delay: int = 0
-    transport_latency_big: int = 0
-    phy: int = 0
+    big_sync_delay: int = 0  # Sync delay, in microseconds
+    transport_latency_big: int = 0  # Transport latency, in microseconds
+    phy: hci.Phy = hci.Phy.LE_1M
     nse: int = 0
     bn: int = 0
     pto: int = 0
     irc: int = 0
     max_pdu: int = 0
-    iso_interval: float = 0.0
+    iso_interval: float = 0.0  # ISO interval, in milliseconds
     bis_links: Sequence[BisLink] = ()
 
     def __post_init__(self) -> None:
@@ -1343,7 +1378,7 @@ class Peer:
         return self.gatt_client.get_characteristics_by_uuid(uuid, service)
 
     def create_service_proxy(
-        self, proxy_class: Type[_PROXY_CLASS]
+        self, proxy_class: type[_PROXY_CLASS]
     ) -> Optional[_PROXY_CLASS]:
         if proxy := proxy_class.from_client(self.gatt_client):
             return cast(_PROXY_CLASS, proxy)
@@ -1351,7 +1386,7 @@ class Peer:
         return None
 
     async def discover_service_and_create_proxy(
-        self, proxy_class: Type[_PROXY_CLASS]
+        self, proxy_class: type[_PROXY_CLASS]
     ) -> Optional[_PROXY_CLASS]:
         # Discover the first matching service and its characteristics
         services = await self.discover_service(proxy_class.SERVICE_CLASS.UUID)
@@ -1464,7 +1499,7 @@ class _IsoLink:
             check_result=True,
         )
 
-    async def remove_data_path(self, direction: _IsoLink.Direction) -> int:
+    async def remove_data_path(self, directions: Iterable[_IsoLink.Direction]) -> int:
         """Remove a data path with controller on given direction.
 
         Args:
@@ -1476,7 +1511,9 @@ class _IsoLink:
         response = await self.device.send_command(
             hci.HCI_LE_Remove_ISO_Data_Path_Command(
                 connection_handle=self.handle,
-                data_path_direction=direction,
+                data_path_direction=sum(
+                    1 << direction for direction in set(directions)
+                ),
             ),
             check_result=False,
         )
@@ -1486,10 +1523,74 @@ class _IsoLink:
         """Write an ISO SDU."""
         self.device.host.send_iso_sdu(connection_handle=self.handle, sdu=sdu)
 
+    async def get_tx_time_stamp(self) -> tuple[int, int, int]:
+        response = await self.device.host.send_command(
+            hci.HCI_LE_Read_ISO_TX_Sync_Command(connection_handle=self.handle),
+            check_result=True,
+        )
+        return (
+            response.return_parameters.packet_sequence_number,
+            response.return_parameters.tx_time_stamp,
+            response.return_parameters.time_offset,
+        )
+
     @property
     def data_packet_queue(self) -> DataPacketQueue | None:
         return self.device.host.get_data_packet_queue(self.handle)
 
+    async def drain(self) -> None:
+        if data_packet_queue := self.data_packet_queue:
+            await data_packet_queue.drain(self.handle)
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class CigParameters:
+    class WorstCaseSca(utils.OpenIntEnum):
+        # fmt: off
+        SCA_251_TO_500_PPM = 0x00
+        SCA_151_TO_250_PPM = 0x01
+        SCA_101_TO_150_PPM = 0x02
+        SCA_76_TO_100_PPM  = 0x03
+        SCA_51_TO_75_PPM   = 0x04
+        SCA_31_TO_50_PPM   = 0x05
+        SCA_21_TO_30_PPM   = 0x06
+        SCA_0_TO_20_PPM    = 0x07
+
+    class Packing(utils.OpenIntEnum):
+        # fmt: off
+        SEQUENTIAL = 0x00
+        INTERLEAVED = 0x01
+
+    class Framing(utils.OpenIntEnum):
+        # fmt: off
+        UNFRAMED = 0x00
+        FRAMED   = 0x01
+
+    @dataclass
+    class CisParameters:
+        cis_id: int
+        max_sdu_c_to_p: int = DEVICE_DEFAULT_ISO_CIS_MAX_SDU
+        max_sdu_p_to_c: int = DEVICE_DEFAULT_ISO_CIS_MAX_SDU
+        phy_c_to_p: hci.PhyBit = hci.PhyBit.LE_2M
+        phy_p_to_c: hci.PhyBit = hci.PhyBit.LE_2M
+        rtn_c_to_p: int = DEVICE_DEFAULT_ISO_CIS_RTN  # Number of C->P retransmissions
+        rtn_p_to_c: int = DEVICE_DEFAULT_ISO_CIS_RTN  # Number of P->C retransmissions
+
+    cig_id: int
+    cis_parameters: list[CisParameters]
+    sdu_interval_c_to_p: int  # C->P SDU interval, in microseconds
+    sdu_interval_p_to_c: int  # P->C SDU interval, in microseconds
+    worst_case_sca: WorstCaseSca = WorstCaseSca.SCA_251_TO_500_PPM
+    packing: Packing = Packing.SEQUENTIAL
+    framing: Framing = Framing.UNFRAMED
+    max_transport_latency_c_to_p: int = (
+        DEVICE_DEFAULT_ISO_CIS_MAX_TRANSPORT_LATENCY  # Max C->P transport latency, in milliseconds
+    )
+    max_transport_latency_p_to_c: int = (
+        DEVICE_DEFAULT_ISO_CIS_MAX_TRANSPORT_LATENCY  # Max C->P transport latency, in milliseconds
+    )
+
 
 # -----------------------------------------------------------------------------
 @dataclass
@@ -1503,6 +1604,20 @@ class CisLink(utils.EventEmitter, _IsoLink):
     handle: int  # CIS handle assigned by Controller (in LE_Set_CIG_Parameters Complete or LE_CIS_Request events)
     cis_id: int  # CIS ID assigned by Central device
     cig_id: int  # CIG ID assigned by Central device
+    cig_sync_delay: int = 0  # CIG sync delay, in microseconds
+    cis_sync_delay: int = 0  # CIS sync delay, in microseconds
+    transport_latency_c_to_p: int = 0  # C->P transport latency, in microseconds
+    transport_latency_p_to_c: int = 0  # P->C transport latency, in microseconds
+    phy_c_to_p: Optional[hci.Phy] = None
+    phy_p_to_c: Optional[hci.Phy] = None
+    nse: int = 0
+    bn_c_to_p: int = 0
+    bn_p_to_c: int = 0
+    ft_c_to_p: int = 0
+    ft_p_to_c: int = 0
+    max_pdu_c_to_p: int = 0
+    max_pdu_p_to_c: int = 0
+    iso_interval: float = 0.0  # ISO interval, in milliseconds
     state: State = State.PENDING
     sink: Callable[[hci.HCI_IsoDataPacket], Any] | None = None
 
@@ -1545,7 +1660,7 @@ class IsoPacketStream:
         self.iso_link = iso_link
         self.data_packet_queue = iso_link.data_packet_queue
         self.data_packet_queue.on('flow', self._on_flow)
-        self._thresholds: Deque[int] = collections.deque()
+        self._thresholds: collections.deque[int] = collections.deque()
         self._semaphore = asyncio.Semaphore(max_queue_size)
 
     def _on_flow(self) -> None:
@@ -1585,6 +1700,7 @@ class Connection(utils.CompositeEventEmitter):
     peer_resolvable_address: Optional[hci.Address]
     peer_le_features: Optional[hci.LeFeatureMask]
     role: hci.Role
+    parameters: Parameters
     encryption: int
     encryption_key_size: int
     authenticated: bool
@@ -1594,6 +1710,8 @@ class Connection(utils.CompositeEventEmitter):
     pairing_peer_authentication_requirements: Optional[int]
     cs_configs: dict[int, ChannelSoundingConfig]  # Config ID to Configuration
     cs_procedures: dict[int, ChannelSoundingProcedure]  # Config ID to Procedures
+    classic_mode: int = hci.HCI_Mode_Change_Event.Mode.ACTIVE
+    classic_interval: int = 0
 
     EVENT_CONNECTION_ATT_MTU_UPDATE = "connection_att_mtu_update"
     EVENT_DISCONNECTION = "disconnection"
@@ -1620,6 +1738,8 @@ class Connection(utils.CompositeEventEmitter):
     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_MODE_CHANGE = "mode_change"
+    EVENT_MODE_CHANGE_FAILURE = "mode_change_failure"
     EVENT_ROLE_CHANGE = "role_change"
     EVENT_ROLE_CHANGE_FAILURE = "role_change_failure"
     EVENT_CLASSIC_PAIRING = "classic_pairing"
@@ -1629,6 +1749,11 @@ class Connection(utils.CompositeEventEmitter):
     EVENT_PAIRING_FAILURE = "pairing_failure"
     EVENT_SECURITY_REQUEST = "security_request"
     EVENT_LINK_KEY = "link_key"
+    EVENT_CIS_REQUEST = "cis_request"
+    EVENT_CIS_ESTABLISHMENT = "cis_establishment"
+    EVENT_CIS_ESTABLISHMENT_FAILURE = "cis_establishment_failure"
+    EVENT_LE_SUBRATE_CHANGE = "le_subrate_change"
+    EVENT_LE_SUBRATE_CHANGE_FAILURE = "le_subrate_change_failure"
 
     @utils.composite_listener
     class Listener:
@@ -1664,6 +1789,12 @@ class Connection(utils.CompositeEventEmitter):
         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.
+        subrate_factor: int = (
+            1  # See Bluetooth spec Vol 6, Part B - 4.5.1 Connection events
+        )
+        continuation_number: int = (
+            0  # See Bluetooth spec Vol 6, Part B - 4.5.1 Connection events
+        )
 
     def __init__(
         self,
@@ -1884,6 +2015,12 @@ class Connection(utils.CompositeEventEmitter):
     def data_packet_queue(self) -> DataPacketQueue | None:
         return self.device.host.get_data_packet_queue(self.handle)
 
+    def cancel_on_disconnection(self, awaitable: Awaitable[_T]) -> Awaitable[_T]:
+        """
+        Helper method to call `utils.cancel_on_event` for the 'disconnection' event
+        """
+        return utils.cancel_on_event(self, self.EVENT_DISCONNECTION, awaitable)
+
     async def __aenter__(self):
         return self
 
@@ -1929,6 +2066,7 @@ class DeviceConfiguration:
     le_simultaneous_enabled: bool = False
     le_privacy_enabled: bool = False
     le_rpa_timeout: int = DEVICE_DEFAULT_LE_RPA_TIMEOUT
+    le_subrate_enabled: bool = False
     classic_enabled: bool = False
     classic_sc_enabled: bool = True
     classic_ssp_enabled: bool = True
@@ -1954,9 +2092,9 @@ class DeviceConfiguration:
     gatt_service_enabled: bool = True
 
     def __post_init__(self) -> None:
-        self.gatt_services: list[Dict[str, Any]] = []
+        self.gatt_services: list[dict[str, Any]] = []
 
-    def load_from_dict(self, config: Dict[str, Any]) -> None:
+    def load_from_dict(self, config: dict[str, Any]) -> None:
         config = copy.deepcopy(config)
 
         # Load simple properties
@@ -2016,13 +2154,13 @@ class DeviceConfiguration:
             self.load_from_dict(json.load(file))
 
     @classmethod
-    def from_file(cls: Type[Self], filename: str) -> Self:
+    def from_file(cls: type[Self], filename: str) -> Self:
         config = cls()
         config.load_from_file(filename)
         return config
 
     @classmethod
-    def from_dict(cls: Type[Self], config: Dict[str, Any]) -> Self:
+    def from_dict(cls: type[Self], config: dict[str, Any]) -> Self:
         device_config = cls()
         device_config.load_from_dict(config)
         return device_config
@@ -2119,22 +2257,22 @@ class Device(utils.CompositeEventEmitter):
     advertising_data: bytes
     scan_response_data: bytes
     cs_capabilities: ChannelSoundingCapabilities | None = None
-    connections: Dict[int, Connection]
-    pending_connections: Dict[hci.Address, Connection]
-    classic_pending_accepts: Dict[
+    connections: dict[int, Connection]
+    pending_connections: dict[hci.Address, Connection]
+    classic_pending_accepts: dict[
         hci.Address,
         list[asyncio.Future[Union[Connection, tuple[hci.Address, int, int]]]],
     ]
-    advertisement_accumulators: Dict[hci.Address, AdvertisementDataAccumulator]
+    advertisement_accumulators: dict[hci.Address, AdvertisementDataAccumulator]
     periodic_advertising_syncs: list[PeriodicAdvertisingSync]
     config: DeviceConfiguration
     legacy_advertiser: Optional[LegacyAdvertiser]
-    sco_links: Dict[int, ScoLink]
-    cis_links: Dict[int, CisLink]
+    sco_links: dict[int, ScoLink]
+    cis_links: dict[int, CisLink]
     bigs: dict[int, Big]
     bis_links: dict[int, BisLink]
     big_syncs: dict[int, BigSync]
-    _pending_cis: Dict[int, tuple[int, int]]
+    _pending_cis: dict[int, tuple[int, int]]
     gatt_service: gatt_service.GenericAttributeProfileService | None = None
 
     EVENT_ADVERTISEMENT = "advertisement"
@@ -2281,6 +2419,7 @@ class Device(utils.CompositeEventEmitter):
         self.le_privacy_enabled = config.le_privacy_enabled
         self.le_rpa_timeout = config.le_rpa_timeout
         self.le_rpa_periodic_update_task: Optional[asyncio.Task] = None
+        self.le_subrate_enabled = config.le_subrate_enabled
         self.classic_enabled = config.classic_enabled
         self.cis_enabled = config.cis_enabled
         self.classic_sc_enabled = config.classic_sc_enabled
@@ -2294,8 +2433,8 @@ class Device(utils.CompositeEventEmitter):
         self.address_generation_offload = config.address_generation_offload
 
         # Extended advertising.
-        self.extended_advertising_sets: Dict[int, AdvertisingSet] = {}
-        self.connecting_extended_advertising_sets: Dict[int, AdvertisingSet] = {}
+        self.extended_advertising_sets: dict[int, AdvertisingSet] = {}
+        self.connecting_extended_advertising_sets: dict[int, AdvertisingSet] = {}
 
         # Legacy advertising.
         # The advertising and scan response data, as well as the advertising interval
@@ -2660,6 +2799,15 @@ class Device(utils.CompositeEventEmitter):
                     check_result=True,
                 )
 
+            if self.le_subrate_enabled:
+                await self.send_command(
+                    hci.HCI_LE_Set_Host_Feature_Command(
+                        bit_number=hci.LeFeature.CONNECTION_SUBRATING_HOST_SUPPORT,
+                        bit_value=1,
+                    ),
+                    check_result=True,
+                )
+
             if self.config.channel_sounding_enabled:
                 await self.send_command(
                     hci.HCI_LE_Set_Host_Feature_Command(
@@ -4271,11 +4419,11 @@ class Device(utils.CompositeEventEmitter):
         self.smp_manager.pairing_config_factory = pairing_config_factory
 
     @property
-    def smp_session_proxy(self) -> Type[smp.Session]:
+    def smp_session_proxy(self) -> type[smp.Session]:
         return self.smp_manager.session_proxy
 
     @smp_session_proxy.setter
-    def smp_session_proxy(self, session_proxy: Type[smp.Session]) -> None:
+    def smp_session_proxy(self, session_proxy: type[smp.Session]) -> None:
         self.smp_manager.session_proxy = session_proxy
 
     async def pair(self, connection):
@@ -4359,9 +4507,7 @@ class Device(utils.CompositeEventEmitter):
                 raise hci.HCI_StatusError(result)
 
             # Wait for the authentication to complete
-            await utils.cancel_on_event(
-                connection, Connection.EVENT_DISCONNECTION, pending_authentication
-            )
+            await connection.cancel_on_disconnection(pending_authentication)
         finally:
             connection.remove_listener(
                 connection.EVENT_CONNECTION_AUTHENTICATION, on_authentication
@@ -4448,9 +4594,7 @@ class Device(utils.CompositeEventEmitter):
                     raise hci.HCI_StatusError(result)
 
             # Wait for the result
-            await utils.cancel_on_event(
-                connection, Connection.EVENT_DISCONNECTION, pending_encryption
-            )
+            await connection.cancel_on_disconnection(pending_encryption)
         finally:
             connection.remove_listener(
                 connection.EVENT_CONNECTION_ENCRYPTION_CHANGE, on_encryption_change
@@ -4494,9 +4638,7 @@ class Device(utils.CompositeEventEmitter):
                     f'{hci.HCI_Constant.error_name(result.status)}'
                 )
                 raise hci.HCI_StatusError(result)
-            await utils.cancel_on_event(
-                connection, Connection.EVENT_DISCONNECTION, pending_role_change
-            )
+            await connection.cancel_on_disconnection(pending_role_change)
         finally:
             connection.remove_listener(connection.EVENT_ROLE_CHANGE, on_role_change)
             connection.remove_listener(
@@ -4556,48 +4698,39 @@ class Device(utils.CompositeEventEmitter):
     @utils.experimental('Only for testing.')
     async def setup_cig(
         self,
-        cig_id: int,
-        cis_id: Sequence[int],
-        sdu_interval: tuple[int, int],
-        framing: int,
-        max_sdu: tuple[int, int],
-        retransmission_number: int,
-        max_transport_latency: tuple[int, int],
+        parameters: CigParameters,
     ) -> list[int]:
         """Sends hci.HCI_LE_Set_CIG_Parameters_Command.
 
         Args:
-            cig_id: CIG_ID.
-            cis_id: CID ID list.
-            sdu_interval: SDU intervals of (Central->Peripheral, Peripheral->Cental).
-            framing: Un-framing(0) or Framing(1).
-            max_sdu: Max SDU counts of (Central->Peripheral, Peripheral->Cental).
-            retransmission_number: retransmission_number.
-            max_transport_latency: Max transport latencies of
-                                   (Central->Peripheral, Peripheral->Cental).
+            parameters: CIG parameters.
 
         Returns:
             List of created CIS handles corresponding to the same order of [cid_id].
         """
-        num_cis = len(cis_id)
+        num_cis = len(parameters.cis_parameters)
 
         response = await self.send_command(
             hci.HCI_LE_Set_CIG_Parameters_Command(
-                cig_id=cig_id,
-                sdu_interval_c_to_p=sdu_interval[0],
-                sdu_interval_p_to_c=sdu_interval[1],
-                worst_case_sca=0x00,  # 251-500 ppm
-                packing=0x00,  # Sequential
-                framing=framing,
-                max_transport_latency_c_to_p=max_transport_latency[0],
-                max_transport_latency_p_to_c=max_transport_latency[1],
-                cis_id=cis_id,
-                max_sdu_c_to_p=[max_sdu[0]] * num_cis,
-                max_sdu_p_to_c=[max_sdu[1]] * num_cis,
-                phy_c_to_p=[hci.HCI_LE_2M_PHY] * num_cis,
-                phy_p_to_c=[hci.HCI_LE_2M_PHY] * num_cis,
-                rtn_c_to_p=[retransmission_number] * num_cis,
-                rtn_p_to_c=[retransmission_number] * num_cis,
+                cig_id=parameters.cig_id,
+                sdu_interval_c_to_p=parameters.sdu_interval_c_to_p,
+                sdu_interval_p_to_c=parameters.sdu_interval_p_to_c,
+                worst_case_sca=parameters.worst_case_sca,
+                packing=int(parameters.packing),
+                framing=int(parameters.framing),
+                max_transport_latency_c_to_p=parameters.max_transport_latency_c_to_p,
+                max_transport_latency_p_to_c=parameters.max_transport_latency_p_to_c,
+                cis_id=[cis.cis_id for cis in parameters.cis_parameters],
+                max_sdu_c_to_p=[
+                    cis.max_sdu_c_to_p for cis in parameters.cis_parameters
+                ],
+                max_sdu_p_to_c=[
+                    cis.max_sdu_p_to_c for cis in parameters.cis_parameters
+                ],
+                phy_c_to_p=[cis.phy_c_to_p for cis in parameters.cis_parameters],
+                phy_p_to_c=[cis.phy_p_to_c for cis in parameters.cis_parameters],
+                rtn_c_to_p=[cis.rtn_c_to_p for cis in parameters.cis_parameters],
+                rtn_p_to_c=[cis.rtn_p_to_c for cis in parameters.cis_parameters],
             ),
             check_result=True,
         )
@@ -4605,19 +4738,17 @@ class Device(utils.CompositeEventEmitter):
         # Ideally, we should manage CIG lifecycle, but they are not useful for Unicast
         # Server, so here it only provides a basic functionality for testing.
         cis_handles = response.return_parameters.connection_handle[:]
-        for id, cis_handle in zip(cis_id, cis_handles):
-            self._pending_cis[cis_handle] = (id, cig_id)
+        for cis, cis_handle in zip(parameters.cis_parameters, cis_handles):
+            self._pending_cis[cis_handle] = (cis.cis_id, parameters.cig_id)
 
         return cis_handles
 
     # [LE only]
     @utils.experimental('Only for testing.')
     async def create_cis(
-        self, cis_acl_pairs: Sequence[tuple[int, int]]
+        self, cis_acl_pairs: Sequence[tuple[int, Connection]]
     ) -> list[CisLink]:
-        for cis_handle, acl_handle in cis_acl_pairs:
-            acl_connection = self.lookup_connection(acl_handle)
-            assert acl_connection
+        for cis_handle, acl_connection in cis_acl_pairs:
             cis_id, cig_id = self._pending_cis.pop(cis_handle)
             self.cis_links[cis_handle] = CisLink(
                 device=self,
@@ -4637,8 +4768,8 @@ class Device(utils.CompositeEventEmitter):
                 if pending_future := pending_cis_establishments.get(cis_link.handle):
                     pending_future.set_result(cis_link)
 
-            def on_cis_establishment_failure(cis_handle: int, status: int) -> None:
-                if pending_future := pending_cis_establishments.get(cis_handle):
+            def on_cis_establishment_failure(cis_link: CisLink, status: int) -> None:
+                if pending_future := pending_cis_establishments.get(cis_link.handle):
                     pending_future.set_exception(hci.HCI_Error(status))
 
             watcher.on(self, self.EVENT_CIS_ESTABLISHMENT, on_cis_establishment)
@@ -4648,7 +4779,7 @@ class Device(utils.CompositeEventEmitter):
             await self.send_command(
                 hci.HCI_LE_Create_CIS_Command(
                     cis_connection_handle=[p[0] for p in cis_acl_pairs],
-                    acl_connection_handle=[p[1] for p in cis_acl_pairs],
+                    acl_connection_handle=[p[1].handle for p in cis_acl_pairs],
                 ),
                 check_result=True,
             )
@@ -4657,26 +4788,21 @@ class Device(utils.CompositeEventEmitter):
 
     # [LE only]
     @utils.experimental('Only for testing.')
-    async def accept_cis_request(self, handle: int) -> CisLink:
+    async def accept_cis_request(self, cis_link: CisLink) -> None:
         """[LE Only] Accepts an incoming CIS request.
 
-        When the specified CIS handle is already created, this method returns the
-        existed CIS link object immediately.
+        This method returns when the CIS is established, or raises an exception if
+        the CIS establishment fails.
 
         Args:
             handle: CIS handle to accept.
-
-        Returns:
-            CIS link object on the given handle.
         """
-        if not (cis_link := self.cis_links.get(handle)):
-            raise InvalidStateError(f'No pending CIS request of handle {handle}')
 
         # There might be multiple ASE sharing a CIS channel.
         # If one of them has accepted the request, the others should just leverage it.
         async with self._cis_lock:
             if cis_link.state == CisLink.State.ESTABLISHED:
-                return cis_link
+                return
 
             with closing(utils.EventWatcher()) as watcher:
                 pending_establishment = asyncio.get_running_loop().create_future()
@@ -4695,26 +4821,24 @@ class Device(utils.CompositeEventEmitter):
                 )
 
                 await self.send_command(
-                    hci.HCI_LE_Accept_CIS_Request_Command(connection_handle=handle),
+                    hci.HCI_LE_Accept_CIS_Request_Command(
+                        connection_handle=cis_link.handle
+                    ),
                     check_result=True,
                 )
 
                 await pending_establishment
-                return cis_link
-
-        # Mypy believes this is reachable when context is an ExitStack.
-        raise UnreachableError()
 
     # [LE only]
     @utils.experimental('Only for testing.')
     async def reject_cis_request(
         self,
-        handle: int,
+        cis_link: CisLink,
         reason: int = hci.HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR,
     ) -> None:
         await self.send_command(
             hci.HCI_LE_Reject_CIS_Request_Command(
-                connection_handle=handle, reason=reason
+                connection_handle=cis_link.handle, reason=reason
             ),
             check_result=True,
         )
@@ -5071,8 +5195,8 @@ class Device(utils.CompositeEventEmitter):
         # 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,
+                hci.LinkKeyType.AUTHENTICATED_COMBINATION_KEY_GENERATED_FROM_P_192,
+                hci.LinkKeyType.AUTHENTICATED_COMBINATION_KEY_GENERATED_FROM_P_256,
             )
             pairing_keys = PairingKeys(
                 link_key=PairingKeys.Key(value=link_key, authenticated=authenticated),
@@ -5252,7 +5376,7 @@ class Device(utils.CompositeEventEmitter):
         big.bis_links = [BisLink(handle=handle, big=big) for handle in bis_handles]
         big.big_sync_delay = big_sync_delay
         big.transport_latency_big = transport_latency_big
-        big.phy = phy
+        big.phy = hci.Phy(phy)
         big.nse = nse
         big.bn = bn
         big.pto = pto
@@ -5519,8 +5643,8 @@ class Device(utils.CompositeEventEmitter):
 
         # Handle SCO request.
         if link_type in (
-            hci.HCI_Connection_Complete_Event.SCO_LINK_TYPE,
-            hci.HCI_Connection_Complete_Event.ESCO_LINK_TYPE,
+            hci.HCI_Connection_Complete_Event.LinkType.SCO,
+            hci.HCI_Connection_Complete_Event.LinkType.ESCO,
         ):
             if connection := self.find_connection_by_bd_addr(
                 bd_addr, transport=PhysicalTransport.BR_EDR
@@ -5628,7 +5752,7 @@ class Device(utils.CompositeEventEmitter):
     # [Classic only]
     @host_event_handler
     @with_connection_from_address
-    def on_authentication_io_capability_request(self, connection):
+    def on_authentication_io_capability_request(self, connection: Connection):
         # Ask what the pairing config should be for this connection
         pairing_config = self.pairing_config_factory(connection)
 
@@ -5636,13 +5760,13 @@ class Device(utils.CompositeEventEmitter):
         authentication_requirements = (
             # No Bonding
             (
-                hci.HCI_MITM_NOT_REQUIRED_NO_BONDING_AUTHENTICATION_REQUIREMENTS,
-                hci.HCI_MITM_REQUIRED_NO_BONDING_AUTHENTICATION_REQUIREMENTS,
+                hci.AuthenticationRequirements.MITM_NOT_REQUIRED_NO_BONDING,
+                hci.AuthenticationRequirements.MITM_REQUIRED_NO_BONDING,
             ),
             # General Bonding
             (
-                hci.HCI_MITM_NOT_REQUIRED_GENERAL_BONDING_AUTHENTICATION_REQUIREMENTS,
-                hci.HCI_MITM_REQUIRED_GENERAL_BONDING_AUTHENTICATION_REQUIREMENTS,
+                hci.AuthenticationRequirements.MITM_NOT_REQUIRED_GENERAL_BONDING,
+                hci.AuthenticationRequirements.MITM_REQUIRED_GENERAL_BONDING,
             ),
         )[1 if pairing_config.bonding else 0][1 if pairing_config.mitm else 0]
 
@@ -5697,30 +5821,30 @@ class Device(utils.CompositeEventEmitter):
             raise UnreachableError()
 
         # See Bluetooth spec @ Vol 3, Part C 5.2.2.6
-        methods = {
-            hci.HCI_DISPLAY_ONLY_IO_CAPABILITY: {
-                hci.HCI_DISPLAY_ONLY_IO_CAPABILITY: display_auto_confirm,
-                hci.HCI_DISPLAY_YES_NO_IO_CAPABILITY: display_confirm,
-                hci.HCI_KEYBOARD_ONLY_IO_CAPABILITY: na,
-                hci.HCI_NO_INPUT_NO_OUTPUT_IO_CAPABILITY: auto_confirm,
+        methods: dict[int, dict[int, Callable[[], Awaitable[bool]]]] = {
+            hci.IoCapability.DISPLAY_ONLY: {
+                hci.IoCapability.DISPLAY_ONLY: display_auto_confirm,
+                hci.IoCapability.DISPLAY_YES_NO: display_confirm,
+                hci.IoCapability.KEYBOARD_ONLY: na,
+                hci.IoCapability.NO_INPUT_NO_OUTPUT: auto_confirm,
             },
-            hci.HCI_DISPLAY_YES_NO_IO_CAPABILITY: {
-                hci.HCI_DISPLAY_ONLY_IO_CAPABILITY: display_auto_confirm,
-                hci.HCI_DISPLAY_YES_NO_IO_CAPABILITY: display_confirm,
-                hci.HCI_KEYBOARD_ONLY_IO_CAPABILITY: na,
-                hci.HCI_NO_INPUT_NO_OUTPUT_IO_CAPABILITY: auto_confirm,
+            hci.IoCapability.DISPLAY_YES_NO: {
+                hci.IoCapability.DISPLAY_ONLY: display_auto_confirm,
+                hci.IoCapability.DISPLAY_YES_NO: display_confirm,
+                hci.IoCapability.KEYBOARD_ONLY: na,
+                hci.IoCapability.NO_INPUT_NO_OUTPUT: auto_confirm,
             },
-            hci.HCI_KEYBOARD_ONLY_IO_CAPABILITY: {
-                hci.HCI_DISPLAY_ONLY_IO_CAPABILITY: na,
-                hci.HCI_DISPLAY_YES_NO_IO_CAPABILITY: na,
-                hci.HCI_KEYBOARD_ONLY_IO_CAPABILITY: na,
-                hci.HCI_NO_INPUT_NO_OUTPUT_IO_CAPABILITY: auto_confirm,
+            hci.IoCapability.KEYBOARD_ONLY: {
+                hci.IoCapability.DISPLAY_ONLY: na,
+                hci.IoCapability.DISPLAY_YES_NO: na,
+                hci.IoCapability.KEYBOARD_ONLY: na,
+                hci.IoCapability.NO_INPUT_NO_OUTPUT: auto_confirm,
             },
-            hci.HCI_NO_INPUT_NO_OUTPUT_IO_CAPABILITY: {
-                hci.HCI_DISPLAY_ONLY_IO_CAPABILITY: confirm,
-                hci.HCI_DISPLAY_YES_NO_IO_CAPABILITY: confirm,
-                hci.HCI_KEYBOARD_ONLY_IO_CAPABILITY: auto_confirm,
-                hci.HCI_NO_INPUT_NO_OUTPUT_IO_CAPABILITY: auto_confirm,
+            hci.IoCapability.NO_INPUT_NO_OUTPUT: {
+                hci.IoCapability.DISPLAY_ONLY: confirm,
+                hci.IoCapability.DISPLAY_YES_NO: confirm,
+                hci.IoCapability.KEYBOARD_ONLY: auto_confirm,
+                hci.IoCapability.NO_INPUT_NO_OUTPUT: auto_confirm,
             },
         }
 
@@ -5728,9 +5852,7 @@ class Device(utils.CompositeEventEmitter):
 
         async def reply() -> None:
             try:
-                if await utils.cancel_on_event(
-                    connection, Connection.EVENT_DISCONNECTION, method()
-                ):
+                if await connection.cancel_on_disconnection(method()):
                     await self.host.send_command(
                         hci.HCI_User_Confirmation_Request_Reply_Command(
                             bd_addr=connection.peer_address
@@ -5757,10 +5879,8 @@ class Device(utils.CompositeEventEmitter):
 
         async def reply() -> None:
             try:
-                number = await utils.cancel_on_event(
-                    connection,
-                    Connection.EVENT_DISCONNECTION,
-                    pairing_config.delegate.get_number(),
+                number = await connection.cancel_on_disconnection(
+                    pairing_config.delegate.get_number()
                 )
                 if number is not None:
                     await self.host.send_command(
@@ -5780,6 +5900,19 @@ class Device(utils.CompositeEventEmitter):
 
         utils.AsyncRunner.spawn(reply())
 
+    # [Classic only]
+    @host_event_handler
+    @with_connection_from_handle
+    def on_mode_change(
+        self, connection: Connection, status: int, current_mode: int, interval: int
+    ):
+        if status == hci.HCI_SUCCESS:
+            connection.classic_mode = current_mode
+            connection.classic_interval = interval
+            connection.emit(connection.EVENT_MODE_CHANGE)
+        else:
+            connection.emit(connection.EVENT_MODE_CHANGE_FAILURE, status)
+
     # [Classic only]
     @host_event_handler
     @with_connection_from_address
@@ -5790,13 +5923,11 @@ class Device(utils.CompositeEventEmitter):
         io_capability = pairing_config.delegate.classic_io_capability
 
         # Respond
-        if io_capability == hci.HCI_KEYBOARD_ONLY_IO_CAPABILITY:
+        if io_capability == hci.IoCapability.KEYBOARD_ONLY:
             # Ask the user to enter a string
             async def get_pin_code():
-                pin_code = await utils.cancel_on_event(
-                    connection,
-                    Connection.EVENT_DISCONNECTION,
-                    pairing_config.delegate.get_string(16),
+                pin_code = await connection.cancel_on_disconnection(
+                    pairing_config.delegate.get_string(16)
                 )
 
                 if pin_code is not None:
@@ -5834,10 +5965,8 @@ class Device(utils.CompositeEventEmitter):
         pairing_config = self.pairing_config_factory(connection)
 
         # Show the passkey to the user
-        utils.cancel_on_event(
-            connection,
-            Connection.EVENT_DISCONNECTION,
-            pairing_config.delegate.display_number(passkey, digits=6),
+        connection.cancel_on_disconnection(
+            pairing_config.delegate.display_number(passkey, digits=6)
         )
 
     # [Classic only]
@@ -5924,24 +6053,63 @@ class Device(utils.CompositeEventEmitter):
             f'cis_id=[0x{cis_id:02X}] ***'
         )
         # LE_CIS_Established event doesn't provide info, so we must store them here.
-        self.cis_links[cis_handle] = CisLink(
+        cis_link = CisLink(
             device=self,
             acl_connection=acl_connection,
             handle=cis_handle,
             cig_id=cig_id,
             cis_id=cis_id,
         )
-        self.emit(self.EVENT_CIS_REQUEST, acl_connection, cis_handle, cig_id, cis_id)
+        self.cis_links[cis_handle] = cis_link
+        acl_connection.emit(acl_connection.EVENT_CIS_REQUEST, cis_link)
+        self.emit(self.EVENT_CIS_REQUEST, cis_link)
 
     # [LE only]
     @host_event_handler
     @utils.experimental('Only for testing')
-    def on_cis_establishment(self, cis_handle: int) -> None:
+    def on_cis_establishment(
+        self,
+        cis_handle: int,
+        cig_sync_delay: int,
+        cis_sync_delay: int,
+        transport_latency_c_to_p: int,
+        transport_latency_p_to_c: int,
+        phy_c_to_p: int,
+        phy_p_to_c: int,
+        nse: int,
+        bn_c_to_p: int,
+        bn_p_to_c: int,
+        ft_c_to_p: int,
+        ft_p_to_c: int,
+        max_pdu_c_to_p: int,
+        max_pdu_p_to_c: int,
+        iso_interval: int,
+    ) -> None:
+        if cis_handle not in self.cis_links:
+            logger.warning("CIS link not found")
+            return
+
         cis_link = self.cis_links[cis_handle]
         cis_link.state = CisLink.State.ESTABLISHED
 
         assert cis_link.acl_connection
 
+        # Update the CIS
+        cis_link.cig_sync_delay = cig_sync_delay
+        cis_link.cis_sync_delay = cis_sync_delay
+        cis_link.transport_latency_c_to_p = transport_latency_c_to_p
+        cis_link.transport_latency_p_to_c = transport_latency_p_to_c
+        cis_link.phy_c_to_p = hci.Phy(phy_c_to_p)
+        cis_link.phy_p_to_c = hci.Phy(phy_p_to_c)
+        cis_link.nse = nse
+        cis_link.bn_c_to_p = bn_c_to_p
+        cis_link.bn_p_to_c = bn_p_to_c
+        cis_link.ft_c_to_p = ft_c_to_p
+        cis_link.ft_p_to_c = ft_p_to_c
+        cis_link.max_pdu_c_to_p = max_pdu_c_to_p
+        cis_link.max_pdu_p_to_c = max_pdu_p_to_c
+        cis_link.iso_interval = iso_interval * 1.25
+
         logger.debug(
             f'*** CIS Establishment '
             f'{cis_link.acl_connection.peer_address}, '
@@ -5951,16 +6119,27 @@ class Device(utils.CompositeEventEmitter):
         )
 
         cis_link.emit(cis_link.EVENT_ESTABLISHMENT)
+        cis_link.acl_connection.emit(
+            cis_link.acl_connection.EVENT_CIS_ESTABLISHMENT, cis_link
+        )
         self.emit(self.EVENT_CIS_ESTABLISHMENT, cis_link)
 
     # [LE only]
     @host_event_handler
     @utils.experimental('Only for testing')
     def on_cis_establishment_failure(self, cis_handle: int, status: int) -> None:
+        if (cis_link := self.cis_links.pop(cis_handle, None)) is None:
+            logger.warning("CIS link not found")
+            return
+
         logger.debug(f'*** CIS Establishment Failure: cis=[0x{cis_handle:04X}] ***')
-        if cis_link := self.cis_links.pop(cis_handle):
-            cis_link.emit(cis_link.EVENT_ESTABLISHMENT_FAILURE, status)
-        self.emit(self.EVENT_CIS_ESTABLISHMENT_FAILURE, cis_handle, status)
+        cis_link.emit(cis_link.EVENT_ESTABLISHMENT_FAILURE, status)
+        cis_link.acl_connection.emit(
+            cis_link.acl_connection.EVENT_CIS_ESTABLISHMENT_FAILURE,
+            cis_link,
+            status,
+        )
+        self.emit(self.EVENT_CIS_ESTABLISHMENT_FAILURE, cis_link, status)
 
     # [LE only]
     @host_event_handler
@@ -5974,7 +6153,7 @@ class Device(utils.CompositeEventEmitter):
     @host_event_handler
     @with_connection_from_handle
     def on_connection_encryption_change(
-        self, connection, encryption, encryption_key_size
+        self, connection: Connection, encryption: int, encryption_key_size: int
     ):
         logger.debug(
             f'*** Connection Encryption Change: [0x{connection.handle:04X}] '
@@ -5987,14 +6166,14 @@ class Device(utils.CompositeEventEmitter):
         if (
             not connection.authenticated
             and connection.transport == PhysicalTransport.BR_EDR
-            and encryption == hci.HCI_Encryption_Change_Event.AES_CCM
+            and encryption == hci.HCI_Encryption_Change_Event.Enabled.AES_CCM
         ):
             connection.authenticated = True
             connection.sc = True
         if (
             not connection.authenticated
             and connection.transport == PhysicalTransport.LE
-            and encryption == hci.HCI_Encryption_Change_Event.E0_OR_AES_CCM
+            and encryption == hci.HCI_Encryption_Change_Event.Enabled.E0_OR_AES_CCM
         ):
             connection.authenticated = True
             connection.sc = True
@@ -6021,13 +6200,31 @@ class Device(utils.CompositeEventEmitter):
 
     @host_event_handler
     @with_connection_from_handle
-    def on_connection_parameters_update(self, connection, connection_parameters):
+    def on_connection_parameters_update(
+        self, connection: Connection, connection_parameters: core.ConnectionParameters
+    ):
         logger.debug(
             f'*** Connection Parameters Update: [0x{connection.handle:04X}] '
             f'{connection.peer_address} as {connection.role_name}, '
             f'{connection_parameters}'
         )
-        connection.parameters = connection_parameters
+        if (
+            connection.parameters.connection_interval
+            != connection_parameters.connection_interval * 1.25
+        ):
+            connection.parameters = Connection.Parameters(
+                connection_parameters.connection_interval * 1.25,
+                connection_parameters.peripheral_latency,
+                connection_parameters.supervision_timeout * 10.0,
+            )
+        else:
+            connection.parameters = Connection.Parameters(
+                connection_parameters.connection_interval * 1.25,
+                connection_parameters.peripheral_latency,
+                connection_parameters.supervision_timeout * 10.0,
+                connection.parameters.subrate_factor,
+                connection.parameters.continuation_number,
+            )
         connection.emit(connection.EVENT_CONNECTION_PARAMETERS_UPDATE)
 
     @host_event_handler
@@ -6060,6 +6257,25 @@ class Device(utils.CompositeEventEmitter):
         )
         connection.emit(connection.EVENT_CONNECTION_PHY_UPDATE_FAILURE, error)
 
+    @host_event_handler
+    @with_connection_from_handle
+    def on_le_subrate_change(
+        self,
+        connection: Connection,
+        subrate_factor: int,
+        peripheral_latency: int,
+        continuation_number: int,
+        supervision_timeout: int,
+    ):
+        connection.parameters = Connection.Parameters(
+            connection.parameters.connection_interval,
+            peripheral_latency,
+            supervision_timeout * 10.0,
+            subrate_factor,
+            continuation_number,
+        )
+        connection.emit(connection.EVENT_LE_SUBRATE_CHANGE)
+
     @host_event_handler
     @with_connection_from_handle
     def on_connection_att_mtu_update(self, connection, att_mtu):