bumble 0.0.179__py3-none-any.whl → 0.0.181__py3-none-any.whl

bumble/device.py

@@ -21,8 +21,9 @@ import functools
 import json
 import asyncio
 import logging
-from contextlib import asynccontextmanager, AsyncExitStack
+from contextlib import asynccontextmanager, AsyncExitStack, closing
 from dataclasses import dataclass
+from collections.abc import Iterable
 from typing import (
     Any,
     Callable,
@@ -32,6 +33,7 @@ from typing import (
     Optional,
     Tuple,
     Type,
+    TypeVar,
     Set,
     Union,
     cast,
@@ -47,6 +49,7 @@ from .hci import (
     HCI_AUTHENTICATED_COMBINATION_KEY_GENERATED_FROM_P_256_TYPE,
     HCI_CENTRAL_ROLE,
     HCI_COMMAND_STATUS_PENDING,
+    HCI_CONNECTED_ISOCHRONOUS_STREAM_LE_SUPPORTED_FEATURE,
     HCI_CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES_ERROR,
     HCI_DISPLAY_YES_NO_IO_CAPABILITY,
     HCI_DISPLAY_ONLY_IO_CAPABILITY,
@@ -83,29 +86,35 @@ from .hci import (
     HCI_Constant,
     HCI_Create_Connection_Cancel_Command,
     HCI_Create_Connection_Command,
+    HCI_Create_Connection_Command,
     HCI_Disconnect_Command,
     HCI_Encryption_Change_Event,
     HCI_Error,
     HCI_IO_Capability_Request_Reply_Command,
     HCI_Inquiry_Cancel_Command,
     HCI_Inquiry_Command,
+    HCI_IsoDataPacket,
+    HCI_LE_Accept_CIS_Request_Command,
     HCI_LE_Add_Device_To_Resolving_List_Command,
     HCI_LE_Advertising_Report_Event,
     HCI_LE_Clear_Resolving_List_Command,
     HCI_LE_Connection_Update_Command,
     HCI_LE_Create_Connection_Cancel_Command,
     HCI_LE_Create_Connection_Command,
+    HCI_LE_Create_CIS_Command,
     HCI_LE_Enable_Encryption_Command,
     HCI_LE_Extended_Advertising_Report_Event,
     HCI_LE_Extended_Create_Connection_Command,
     HCI_LE_Rand_Command,
     HCI_LE_Read_PHY_Command,
+    HCI_LE_Reject_CIS_Request_Command,
     HCI_LE_Remove_Advertising_Set_Command,
     HCI_LE_Set_Address_Resolution_Enable_Command,
     HCI_LE_Set_Advertising_Data_Command,
     HCI_LE_Set_Advertising_Enable_Command,
     HCI_LE_Set_Advertising_Parameters_Command,
     HCI_LE_Set_Advertising_Set_Random_Address_Command,
+    HCI_LE_Set_CIG_Parameters_Command,
     HCI_LE_Set_Data_Length_Command,
     HCI_LE_Set_Default_PHY_Command,
     HCI_LE_Set_Extended_Scan_Enable_Command,
@@ -114,6 +123,7 @@ from .hci import (
     HCI_LE_Set_Extended_Advertising_Data_Command,
     HCI_LE_Set_Extended_Advertising_Enable_Command,
     HCI_LE_Set_Extended_Advertising_Parameters_Command,
+    HCI_LE_Set_Host_Feature_Command,
     HCI_LE_Set_PHY_Command,
     HCI_LE_Set_Random_Address_Command,
     HCI_LE_Set_Scan_Enable_Command,
@@ -128,6 +138,7 @@ from .hci import (
     HCI_Switch_Role_Command,
     HCI_Set_Connection_Encryption_Command,
     HCI_StatusError,
+    HCI_SynchronousDataPacket,
     HCI_User_Confirmation_Request_Negative_Reply_Command,
     HCI_User_Confirmation_Request_Reply_Command,
     HCI_User_Passkey_Request_Negative_Reply_Command,
@@ -159,6 +170,7 @@ from .core import (
 from .utils import (
     AsyncRunner,
     CompositeEventEmitter,
+    EventWatcher,
     setup_event_forwarding,
     composite_listener,
     deprecated,
@@ -425,6 +437,38 @@ class AdvertisingType(IntEnum):
         )
 
 
+# -----------------------------------------------------------------------------
+@dataclass
+class LegacyAdvertiser:
+    device: Device
+    advertising_type: AdvertisingType
+    own_address_type: OwnAddressType
+    auto_restart: bool
+    advertising_data: Optional[bytes]
+    scan_response_data: Optional[bytes]
+
+    async def stop(self) -> None:
+        await self.device.stop_legacy_advertising()
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class ExtendedAdvertiser(CompositeEventEmitter):
+    device: Device
+    handle: int
+    advertising_properties: HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties
+    own_address_type: OwnAddressType
+    auto_restart: bool
+    advertising_data: Optional[bytes]
+    scan_response_data: Optional[bytes]
+
+    def __post_init__(self) -> None:
+        super().__init__()
+
+    async def stop(self) -> None:
+        await self.device.stop_extended_advertising(self.handle)
+
+
 # -----------------------------------------------------------------------------
 class LePhyOptions:
     # Coded PHY preference
@@ -440,8 +484,11 @@ class LePhyOptions:
 
 
 # -----------------------------------------------------------------------------
+_PROXY_CLASS = TypeVar('_PROXY_CLASS', bound=gatt_client.ProfileServiceProxy)
+
+
 class Peer:
-    def __init__(self, connection):
+    def __init__(self, connection: Connection) -> None:
         self.connection = connection
 
         # Create a GATT client for the connection
@@ -449,77 +496,113 @@ class Peer:
         connection.gatt_client = self.gatt_client
 
     @property
-    def services(self):
+    def services(self) -> List[gatt_client.ServiceProxy]:
         return self.gatt_client.services
 
-    async def request_mtu(self, mtu):
+    async def request_mtu(self, mtu: int) -> int:
         mtu = await self.gatt_client.request_mtu(mtu)
         self.connection.emit('connection_att_mtu_update')
         return mtu
 
-    async def discover_service(self, uuid):
+    async def discover_service(
+        self, uuid: Union[core.UUID, str]
+    ) -> List[gatt_client.ServiceProxy]:
         return await self.gatt_client.discover_service(uuid)
 
-    async def discover_services(self, uuids=()):
+    async def discover_services(
+        self, uuids: Iterable[core.UUID] = ()
+    ) -> List[gatt_client.ServiceProxy]:
         return await self.gatt_client.discover_services(uuids)
 
-    async def discover_included_services(self, service):
+    async def discover_included_services(
+        self, service: gatt_client.ServiceProxy
+    ) -> List[gatt_client.ServiceProxy]:
         return await self.gatt_client.discover_included_services(service)
 
-    async def discover_characteristics(self, uuids=(), service=None):
+    async def discover_characteristics(
+        self,
+        uuids: Iterable[Union[core.UUID, str]] = (),
+        service: Optional[gatt_client.ServiceProxy] = None,
+    ) -> List[gatt_client.CharacteristicProxy]:
         return await self.gatt_client.discover_characteristics(
             uuids=uuids, service=service
         )
 
     async def discover_descriptors(
-        self, characteristic=None, start_handle=None, end_handle=None
+        self,
+        characteristic: Optional[gatt_client.CharacteristicProxy] = None,
+        start_handle: Optional[int] = None,
+        end_handle: Optional[int] = None,
     ):
         return await self.gatt_client.discover_descriptors(
             characteristic, start_handle, end_handle
         )
 
-    async def discover_attributes(self):
+    async def discover_attributes(self) -> List[gatt_client.AttributeProxy]:
         return await self.gatt_client.discover_attributes()
 
-    async def subscribe(self, characteristic, subscriber=None, prefer_notify=True):
+    async def subscribe(
+        self,
+        characteristic: gatt_client.CharacteristicProxy,
+        subscriber: Optional[Callable[[bytes], Any]] = None,
+        prefer_notify: bool = True,
+    ) -> None:
         return await self.gatt_client.subscribe(
             characteristic, subscriber, prefer_notify
         )
 
-    async def unsubscribe(self, characteristic, subscriber=None):
+    async def unsubscribe(
+        self,
+        characteristic: gatt_client.CharacteristicProxy,
+        subscriber: Optional[Callable[[bytes], Any]] = None,
+    ) -> None:
         return await self.gatt_client.unsubscribe(characteristic, subscriber)
 
-    async def read_value(self, attribute):
+    async def read_value(
+        self, attribute: Union[int, gatt_client.AttributeProxy]
+    ) -> bytes:
         return await self.gatt_client.read_value(attribute)
 
-    async def write_value(self, attribute, value, with_response=False):
+    async def write_value(
+        self,
+        attribute: Union[int, gatt_client.AttributeProxy],
+        value: bytes,
+        with_response: bool = False,
+    ) -> None:
         return await self.gatt_client.write_value(attribute, value, with_response)
 
-    async def read_characteristics_by_uuid(self, uuid, service=None):
+    async def read_characteristics_by_uuid(
+        self, uuid: core.UUID, service: Optional[gatt_client.ServiceProxy] = None
+    ) -> List[bytes]:
         return await self.gatt_client.read_characteristics_by_uuid(uuid, service)
 
-    def get_services_by_uuid(self, uuid):
+    def get_services_by_uuid(self, uuid: core.UUID) -> List[gatt_client.ServiceProxy]:
         return self.gatt_client.get_services_by_uuid(uuid)
 
-    def get_characteristics_by_uuid(self, uuid, service=None):
+    def get_characteristics_by_uuid(
+        self, uuid: core.UUID, service: Optional[gatt_client.ServiceProxy] = None
+    ) -> List[gatt_client.CharacteristicProxy]:
         return self.gatt_client.get_characteristics_by_uuid(uuid, service)
 
-    def create_service_proxy(self, proxy_class):
-        return proxy_class.from_client(self.gatt_client)
+    def create_service_proxy(self, proxy_class: Type[_PROXY_CLASS]) -> _PROXY_CLASS:
+        return cast(_PROXY_CLASS, proxy_class.from_client(self.gatt_client))
 
-    async def discover_service_and_create_proxy(self, proxy_class):
+    async def discover_service_and_create_proxy(
+        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)
         if services:
             service = services[0]
             await service.discover_characteristics()
             return self.create_service_proxy(proxy_class)
+        return None
 
-    async def sustain(self, timeout=None):
+    async def sustain(self, timeout: Optional[float] = None) -> None:
         await self.connection.sustain(timeout)
 
     # [Classic only]
-    async def request_name(self):
+    async def request_name(self) -> str:
         return await self.connection.request_remote_name()
 
     async def __aenter__(self):
@@ -532,7 +615,7 @@ class Peer:
     async def __aexit__(self, exc_type, exc_value, traceback):
         pass
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f'{self.connection.peer_address} as {self.connection.role_name}'
 
 
@@ -551,6 +634,46 @@ class ConnectionParametersPreferences:
 ConnectionParametersPreferences.default = ConnectionParametersPreferences()
 
 
+# -----------------------------------------------------------------------------
+@dataclass
+class ScoLink(CompositeEventEmitter):
+    device: Device
+    acl_connection: Connection
+    handle: int
+    link_type: int
+
+    def __post_init__(self):
+        super().__init__()
+
+    async def disconnect(
+        self, reason: int = HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR
+    ) -> None:
+        await self.device.disconnect(self, reason)
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class CisLink(CompositeEventEmitter):
+    class State(IntEnum):
+        PENDING = 0
+        ESTABLISHED = 1
+
+    device: Device
+    acl_connection: Connection  # Based ACL connection
+    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
+    state: State = State.PENDING
+
+    def __post_init__(self):
+        super().__init__()
+
+    async def disconnect(
+        self, reason: int = HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR
+    ) -> None:
+        await self.device.disconnect(self, reason)
+
+
 # -----------------------------------------------------------------------------
 class Connection(CompositeEventEmitter):
     device: Device
@@ -567,6 +690,9 @@ class Connection(CompositeEventEmitter):
     gatt_client: gatt_client.Client
     pairing_peer_io_capability: Optional[int]
     pairing_peer_authentication_requirements: Optional[int]
+    advertiser_after_disconnection: Union[
+        LegacyAdvertiser, ExtendedAdvertiser, None
+    ] = None
 
     @composite_listener
     class Listener:
@@ -732,7 +858,7 @@ class Connection(CompositeEventEmitter):
     async def switch_role(self, role: int) -> None:
         return await self.device.switch_role(self, role)
 
-    async def sustain(self, timeout=None):
+    async def sustain(self, timeout: Optional[float] = None) -> None:
         """Idles the current task waiting for a disconnect or timeout"""
 
         abort = asyncio.get_running_loop().create_future()
@@ -829,6 +955,7 @@ class DeviceConfiguration:
         self.keystore = None
         self.gatt_services: List[Dict[str, Any]] = []
         self.address_resolution_offload = False
+        self.cis_enabled = False
 
     def load_from_dict(self, config: Dict[str, Any]) -> None:
         # Load simple properties
@@ -864,6 +991,7 @@ class DeviceConfiguration:
         self.address_resolution_offload = config.get(
             'address_resolution_offload', self.address_resolution_offload
         )
+        self.cis_enabled = config.get('cis_enabled', self.cis_enabled)
 
         # Load or synthesize an IRK
         irk = config.get('irk')
@@ -970,7 +1098,11 @@ class Device(CompositeEventEmitter):
     ]
     advertisement_accumulators: Dict[Address, AdvertisementDataAccumulator]
     config: DeviceConfiguration
-    extended_advertising_handles: Set[int]
+    legacy_advertiser: Optional[LegacyAdvertiser]
+    extended_advertisers: Dict[int, ExtendedAdvertiser]
+    sco_links: Dict[int, ScoLink]
+    cis_links: Dict[int, CisLink]
+    _pending_cis: Dict[int, Tuple[int, int]]
 
     @composite_listener
     class Listener:
@@ -1045,10 +1177,7 @@ class Device(CompositeEventEmitter):
 
         self._host = None
         self.powered_on = False
-        self.advertising = False
-        self.advertising_type = None
         self.auto_restart_inquiry = True
-        self.auto_restart_advertising = False
         self.command_timeout = 10  # seconds
         self.gatt_server = gatt_server.Server(self)
         self.sdp_server = sdp.Server(self)
@@ -1063,16 +1192,19 @@ class Device(CompositeEventEmitter):
         self.disconnecting = False
         self.connections = {}  # Connections, by connection handle
         self.pending_connections = {}  # Connections, by BD address (BR/EDR only)
+        self.sco_links = {}  # ScoLinks, by connection handle (BR/EDR only)
+        self.cis_links = {}  # CisLinks, by connection handle (LE only)
+        self._pending_cis = {}  # (CIS_ID, CIG_ID), by CIS_handle
         self.classic_enabled = False
         self.inquiry_response = None
         self.address_resolver = None
         self.classic_pending_accepts = {
             Address.ANY: []
         }  # Futures, by BD address OR [Futures] for Address.ANY
-        self.extended_advertising_handles = set()
+        self.legacy_advertiser = None
+        self.extended_advertisers = {}
 
         # Own address type cache
-        self.advertising_own_address_type = None
         self.connect_own_address_type = None
 
         # Use the initial config or a default
@@ -1092,6 +1224,7 @@ class Device(CompositeEventEmitter):
         self.le_enabled = config.le_enabled
         self.classic_enabled = config.classic_enabled
         self.le_simultaneous_enabled = config.le_simultaneous_enabled
+        self.cis_enabled = config.cis_enabled
         self.classic_sc_enabled = config.classic_sc_enabled
         self.classic_ssp_enabled = config.classic_ssp_enabled
         self.classic_smp_enabled = config.classic_smp_enabled
@@ -1332,7 +1465,7 @@ class Device(CompositeEventEmitter):
         await self.host.reset()
 
         # Try to get the public address from the controller
-        response = await self.send_command(HCI_Read_BD_ADDR_Command())  # type: ignore[call-arg]
+        response = await self.send_command(HCI_Read_BD_ADDR_Command())
         if response.return_parameters.status == HCI_SUCCESS:
             logger.debug(
                 color(f'BD_ADDR: {response.return_parameters.bd_addr}', 'yellow')
@@ -1355,7 +1488,7 @@ class Device(CompositeEventEmitter):
                 HCI_Write_LE_Host_Support_Command(
                     le_supported_host=int(self.le_enabled),
                     simultaneous_le_host=int(self.le_simultaneous_enabled),
-                )  # type: ignore[call-arg]
+                )
             )
 
         if self.le_enabled:
@@ -1365,7 +1498,7 @@ class Device(CompositeEventEmitter):
                 if self.host.supports_command(HCI_LE_RAND_COMMAND):
                     # Get 8 random bytes
                     response = await self.send_command(
-                        HCI_LE_Rand_Command(), check_result=True  # type: ignore[call-arg]
+                        HCI_LE_Rand_Command(), check_result=True
                     )
 
                     # Ensure the address bytes can be a static random address
@@ -1386,7 +1519,7 @@ class Device(CompositeEventEmitter):
                 await self.send_command(
                     HCI_LE_Set_Random_Address_Command(
                         random_address=self.random_address
-                    ),  # type: ignore[call-arg]
+                    ),
                     check_result=True,
                 )
 
@@ -1399,25 +1532,35 @@ class Device(CompositeEventEmitter):
                 await self.send_command(
                     HCI_LE_Set_Address_Resolution_Enable_Command(
                         address_resolution_enable=1
-                    )  # type: ignore[call-arg]
+                    )
+                )
+
+            if self.cis_enabled:
+                await self.send_command(
+                    HCI_LE_Set_Host_Feature_Command(
+                        bit_number=(
+                            HCI_CONNECTED_ISOCHRONOUS_STREAM_LE_SUPPORTED_FEATURE
+                        ),
+                        bit_value=1,
+                    )
                 )
 
         if self.classic_enabled:
             await self.send_command(
-                HCI_Write_Local_Name_Command(local_name=self.name.encode('utf8'))  # type: ignore[call-arg]
+                HCI_Write_Local_Name_Command(local_name=self.name.encode('utf8'))
             )
             await self.send_command(
-                HCI_Write_Class_Of_Device_Command(class_of_device=self.class_of_device)  # type: ignore[call-arg]
+                HCI_Write_Class_Of_Device_Command(class_of_device=self.class_of_device)
             )
             await self.send_command(
                 HCI_Write_Simple_Pairing_Mode_Command(
                     simple_pairing_mode=int(self.classic_ssp_enabled)
-                )  # type: ignore[call-arg]
+                )
             )
             await self.send_command(
                 HCI_Write_Secure_Connections_Host_Support_Command(
                     secure_connections_host_support=int(self.classic_sc_enabled)
-                )  # type: ignore[call-arg]
+                )
             )
             await self.set_connectable(self.connectable)
             await self.set_discoverable(self.discoverable)
@@ -1441,7 +1584,7 @@ class Device(CompositeEventEmitter):
         self.address_resolver = smp.AddressResolver(resolving_keys)
 
         if self.address_resolution_offload:
-            await self.send_command(HCI_LE_Clear_Resolving_List_Command())  # type: ignore[call-arg]
+            await self.send_command(HCI_LE_Clear_Resolving_List_Command())
 
             for irk, address in resolving_keys:
                 await self.send_command(
@@ -1450,7 +1593,7 @@ class Device(CompositeEventEmitter):
                         peer_identity_address=address,
                         peer_irk=irk,
                         local_irk=self.irk,
-                    )  # type: ignore[call-arg]
+                    )
                 )
 
     def supports_le_feature(self, feature):
@@ -1469,6 +1612,7 @@ class Device(CompositeEventEmitter):
 
         return self.host.supports_le_feature(feature_map[phy])
 
+    @deprecated("Please use start_legacy_advertising.")
     async def start_advertising(
         self,
         advertising_type: AdvertisingType = AdvertisingType.UNDIRECTED_CONNECTABLE_SCANNABLE,
@@ -1476,16 +1620,50 @@ class Device(CompositeEventEmitter):
         own_address_type: int = OwnAddressType.RANDOM,
         auto_restart: bool = False,
     ) -> None:
+        await self.start_legacy_advertising(
+            advertising_type=advertising_type,
+            target=target,
+            own_address_type=OwnAddressType(own_address_type),
+            auto_restart=auto_restart,
+        )
+
+    async def start_legacy_advertising(
+        self,
+        advertising_type: AdvertisingType = AdvertisingType.UNDIRECTED_CONNECTABLE_SCANNABLE,
+        target: Optional[Address] = None,
+        own_address_type: OwnAddressType = OwnAddressType.RANDOM,
+        auto_restart: bool = False,
+        advertising_data: Optional[bytes] = None,
+        scan_response_data: Optional[bytes] = None,
+    ) -> LegacyAdvertiser:
+        """Starts an legacy advertisement.
+
+        Args:
+          advertising_type: Advertising type passed to HCI_LE_Set_Advertising_Parameters_Command.
+          target: Directed advertising target. Directed type should be set in advertising_type arg.
+          own_address_type: own address type to use in the advertising.
+          auto_restart: whether the advertisement will be restarted after disconnection.
+          scan_response_data: raw scan response.
+          advertising_data: raw advertising data.
+
+        Returns:
+          LegacyAdvertiser object containing the metadata of advertisement.
+        """
+        if self.extended_advertisers:
+            logger.warning(
+                'Trying to start Legacy and Extended Advertising at the same time!'
+            )
+
         # If we're advertising, stop first
-        if self.advertising:
+        if self.legacy_advertiser:
             await self.stop_advertising()
 
         # Set/update the advertising data if the advertising type allows it
         if advertising_type.has_data:
             await self.send_command(
                 HCI_LE_Set_Advertising_Data_Command(
-                    advertising_data=self.advertising_data
-                ),  # type: ignore[call-arg]
+                    advertising_data=advertising_data or self.advertising_data or b''
+                ),
                 check_result=True,
             )
 
@@ -1493,8 +1671,10 @@ class Device(CompositeEventEmitter):
         if advertising_type.is_scannable:
             await self.send_command(
                 HCI_LE_Set_Scan_Response_Data_Command(
-                    scan_response_data=self.scan_response_data
-                ),  # type: ignore[call-arg]
+                    scan_response_data=scan_response_data
+                    or self.scan_response_data
+                    or b''
+                ),
                 check_result=True,
             )
 
@@ -1520,55 +1700,67 @@ class Device(CompositeEventEmitter):
                 peer_address=peer_address,
                 advertising_channel_map=7,
                 advertising_filter_policy=0,
-            ),  # type: ignore[call-arg]
+            ),
             check_result=True,
         )
 
         # Enable advertising
         await self.send_command(
-            HCI_LE_Set_Advertising_Enable_Command(advertising_enable=1),  # type: ignore[call-arg]
+            HCI_LE_Set_Advertising_Enable_Command(advertising_enable=1),
             check_result=True,
         )
 
-        self.advertising_type = advertising_type
-        self.advertising_own_address_type = own_address_type
-        self.advertising = True
-        self.auto_restart_advertising = auto_restart
+        self.legacy_advertiser = LegacyAdvertiser(
+            device=self,
+            advertising_type=advertising_type,
+            own_address_type=own_address_type,
+            auto_restart=auto_restart,
+            advertising_data=advertising_data,
+            scan_response_data=scan_response_data,
+        )
+        return self.legacy_advertiser
 
+    @deprecated("Please use stop_legacy_advertising.")
     async def stop_advertising(self) -> None:
+        await self.stop_legacy_advertising()
+
+    async def stop_legacy_advertising(self) -> None:
         # Disable advertising
-        if self.advertising:
+        if self.legacy_advertiser:
             await self.send_command(
-                HCI_LE_Set_Advertising_Enable_Command(advertising_enable=0),  # type: ignore[call-arg]
+                HCI_LE_Set_Advertising_Enable_Command(advertising_enable=0),
                 check_result=True,
             )
 
-            self.advertising_type = None
-            self.advertising_own_address_type = None
-            self.advertising = False
-            self.auto_restart_advertising = False
+            self.legacy_advertiser = None
 
     @experimental('Extended Advertising is still experimental - Might be changed soon.')
     async def start_extended_advertising(
         self,
         advertising_properties: HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties = HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties.CONNECTABLE_ADVERTISING,
         target: Address = Address.ANY,
-        own_address_type: int = OwnAddressType.RANDOM,
-        scan_response: Optional[bytes] = None,
+        own_address_type: OwnAddressType = OwnAddressType.RANDOM,
+        auto_restart: bool = True,
         advertising_data: Optional[bytes] = None,
-    ) -> int:
+        scan_response_data: Optional[bytes] = None,
+    ) -> ExtendedAdvertiser:
         """Starts an extended advertising set.
 
         Args:
           advertising_properties: Properties to pass in HCI_LE_Set_Extended_Advertising_Parameters_Command
           target: Directed advertising target. Directed property should be set in advertising_properties arg.
           own_address_type: own address type to use in the advertising.
-          scan_response: raw scan response. When a non-none value is set, HCI_LE_Set_Extended_Scan_Response_Data_Command will be sent.
+          auto_restart: whether the advertisement will be restarted after disconnection.
           advertising_data: raw advertising data. When a non-none value is set, HCI_LE_Set_Advertising_Set_Random_Address_Command will be sent.
+          scan_response_data: raw scan response. When a non-none value is set, HCI_LE_Set_Extended_Scan_Response_Data_Command will be sent.
 
         Returns:
-          Handle of the new advertising set.
+          ExtendedAdvertiser object containing the metadata of advertisement.
         """
+        if self.legacy_advertiser:
+            logger.warning(
+                'Trying to start Legacy and Extended Advertising at the same time!'
+            )
 
         adv_handle = -1
         # Find a free handle
@@ -1576,7 +1768,7 @@ class Device(CompositeEventEmitter):
             DEVICE_MIN_EXTENDED_ADVERTISING_SET_HANDLE,
             DEVICE_MAX_EXTENDED_ADVERTISING_SET_HANDLE + 1,
         ):
-            if i not in self.extended_advertising_handles:
+            if i not in self.extended_advertisers:
                 adv_handle = i
                 break
 
@@ -1606,7 +1798,7 @@ class Device(CompositeEventEmitter):
                     secondary_advertising_phy=1,  # LE 1M
                     advertising_sid=0,
                     scan_request_notification_enable=0,
-                ),  # type: ignore[call-arg]
+                ),
                 check_result=True,
             )
 
@@ -1618,19 +1810,19 @@ class Device(CompositeEventEmitter):
                         operation=HCI_LE_Set_Extended_Advertising_Data_Command.Operation.COMPLETE_DATA,
                         fragment_preference=0x01,  # Should not fragment
                         advertising_data=advertising_data,
-                    ),  # type: ignore[call-arg]
+                    ),
                     check_result=True,
                 )
 
             # Set the scan response if present
-            if scan_response is not None:
+            if scan_response_data is not None:
                 await self.send_command(
                     HCI_LE_Set_Extended_Scan_Response_Data_Command(
                         advertising_handle=adv_handle,
                         operation=HCI_LE_Set_Extended_Advertising_Data_Command.Operation.COMPLETE_DATA,
                         fragment_preference=0x01,  # Should not fragment
-                        scan_response_data=scan_response,
-                    ),  # type: ignore[call-arg]
+                        scan_response_data=scan_response_data,
+                    ),
                     check_result=True,
                 )
 
@@ -1642,7 +1834,7 @@ class Device(CompositeEventEmitter):
                     HCI_LE_Set_Advertising_Set_Random_Address_Command(
                         advertising_handle=adv_handle,
                         random_address=self.random_address,
-                    ),  # type: ignore[call-arg]
+                    ),
                     check_result=True,
                 )
 
@@ -1653,19 +1845,27 @@ class Device(CompositeEventEmitter):
                     advertising_handles=[adv_handle],
                     durations=[0],  # Forever
                     max_extended_advertising_events=[0],  # Infinite
-                ),  # type: ignore[call-arg]
+                ),
                 check_result=True,
             )
         except HCI_Error as error:
             # When any step fails, cleanup the advertising handle.
             await self.send_command(
-                HCI_LE_Remove_Advertising_Set_Command(advertising_handle=adv_handle),  # type: ignore[call-arg]
+                HCI_LE_Remove_Advertising_Set_Command(advertising_handle=adv_handle),
                 check_result=False,
             )
             raise error
 
-        self.extended_advertising_handles.add(adv_handle)
-        return adv_handle
+        advertiser = self.extended_advertisers[adv_handle] = ExtendedAdvertiser(
+            device=self,
+            handle=adv_handle,
+            advertising_properties=advertising_properties,
+            own_address_type=own_address_type,
+            auto_restart=auto_restart,
+            advertising_data=advertising_data,
+            scan_response_data=scan_response_data,
+        )
+        return advertiser
 
     @experimental('Extended Advertising is still experimental - Might be changed soon.')
     async def stop_extended_advertising(self, adv_handle: int) -> None:
@@ -1681,19 +1881,19 @@ class Device(CompositeEventEmitter):
                 advertising_handles=[adv_handle],
                 durations=[0],
                 max_extended_advertising_events=[0],
-            ),  # type: ignore[call-arg]
+            ),
             check_result=True,
         )
         # Remove advertising set
         await self.send_command(
-            HCI_LE_Remove_Advertising_Set_Command(advertising_handle=adv_handle),  # type: ignore[call-arg]
+            HCI_LE_Remove_Advertising_Set_Command(advertising_handle=adv_handle),
             check_result=True,
         )
-        self.extended_advertising_handles.remove(adv_handle)
+        del self.extended_advertisers[adv_handle]
 
     @property
     def is_advertising(self):
-        return self.advertising
+        return self.legacy_advertiser or self.extended_advertisers
 
     async def start_scanning(
         self,
@@ -1754,7 +1954,7 @@ class Device(CompositeEventEmitter):
                     scan_types=[scan_type] * scanning_phy_count,
                     scan_intervals=[int(scan_window / 0.625)] * scanning_phy_count,
                     scan_windows=[int(scan_window / 0.625)] * scanning_phy_count,
-                ),  # type: ignore[call-arg]
+                ),
                 check_result=True,
             )
 
@@ -1765,7 +1965,7 @@ class Device(CompositeEventEmitter):
                     filter_duplicates=1 if filter_duplicates else 0,
                     duration=0,  # TODO allow other values
                     period=0,  # TODO allow other values
-                ),  # type: ignore[call-arg]
+                ),
                 check_result=True,
             )
         else:
@@ -1783,7 +1983,7 @@ class Device(CompositeEventEmitter):
                     le_scan_window=int(scan_window / 0.625),
                     own_address_type=own_address_type,
                     scanning_filter_policy=HCI_LE_Set_Scan_Parameters_Command.BASIC_UNFILTERED_POLICY,
-                ),  # type: ignore[call-arg]
+                ),
                 check_result=True,
             )
 
@@ -1791,7 +1991,7 @@ class Device(CompositeEventEmitter):
             await self.send_command(
                 HCI_LE_Set_Scan_Enable_Command(
                     le_scan_enable=1, filter_duplicates=1 if filter_duplicates else 0
-                ),  # type: ignore[call-arg]
+                ),
                 check_result=True,
             )
 
@@ -1804,12 +2004,12 @@ class Device(CompositeEventEmitter):
             await self.send_command(
                 HCI_LE_Set_Extended_Scan_Enable_Command(
                     enable=0, filter_duplicates=0, duration=0, period=0
-                ),  # type: ignore[call-arg]
+                ),
                 check_result=True,
             )
         else:
             await self.send_command(
-                HCI_LE_Set_Scan_Enable_Command(le_scan_enable=0, filter_duplicates=0),  # type: ignore[call-arg]
+                HCI_LE_Set_Scan_Enable_Command(le_scan_enable=0, filter_duplicates=0),
                 check_result=True,
             )
 
@@ -1829,7 +2029,7 @@ class Device(CompositeEventEmitter):
 
     async def start_discovery(self, auto_restart: bool = True) -> None:
         await self.send_command(
-            HCI_Write_Inquiry_Mode_Command(inquiry_mode=HCI_EXTENDED_INQUIRY_MODE),  # type: ignore[call-arg]
+            HCI_Write_Inquiry_Mode_Command(inquiry_mode=HCI_EXTENDED_INQUIRY_MODE),
             check_result=True,
         )
 
@@ -1838,7 +2038,7 @@ class Device(CompositeEventEmitter):
                 lap=HCI_GENERAL_INQUIRY_LAP,
                 inquiry_length=DEVICE_DEFAULT_INQUIRY_LENGTH,
                 num_responses=0,  # Unlimited number of responses.
-            )  # type: ignore[call-arg]
+            )
         )
         if response.status != HCI_Command_Status_Event.PENDING:
             self.discovering = False
@@ -1849,7 +2049,7 @@ class Device(CompositeEventEmitter):
 
     async def stop_discovery(self) -> None:
         if self.discovering:
-            await self.send_command(HCI_Inquiry_Cancel_Command(), check_result=True)  # type: ignore[call-arg]
+            await self.send_command(HCI_Inquiry_Cancel_Command(), check_result=True)
         self.auto_restart_inquiry = True
         self.discovering = False
 
@@ -1897,7 +2097,7 @@ class Device(CompositeEventEmitter):
             await self.send_command(
                 HCI_Write_Extended_Inquiry_Response_Command(
                     fec_required=0, extended_inquiry_response=self.inquiry_response
-                ),  # type: ignore[call-arg]
+                ),
                 check_result=True,
             )
             await self.set_scan_enable(
@@ -2086,7 +2286,7 @@ class Device(CompositeEventEmitter):
                             supervision_timeouts=supervision_timeouts,
                             min_ce_lengths=min_ce_lengths,
                             max_ce_lengths=max_ce_lengths,
-                        )  # type: ignore[call-arg]
+                        )
                     )
                 else:
                     if HCI_LE_1M_PHY not in connection_parameters_preferences:
@@ -2115,7 +2315,7 @@ class Device(CompositeEventEmitter):
                             supervision_timeout=int(prefs.supervision_timeout / 10),
                             min_ce_length=int(prefs.min_ce_length / 0.625),
                             max_ce_length=int(prefs.max_ce_length / 0.625),
-                        )  # type: ignore[call-arg]
+                        )
                     )
             else:
                 # Save pending connection
@@ -2132,7 +2332,7 @@ class Device(CompositeEventEmitter):
                         clock_offset=0x0000,
                         allow_role_switch=0x01,
                         reserved=0,
-                    )  # type: ignore[call-arg]
+                    )
                 )
 
             if result.status != HCI_Command_Status_Event.PENDING:
@@ -2151,10 +2351,10 @@ class Device(CompositeEventEmitter):
                 )
             except asyncio.TimeoutError:
                 if transport == BT_LE_TRANSPORT:
-                    await self.send_command(HCI_LE_Create_Connection_Cancel_Command())  # type: ignore[call-arg]
+                    await self.send_command(HCI_LE_Create_Connection_Cancel_Command())
                 else:
                     await self.send_command(
-                        HCI_Create_Connection_Cancel_Command(bd_addr=peer_address)  # type: ignore[call-arg]
+                        HCI_Create_Connection_Cancel_Command(bd_addr=peer_address)
                     )
 
                 try:
@@ -2268,7 +2468,7 @@ class Device(CompositeEventEmitter):
         try:
             # Accept connection request
             await self.send_command(
-                HCI_Accept_Connection_Request_Command(bd_addr=peer_address, role=role)  # type: ignore[call-arg]
+                HCI_Accept_Connection_Request_Command(bd_addr=peer_address, role=role)
             )
 
             # Wait for connection complete
@@ -2325,7 +2525,9 @@ class Device(CompositeEventEmitter):
                 check_result=True,
             )
 
-    async def disconnect(self, connection, reason):
+    async def disconnect(
+        self, connection: Union[Connection, ScoLink, CisLink], reason: int
+    ) -> 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)
@@ -2364,7 +2566,7 @@ class Device(CompositeEventEmitter):
                 connection_handle=connection.handle,
                 tx_octets=tx_octets,
                 tx_time=tx_time,
-            ),  # type: ignore[call-arg]
+            ),
             check_result=True,
         )
 
@@ -2410,7 +2612,7 @@ class Device(CompositeEventEmitter):
                 supervision_timeout=supervision_timeout,
                 min_ce_length=min_ce_length,
                 max_ce_length=max_ce_length,
-            )  # type: ignore[call-arg]
+            )
         )
         if result.status != HCI_Command_Status_Event.PENDING:
             raise HCI_StatusError(result)
@@ -2738,7 +2940,7 @@ class Device(CompositeEventEmitter):
 
         try:
             result = await self.send_command(
-                HCI_Switch_Role_Command(bd_addr=connection.peer_address, role=role)  # type: ignore[call-arg]
+                HCI_Switch_Role_Command(bd_addr=connection.peer_address, role=role)
             )
             if result.status != HCI_COMMAND_STATUS_PENDING:
                 logger.warning(
@@ -2780,7 +2982,7 @@ class Device(CompositeEventEmitter):
                     page_scan_repetition_mode=HCI_Remote_Name_Request_Command.R2,
                     reserved=0,
                     clock_offset=0,  # TODO investigate non-0 values
-                )  # type: ignore[call-arg]
+                )
             )
 
             if result.status != HCI_COMMAND_STATUS_PENDING:
@@ -2796,6 +2998,150 @@ class Device(CompositeEventEmitter):
             self.remove_listener('remote_name', handler)
             self.remove_listener('remote_name_failure', failure_handler)
 
+    # [LE only]
+    @experimental('Only for testing.')
+    async def setup_cig(
+        self,
+        cig_id: int,
+        cis_id: List[int],
+        sdu_interval: Tuple[int, int],
+        framing: int,
+        max_sdu: Tuple[int, int],
+        retransmission_number: int,
+        max_transport_latency: Tuple[int, int],
+    ) -> List[int]:
+        """Sends 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).
+
+        Returns:
+            List of created CIS handles corresponding to the same order of [cid_id].
+        """
+        num_cis = len(cis_id)
+
+        response = await self.send_command(
+            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_LE_2M_PHY] * num_cis,
+                phy_p_to_c=[HCI_LE_2M_PHY] * num_cis,
+                rtn_c_to_p=[retransmission_number] * num_cis,
+                rtn_p_to_c=[retransmission_number] * num_cis,
+            ),
+            check_result=True,
+        )
+
+        # 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)
+
+        return cis_handles
+
+    # [LE only]
+    @experimental('Only for testing.')
+    async def create_cis(self, cis_acl_pairs: List[Tuple[int, int]]) -> List[CisLink]:
+        for cis_handle, acl_handle in cis_acl_pairs:
+            acl_connection = self.lookup_connection(acl_handle)
+            assert acl_connection
+            cis_id, cig_id = self._pending_cis.pop(cis_handle)
+            self.cis_links[cis_handle] = CisLink(
+                device=self,
+                acl_connection=acl_connection,
+                handle=cis_handle,
+                cis_id=cis_id,
+                cig_id=cig_id,
+            )
+
+        result = await self.send_command(
+            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],
+            ),
+        )
+        if result.status != HCI_COMMAND_STATUS_PENDING:
+            logger.warning(
+                'HCI_LE_Create_CIS_Command failed: '
+                f'{HCI_Constant.error_name(result.status)}'
+            )
+            raise HCI_StatusError(result)
+
+        pending_cis_establishments: Dict[int, asyncio.Future[CisLink]] = {}
+        for cis_handle, _ in cis_acl_pairs:
+            pending_cis_establishments[
+                cis_handle
+            ] = asyncio.get_running_loop().create_future()
+
+        with closing(EventWatcher()) as watcher:
+
+            @watcher.on(self, 'cis_establishment')
+            def on_cis_establishment(cis_link: CisLink) -> None:
+                if pending_future := pending_cis_establishments.get(
+                    cis_link.handle, None
+                ):
+                    pending_future.set_result(cis_link)
+
+            return await asyncio.gather(*pending_cis_establishments.values())
+
+    # [LE only]
+    @experimental('Only for testing.')
+    async def accept_cis_request(self, handle: int) -> CisLink:
+        result = await self.send_command(
+            HCI_LE_Accept_CIS_Request_Command(connection_handle=handle),
+        )
+        if result.status != HCI_COMMAND_STATUS_PENDING:
+            logger.warning(
+                'HCI_LE_Accept_CIS_Request_Command failed: '
+                f'{HCI_Constant.error_name(result.status)}'
+            )
+            raise HCI_StatusError(result)
+
+        pending_cis_establishment = asyncio.get_running_loop().create_future()
+
+        with closing(EventWatcher()) as watcher:
+
+            @watcher.on(self, 'cis_establishment')
+            def on_cis_establishment(cis_link: CisLink) -> None:
+                if cis_link.handle == handle:
+                    pending_cis_establishment.set_result(cis_link)
+
+            return await pending_cis_establishment
+
+    # [LE only]
+    @experimental('Only for testing.')
+    async def reject_cis_request(
+        self,
+        handle: int,
+        reason: int = HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR,
+    ) -> None:
+        result = await self.send_command(
+            HCI_LE_Reject_CIS_Request_Command(connection_handle=handle, reason=reason),
+        )
+        if result.status != HCI_COMMAND_STATUS_PENDING:
+            logger.warning(
+                'HCI_LE_Reject_CIS_Request_Command failed: '
+                f'{HCI_Constant.error_name(result.status)}'
+            )
+            raise HCI_StatusError(result)
+
     @host_event_handler
     def on_flush(self):
         self.emit('flush')
@@ -2888,13 +3234,18 @@ class Device(CompositeEventEmitter):
             # Guess which own address type is used for this connection.
             # This logic is somewhat correct but may need to be improved
             # when multiple advertising are run simultaneously.
+            advertiser = None
             if self.connect_own_address_type is not None:
                 own_address_type = self.connect_own_address_type
+            elif self.legacy_advertiser:
+                own_address_type = self.legacy_advertiser.own_address_type
+                # Store advertiser for restarting - it's only required for legacy, since
+                # extended advertisement produces HCI_Advertising_Set_Terminated.
+                if self.legacy_advertiser.auto_restart:
+                    advertiser = self.legacy_advertiser
             else:
-                own_address_type = self.advertising_own_address_type
-
-            # We are no longer advertising
-            self.advertising = False
+                # For extended advertisement, determining own address type later.
+                own_address_type = OwnAddressType.RANDOM
 
             if own_address_type in (
                 OwnAddressType.PUBLIC,
@@ -2916,6 +3267,7 @@ class Device(CompositeEventEmitter):
                 connection_parameters,
                 ConnectionPHY(HCI_LE_1M_PHY, HCI_LE_1M_PHY),
             )
+            connection.advertiser_after_disconnection = advertiser
             self.connections[connection_handle] = connection
 
             # If supported, read which PHY we're connected with before
@@ -2947,10 +3299,10 @@ class Device(CompositeEventEmitter):
         # For directed advertising, this means a timeout
         if (
             transport == BT_LE_TRANSPORT
-            and self.advertising
-            and self.advertising_type.is_directed
+            and self.legacy_advertiser
+            and self.legacy_advertiser.advertising_type.is_directed
         ):
-            self.advertising = False
+            self.legacy_advertiser = None
 
         # Notify listeners
         error = core.ConnectionError(
@@ -3000,30 +3352,49 @@ class Device(CompositeEventEmitter):
             )
 
     @host_event_handler
-    @with_connection_from_handle
-    def on_disconnection(self, connection, reason):
-        logger.debug(
-            f'*** Disconnection: [0x{connection.handle:04X}] '
-            f'{connection.peer_address} as {connection.role_name}, reason={reason}'
-        )
-        connection.emit('disconnection', reason)
-
-        # Remove the connection from the map
-        del self.connections[connection.handle]
-
-        # Cleanup subsystems that maintain per-connection state
-        self.gatt_server.on_disconnection(connection)
-
-        # Restart advertising if auto-restart is enabled
-        if self.auto_restart_advertising:
-            logger.debug('restarting advertising')
-            self.abort_on(
-                'flush',
-                self.start_advertising(
-                    advertising_type=self.advertising_type,
-                    own_address_type=self.advertising_own_address_type,
-                    auto_restart=True,
-                ),
+    def on_disconnection(self, connection_handle: int, reason: int) -> None:
+        if connection := self.connections.pop(connection_handle, None):
+            logger.debug(
+                f'*** Disconnection: [0x{connection.handle:04X}] '
+                f'{connection.peer_address} as {connection.role_name}, reason={reason}'
+            )
+            connection.emit('disconnection', reason)
+
+            # Cleanup subsystems that maintain per-connection state
+            self.gatt_server.on_disconnection(connection)
+
+            # Restart advertising if auto-restart is enabled
+            if advertiser := connection.advertiser_after_disconnection:
+                logger.debug('restarting advertising')
+                if isinstance(advertiser, LegacyAdvertiser):
+                    self.abort_on(
+                        'flush',
+                        self.start_legacy_advertising(
+                            advertising_type=advertiser.advertising_type,
+                            own_address_type=advertiser.own_address_type,
+                            advertising_data=advertiser.advertising_data,
+                            scan_response_data=advertiser.scan_response_data,
+                            auto_restart=True,
+                        ),
+                    )
+                elif isinstance(advertiser, ExtendedAdvertiser):
+                    self.abort_on(
+                        'flush',
+                        self.start_extended_advertising(
+                            advertising_properties=advertiser.advertising_properties,
+                            own_address_type=advertiser.own_address_type,
+                            advertising_data=advertiser.advertising_data,
+                            scan_response_data=advertiser.scan_response_data,
+                            auto_restart=True,
+                        ),
+                    )
+        elif sco_link := self.sco_links.pop(connection_handle, None):
+            sco_link.emit('disconnection', reason)
+        elif cis_link := self.cis_links.pop(connection_handle, None):
+            cis_link.emit('disconnection', reason)
+        else:
+            logger.error(
+                f'*** Unknown disconnection handle=0x{connection_handle}, reason={reason} ***'
             )
 
     @host_event_handler
@@ -3174,7 +3545,7 @@ class Device(CompositeEventEmitter):
             try:
                 if await connection.abort_on('disconnection', method()):
                     await self.host.send_command(
-                        HCI_User_Confirmation_Request_Reply_Command(  # type: ignore[call-arg]
+                        HCI_User_Confirmation_Request_Reply_Command(
                             bd_addr=connection.peer_address
                         )
                     )
@@ -3183,7 +3554,7 @@ class Device(CompositeEventEmitter):
                 logger.warning(f'exception while confirming: {error}')
 
             await self.host.send_command(
-                HCI_User_Confirmation_Request_Negative_Reply_Command(  # type: ignore[call-arg]
+                HCI_User_Confirmation_Request_Negative_Reply_Command(
                     bd_addr=connection.peer_address
                 )
             )
@@ -3204,7 +3575,7 @@ class Device(CompositeEventEmitter):
                 )
                 if number is not None:
                     await self.host.send_command(
-                        HCI_User_Passkey_Request_Reply_Command(  # type: ignore[call-arg]
+                        HCI_User_Passkey_Request_Reply_Command(
                             bd_addr=connection.peer_address, numeric_value=number
                         )
                     )
@@ -3213,7 +3584,7 @@ class Device(CompositeEventEmitter):
                 logger.warning(f'exception while asking for pass-key: {error}')
 
             await self.host.send_command(
-                HCI_User_Passkey_Request_Negative_Reply_Command(  # type: ignore[call-arg]
+                HCI_User_Passkey_Request_Negative_Reply_Command(
                     bd_addr=connection.peer_address
                 )
             )
@@ -3302,6 +3673,131 @@ class Device(CompositeEventEmitter):
             connection.emit('remote_name_failure', error)
         self.emit('remote_name_failure', address, error)
 
+    # [Classic only]
+    @host_event_handler
+    @with_connection_from_address
+    @experimental('Only for testing.')
+    def on_sco_connection(
+        self, acl_connection: Connection, sco_handle: int, link_type: int
+    ) -> None:
+        logger.debug(
+            f'*** SCO connected: {acl_connection.peer_address}, '
+            f'sco_handle=[0x{sco_handle:04X}], '
+            f'link_type=[0x{link_type:02X}] ***'
+        )
+        sco_link = self.sco_links[sco_handle] = ScoLink(
+            device=self,
+            acl_connection=acl_connection,
+            handle=sco_handle,
+            link_type=link_type,
+        )
+        self.emit('sco_connection', sco_link)
+
+    # [Classic only]
+    @host_event_handler
+    @with_connection_from_address
+    @experimental('Only for testing.')
+    def on_sco_connection_failure(
+        self, acl_connection: Connection, status: int
+    ) -> None:
+        logger.debug(f'*** SCO connection failure: {acl_connection.peer_address}***')
+        self.emit('sco_connection_failure')
+
+    # [Classic only]
+    @host_event_handler
+    @experimental('Only for testing')
+    def on_sco_packet(self, sco_handle: int, packet: HCI_SynchronousDataPacket) -> None:
+        if sco_link := self.sco_links.get(sco_handle, None):
+            sco_link.emit('pdu', packet)
+
+    # [LE only]
+    @host_event_handler
+    @experimental('Only for testing')
+    def on_advertising_set_termination(
+        self,
+        status: int,
+        advertising_handle: int,
+        connection_handle: int,
+    ) -> None:
+        if status == HCI_SUCCESS:
+            connection = self.lookup_connection(connection_handle)
+        if advertiser := self.extended_advertisers.pop(advertising_handle, None):
+            if connection:
+                if advertiser.auto_restart:
+                    connection.advertiser_after_disconnection = advertiser
+                if advertiser.own_address_type in (
+                    OwnAddressType.PUBLIC,
+                    OwnAddressType.RESOLVABLE_OR_PUBLIC,
+                ):
+                    connection.self_address = self.public_address
+                else:
+                    connection.self_address = self.random_address
+            advertiser.emit('termination', status)
+
+    # [LE only]
+    @host_event_handler
+    @with_connection_from_handle
+    @experimental('Only for testing')
+    def on_cis_request(
+        self,
+        acl_connection: Connection,
+        cis_handle: int,
+        cig_id: int,
+        cis_id: int,
+    ) -> None:
+        logger.debug(
+            f'*** CIS Request '
+            f'acl_handle=[0x{acl_connection.handle:04X}]{acl_connection.peer_address}, '
+            f'cis_handle=[0x{cis_handle:04X}], '
+            f'cig_id=[0x{cig_id:02X}], '
+            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(
+            device=self,
+            acl_connection=acl_connection,
+            handle=cis_handle,
+            cig_id=cig_id,
+            cis_id=cis_id,
+        )
+        self.emit('cis_request', acl_connection, cis_handle, cig_id, cis_id)
+
+    # [LE only]
+    @host_event_handler
+    @experimental('Only for testing')
+    def on_cis_establishment(self, cis_handle: int) -> None:
+        cis_link = self.cis_links[cis_handle]
+        cis_link.state = CisLink.State.ESTABLISHED
+
+        assert cis_link.acl_connection
+
+        logger.debug(
+            f'*** CIS Establishment '
+            f'{cis_link.acl_connection.peer_address}, '
+            f'cis_handle=[0x{cis_handle:04X}], '
+            f'cig_id=[0x{cis_link.cig_id:02X}], '
+            f'cis_id=[0x{cis_link.cis_id:02X}] ***'
+        )
+
+        cis_link.emit('establishment')
+        self.emit('cis_establishment', cis_link)
+
+    # [LE only]
+    @host_event_handler
+    @experimental('Only for testing')
+    def on_cis_establishment_failure(self, cis_handle: int, status: int) -> None:
+        logger.debug(f'*** CIS Establishment Failure: cis=[0x{cis_handle:04X}] ***')
+        if cis_link := self.cis_links.pop(cis_handle, None):
+            cis_link.emit('establishment_failure')
+        self.emit('cis_establishment_failure', cis_handle, status)
+
+    # [LE only]
+    @host_event_handler
+    @experimental('Only for testing')
+    def on_iso_packet(self, handle: int, packet: HCI_IsoDataPacket) -> None:
+        if cis_link := self.cis_links.get(handle, None):
+            cis_link.emit('pdu', packet)
+
     @host_event_handler
     @with_connection_from_handle
     def on_connection_encryption_change(self, connection, encryption):