HAP-python 5.0.0__tar.gz → 5.1.0__tar.gz

{hap_python-5.0.0 → hap_python-5.1.0}/HAP_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: HAP-python
-Version: 5.0.0
+Version: 5.1.0
 Summary: HomeKit Accessory Protocol implementation in python
 Author: Ivan Kalchev
 License-Expression: Apache-2.0
@@ -12,14 +12,13 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Home Automation
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS
@@ -32,6 +31,8 @@ Requires-Dist: h11
 Provides-Extra: qrcode
 Requires-Dist: base36; extra == "qrcode"
 Requires-Dist: pyqrcode; extra == "qrcode"
+Provides-Extra: talkback
+Requires-Dist: pylibsrtp; extra == "talkback"
 Dynamic: license-file
 
 [![PyPI version](https://badge.fury.io/py/HAP-python.svg)](https://badge.fury.io/py/HAP-python) [![Build Status](https://github.com/ikalchev/HAP-python/workflows/CI/badge.svg)](https://github.com/ikalchev/HAP-python) [![codecov](https://codecov.io/gh/ikalchev/HAP-python/branch/master/graph/badge.svg)](https://codecov.io/gh/ikalchev/HAP-python) [![Python Versions](https://img.shields.io/pypi/pyversions/HAP-python.svg)](https://pypi.python.org/pypi/HAP-python/) [![Documentation Status](https://readthedocs.org/projects/hap-python/badge/?version=latest)](http://hap-python.readthedocs.io/en/latest/?badge=latest) [![Downloads](https://pepy.tech/badge/hap-python)](https://pepy.tech/project/hap-python)

{hap_python-5.0.0 → hap_python-5.1.0}/HAP_python.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ pyhap/__init__.py
 pyhap/accessory.py
 pyhap/accessory_driver.py
 pyhap/camera.py
+pyhap/camera_talkback.py
 pyhap/characteristic.py
 pyhap/const.py
 pyhap/encoder.py
@@ -21,6 +22,11 @@ pyhap/hap_event.py
 pyhap/hap_handler.py
 pyhap/hap_protocol.py
 pyhap/hap_server.py
+pyhap/hds.py
+pyhap/hds_protocol.py
+pyhap/hds_recording.py
+pyhap/hds_server.py
+pyhap/hksv_recording.py
 pyhap/hsrp.py
 pyhap/iid_manager.py
 pyhap/loader.py
@@ -41,6 +47,8 @@ tests/test_hap_crypto.py
 tests/test_hap_handler.py
 tests/test_hap_protocol.py
 tests/test_hap_server.py
+tests/test_hds_recording.py
+tests/test_hksv_recording.py
 tests/test_hsrp.py
 tests/test_iid_manager.py
 tests/test_loader.py

{hap_python-5.0.0 → hap_python-5.1.0}/HAP_python.egg-info/requires.txt

@@ -10,3 +10,6 @@ async_timeout
 [QRCode]
 base36
 pyqrcode
+
+[Talkback]
+pylibsrtp

{hap_python-5.0.0 → hap_python-5.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: HAP-python
-Version: 5.0.0
+Version: 5.1.0
 Summary: HomeKit Accessory Protocol implementation in python
 Author: Ivan Kalchev
 License-Expression: Apache-2.0
@@ -12,14 +12,13 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Home Automation
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS
@@ -32,6 +31,8 @@ Requires-Dist: h11
 Provides-Extra: qrcode
 Requires-Dist: base36; extra == "qrcode"
 Requires-Dist: pyqrcode; extra == "qrcode"
+Provides-Extra: talkback
+Requires-Dist: pylibsrtp; extra == "talkback"
 Dynamic: license-file
 
 [![PyPI version](https://badge.fury.io/py/HAP-python.svg)](https://badge.fury.io/py/HAP-python) [![Build Status](https://github.com/ikalchev/HAP-python/workflows/CI/badge.svg)](https://github.com/ikalchev/HAP-python) [![codecov](https://codecov.io/gh/ikalchev/HAP-python/branch/master/graph/badge.svg)](https://codecov.io/gh/ikalchev/HAP-python) [![Python Versions](https://img.shields.io/pypi/pyversions/HAP-python.svg)](https://pypi.python.org/pypi/HAP-python/) [![Documentation Status](https://readthedocs.org/projects/hap-python/badge/?version=latest)](http://hap-python.readthedocs.io/en/latest/?badge=latest) [![Downloads](https://pepy.tech/badge/hap-python)](https://pepy.tech/project/hap-python)

{hap_python-5.0.0 → hap_python-5.1.0}/pyhap/accessory_driver.py

@@ -292,6 +292,9 @@ class AccessoryDriver:
         self.persist_file = os.path.expanduser(persist_file)
         self.encoder = encoder or AccessoryEncoder()
         self.topics = {}  # topic: set of (address, port) of subscribed clients
+        # Per-session HAP shared keys, keyed by client (address, port). Needed
+        # by transports derived from the session, e.g. HomeKit Data Stream.
+        self.session_shared_keys: Dict[Tuple[str, int], bytes] = {}
         self.loader = loader or Loader()
         self.aio_stop_event = None
         self.stop_event = threading.Event()
@@ -322,6 +325,9 @@ class AccessoryDriver:
             if (
                 threading.current_thread() is threading.main_thread()
                 and os.name != "nt"
+                # The child watcher API was removed in Python 3.14; there the
+                # default event loop reaps subprocesses without one.
+                and hasattr(asyncio, "SafeChildWatcher")
             ):
                 logger.debug("Setting child watcher")
                 watcher = asyncio.SafeChildWatcher()  # pylint: disable=deprecated-class
@@ -537,6 +543,7 @@ class AccessoryDriver:
         for topic in client_topics:
             self.async_subscribe_client_topic(client, topic, subscribe=False)
         self.prepared_writes.pop(client, None)
+        self.session_shared_keys.pop(client, None)
 
     def publish(self, data, sender_client_addr=None, immediate=False):
         """Publishes an event to the client.
@@ -829,7 +836,7 @@ class AccessoryDriver:
             try:
                 if aid == STANDALONE_AID:
                     char = self.accessory.iid_manager.get_obj(iid)
-                    available = True
+                    available = self.accessory.available
                 else:
                     acc = self.accessory.accessories.get(aid)
                     if acc is None:

{hap_python-5.0.0 → hap_python-5.1.0}/pyhap/camera.py

@@ -25,10 +25,11 @@ import struct
 import sys
 from uuid import UUID
 
-from pyhap import RESOURCE_DIR, tlv
+from pyhap import RESOURCE_DIR, hds, hds_recording, hds_server, hksv_recording, tlv
 from pyhap.accessory import Accessory
+from pyhap.camera_talkback import TalkbackReceiver, talkback_available
 from pyhap.const import CATEGORY_CAMERA
-from pyhap.util import byte_bool, to_base64_str
+from pyhap.util import base64_to_bytes, byte_bool, to_base64_str
 
 if sys.version_info >= (3, 11):
     from asyncio import timeout as async_timeout
@@ -427,6 +428,13 @@ class Camera(Accessory):
 
             Additional optional values are:
             - srtp - boolean, defaults to False. Whether the camera supports SRTP.
+            - talkback - boolean, defaults to False. Whether the camera supports
+                receiving two-way ("talkback") audio from the controller during a
+                live view session. Requires the optional ``pylibsrtp`` dependency
+                (``pip install HAP-python[Talkback]``). When enabled, a "Speaker"
+                service is added so that HAP clients know the accessory supports
+                it, and :meth:`talkback_audio_received` is called with the
+                received audio for each session that negotiates it.
             - start_stream_cmd - string specifying the command to be executed to start
                 the stream. The string can contain the keywords, corresponding to the
                 video and audio configuration that was negotiated between the camera
@@ -435,6 +443,12 @@ class Camera(Accessory):
         :type options: ``dict``
         """
         self.has_srtp = options.get("srtp", False)
+        self.support_talkback = options.get("talkback", False)
+        if self.support_talkback and not talkback_available():
+            raise ValueError(
+                "The 'talkback' option requires the optional 'pylibsrtp' "
+                "dependency. Install it with: pip install HAP-python[Talkback]"
+            )
         self.start_stream_cmd = options.get("start_stream_cmd", FFMPEG_CMD)
 
         self.stream_address = options["address"]
@@ -448,14 +462,29 @@ class Camera(Accessory):
         super().__init__(*args, **kwargs)
 
         self.add_preload_service("Microphone")
+        if self.support_talkback:
+            self.add_preload_service("Speaker").configure_char("Mute", value=False)
         self._streaming_status = []
         self._management = []
-        self._setup_stream_management(options)
+        # All HKSV state defaults are initialized before any setup runs so the
+        # setup methods below never follow (and reset) them.
+        self._status_active_char = None
+        self._recording_service = None
+        self._selected_recording_config = None
+        self._motion_detected_char = None
+        self._hds_listener = None
+        self._hds_connections = set()
+        if options.get("video"):
+            self._setup_stream_management(options)
+        # Classic HomeKit Secure Video recording (HDS + fragmented MP4).
+        if options.get("recording"):
+            self._setup_recording_management(options)
 
     @property
     def streaming_status(self):
         """For backwards compatibility."""
-        return self._streaming_status[0]
+        # A recording-only camera has no RTP stream management service.
+        return self._streaming_status[0] if self._streaming_status else None
 
     def _setup_stream_management(self, options):
         """Create stream management."""
@@ -467,8 +496,12 @@ class Camera(Accessory):
     def _create_stream_management(self, stream_idx, options):
         """Create a stream management service."""
         management = self.add_preload_service(
-            "CameraRTPStreamManagement", unique_id=stream_idx
+            "CameraRTPStreamManagement", unique_id=stream_idx, chars=["Active"]
         )
+        # HAP-NodeJS exposes an Active (0x0B0) characteristic on every stream
+        # management service (value 1 = active); iOS' camera validation expects
+        # it, and it is required for Secure Video eligibility.
+        management.configure_char("Active", value=1)
         management.configure_char(
             "StreamingStatus",
             getter_callback=lambda: self._get_streaming_status(stream_idx),
@@ -497,6 +530,203 @@ class Camera(Accessory):
         )
         return management
 
+    def _default_recording_configs(self, options):
+        """Derive supported recording configurations from the streaming options.
+
+        A widely-compatible default: H.264 (Baseline/Main/High, levels 3.1/3.2/
+        4.0) at the streaming resolutions, AAC-LC audio. Accessories can override
+        this to advertise their own recording capabilities.
+        """
+        video_opts = options.get("video") or {}
+        resolutions = video_opts.get("resolutions") or [[1920, 1080, 30]]
+        video = [
+            hksv_recording.VideoCodecConfiguration(
+                codec_type=hksv_recording.VideoCodecType.H264,
+                profile=[
+                    VIDEO_CODEC_PARAM_PROFILE_ID_TYPES["BASELINE"][0],
+                    VIDEO_CODEC_PARAM_PROFILE_ID_TYPES["MAIN"][0],
+                    VIDEO_CODEC_PARAM_PROFILE_ID_TYPES["HIGH"][0],
+                ],
+                level=[
+                    VIDEO_CODEC_PARAM_LEVEL_TYPES["TYPE3_1"][0],
+                    VIDEO_CODEC_PARAM_LEVEL_TYPES["TYPE3_2"][0],
+                    VIDEO_CODEC_PARAM_LEVEL_TYPES["TYPE4_0"][0],
+                ],
+                bitrate_kbps=2000,
+                iframe_interval_ms=4000,
+                attributes=[
+                    hksv_recording.VideoAttributes(width, height, fps)
+                    for width, height, fps in resolutions
+                ],
+            )
+        ]
+        audio = [hksv_recording.AudioCodecConfiguration()]
+        general = hksv_recording.SupportedRecordingConfiguration()
+        return general, video, audio
+
+    def _setup_recording_management(self, options):
+        """Create the Camera Recording Management service (classic HKSV).
+
+        Advertises the supported general/video/audio recording configurations
+        and accepts the controller's selection. Recording stays inactive
+        (Active=0) unless the ``recording`` option enables it; the fragment
+        data flow over HDS is wired by the recording transport.
+        """
+        # HKSV requires the Camera Operating Mode service (0000021A); the
+        # controller validates its presence before enabling recording.
+        operating_mode = self.add_preload_service(
+            "CameraOperatingMode", chars=["PeriodicSnapshotsActive"]
+        )
+        operating_mode.configure_char("EventSnapshotsActive", value=1)
+        operating_mode.configure_char("HomeKitCameraActive", value=1)
+        operating_mode.configure_char("PeriodicSnapshotsActive", value=1)
+
+        # HKSV records on an event trigger; the camera owns a motion sensor and
+        # links it (and the data stream transport) to the recording management.
+        motion = self.add_preload_service("MotionSensor", chars=["StatusActive"])
+        self._motion_detected_char = motion.configure_char(
+            "MotionDetected", value=False
+        )
+        # HAP-NodeJS marks the HKSV event-trigger sensor as active; iOS expects it.
+        motion.configure_char("StatusActive", value=True)
+
+        general, video, audio = self._default_recording_configs(options)
+        service = self.add_preload_service(
+            "CameraRecordingManagement", chars=["RecordingAudioActive"]
+        )
+        service.add_linked_service(motion)
+        service.configure_char("Active", value=0)
+        service.configure_char(
+            "RecordingAudioActive", value=1 if options.get("recording_audio") else 0
+        )
+        service.configure_char(
+            "SupportedCameraRecordingConfiguration",
+            value=to_base64_str(general.encode()),
+        )
+        service.configure_char(
+            "SupportedVideoRecordingConfiguration",
+            value=to_base64_str(hksv_recording.encode_supported_video(video)),
+        )
+        service.configure_char(
+            "SupportedAudioRecordingConfiguration",
+            value=to_base64_str(hksv_recording.encode_supported_audio(audio)),
+        )
+        service.configure_char(
+            "SelectedCameraRecordingConfiguration",
+            setter_callback=self.set_selected_recording_configuration,
+        )
+        self._recording_service = service
+        self._setup_data_stream_transport()
+
+    def _setup_data_stream_transport(self):
+        """Create the Data Stream Transport Management service used by HDS.
+
+        SetupDataStreamTransport needs the HAP session shared secret, so its
+        setter receives the sender's client address to look the secret up.
+        """
+        transport = self.add_preload_service("DataStreamTransportManagement")
+        transport.configure_char("Version", value="1.0")
+        transport.configure_char(
+            "SupportedDataStreamTransportConfiguration",
+            value=to_base64_str(self._supported_data_stream_transport()),
+        )
+        transport.configure_char(
+            "SetupDataStreamTransport",
+            setter_callback=self.set_data_stream_transport,
+        )
+        # HKSV requires the recording management service to link the data stream
+        # transport it records over; without the link the controller rejects
+        # recording during validation, before writing any configuration.
+        self._recording_service.add_linked_service(transport)
+
+    @staticmethod
+    def _supported_data_stream_transport():
+        # A single supported transport configuration: TCP.
+        transport_configuration = tlv.encode(b"\x01", hds.TRANSPORT_TYPE_TCP)
+        return tlv.encode(b"\x01", transport_configuration)
+
+    async def _ensure_hds_listener(self):
+        if self._hds_listener is None:
+            self._hds_listener = hds_server.HDSListener()
+            self._hds_listener.on_connection = self._on_hds_connection
+            await self._hds_listener.start()
+
+    def _on_hds_connection(self, connection):
+        self._hds_connections.add(connection)
+        connection.add_close_callback(self._hds_connections.discard)
+        hds_recording.RecordingStreamManager(connection, self._recording_delegate)
+
+    def set_data_stream_transport(self, value, sender_client_addr=None):
+        """Handle a write to SetupDataStreamTransport (HDS session setup).
+
+        SetupDataStreamTransport is a write-response ('wr') characteristic: the
+        controller writes with ``r: true`` and reads the encoded setup response
+        (TCP listening port + accessory key salt) straight back from the write
+        response. That means the value MUST be RETURNED from the setter so the
+        HAP layer includes it in the write response — setting it on the
+        characteristic is not delivered to the controller and leaves it without
+        the port, so it can never open the HDS connection.
+        """
+        request = hds.SetupRequest.decode(base64_to_bytes(value))
+        shared_secret = self.driver.session_shared_keys.get(sender_client_addr)
+        if shared_secret is None or self._hds_listener is None:
+            response = hds.encode_setup_response(
+                0, b"", status=hds.SETUP_STATUS_GENERIC_ERROR
+            )
+        else:
+            accessory_salt = self._hds_listener.register_transport(
+                shared_secret, request.controller_key_salt
+            )
+            response = hds.encode_setup_response(
+                self._hds_listener.port, accessory_salt
+            )
+        return to_base64_str(response)
+
+    async def _recording_delegate(self, stream_id):
+        """Yield recording fragments for ``stream_id``.
+
+        Override ``handle_recording_stream`` to produce the fragmented MP4
+        packets; this adapter exists so the transport can await an async
+        generator.
+        """
+        async for packet in self.handle_recording_stream(stream_id):
+            yield packet
+
+    async def handle_recording_stream(self, stream_id):
+        """Produce the fragmented-MP4 recording for ``stream_id``.
+
+        Override to yield :class:`pyhap.hds_recording.RecordingPacket` objects,
+        the first being the MP4 initialization segment. The default yields
+        nothing (no recording).
+        """
+        return
+        yield  # pragma: no cover - makes this an async generator
+
+    @property
+    def selected_recording_configuration(self):
+        """The controller's selected recording configuration, if any."""
+        return self._selected_recording_config
+
+    def set_selected_recording_configuration(self, value):
+        """Handle a write to Selected Camera Recording Configuration (spec HKSV)."""
+        self._selected_recording_config = (
+            hksv_recording.SelectedRecordingConfiguration.decode(base64_to_bytes(value))
+        )
+        self.recording_configuration_selected(self._selected_recording_config)
+
+    def recording_configuration_selected(self, configuration):
+        """React to the controller selecting a recording configuration. Override."""
+
+    def set_motion_detected(self, detected):
+        """Fire (``True``) or clear (``False``) the recording motion trigger.
+
+        This is the entry point an integration calls when its own motion
+        detector changes state: it drives the HKSV event-trigger MotionSensor,
+        which is what makes the Home Hub start (and later finish) a recording.
+        """
+        if self._motion_detected_char is not None:
+            self._motion_detected_char.set_value(bool(detected))
+
     async def _start_stream(self, objs, reconfigure):  # pylint: disable=unused-argument
         """Start or reconfigure video streaming for the given session.
 
@@ -625,6 +855,7 @@ class Camera(Accessory):
             logger.error(
                 "[%s] Failed to start/reconfigure stream, deleting session.", session_id
             )
+            self._close_talkback(session_info)
             del self.sessions[session_id]
             self._streaming_status[stream_idx] = STREAMING_STATUS["AVAILABLE"]
 
@@ -657,10 +888,53 @@ class Camera(Accessory):
 
         stream_idx = session_info["stream_idx"]
         await self.stop_stream(session_info)
+        self._close_talkback(session_info)
         del self.sessions[session_id]
 
         self._streaming_status[stream_idx] = STREAMING_STATUS["AVAILABLE"]
 
+    @staticmethod
+    def _close_talkback(session_info):
+        """Stop the talkback audio receiver for a session, if any."""
+        audio_backchannel = session_info.pop("audio_backchannel", None)
+        if audio_backchannel is not None:
+            audio_backchannel.stop()
+
+    def _talkback_payload_received(self, session_id, payload: bytes) -> None:
+        """Dispatch a received talkback RTP payload to the accessory implementation.
+
+        Called from the :class:`~pyhap.camera_talkback.TalkbackReceiver`
+        background thread, so this hops back onto the accessory driver's event
+        loop before calling the (synchronous) public callback, to keep
+        :meth:`talkback_audio_received` easy to implement without every caller
+        having to worry about thread-safety.
+        """
+        loop = getattr(self.driver, "loop", None)
+        if loop is None:
+            logger.warning(
+                "Dropping talkback audio packet: driver event loop is not available."
+            )
+            return
+        loop.call_soon_threadsafe(self.talkback_audio_received, session_id, payload)
+
+    def talkback_audio_received(
+        self, session_id, payload: bytes
+    ) -> None:  # pylint: disable=unused-argument
+        """Handle received two-way ("talkback") audio for a streaming session.
+
+        Only called for sessions of accessories constructed with the
+        ``talkback`` option enabled (see ``__init__``). Override to consume the
+        received audio, e.g. decode it (the codec is whichever was negotiated,
+        see ``a_codec`` in the stream configuration passed to
+        :meth:`start_stream`) and play it out through a speaker.
+
+        :param session_id: The session ID this audio belongs to.
+        :type session_id: :class:`~uuid.UUID`
+        :param payload: The RTP payload of one received packet, still encoded
+            with the negotiated audio codec (not decoded by pyhap).
+        :type payload: ``bytes``
+        """
+
     def set_selected_stream_configuration(self, value):
         """Set the selected stream configuration.
 
@@ -787,6 +1061,32 @@ class Camera(Accessory):
         video_ssrc = int.from_bytes(os.urandom(3), byteorder="big")
         audio_ssrc = int.from_bytes(os.urandom(3), byteorder="big")
 
+        # If talkback is enabled, open a local receiver for the audio the
+        # controller will send back during the session, and report *its* real
+        # port below instead of echoing the controller's own port back at it.
+        # Per the HAP spec (section 11, "IP Cameras"), the "Accessory Address"
+        # TLV in this response carries the accessory's own address/ports (the
+        # "Controller Address" received above carries the controller's), so
+        # echoing the controller's port here left HAP clients with nowhere
+        # valid to send the talkback audio to.
+        #
+        # Stop any previous receiver for this session first, so a
+        # re-sent SetupEndpoints for the same session ID doesn't leak its
+        # receiver thread and UDP socket.
+        self._close_talkback(self.sessions.get(session_id, {}))
+        audio_backchannel = None
+        audio_rtp_port = target_audio_port
+        if self.support_talkback:
+            audio_backchannel = TalkbackReceiver(
+                srtp_key_and_salt=audio_master_key + audio_master_salt,
+                on_payload=functools.partial(
+                    self._talkback_payload_received, session_id
+                ),
+                is_ipv6=bool(is_ipv6),
+            )
+            audio_backchannel.start()
+            audio_rtp_port = audio_backchannel.local_port
+
         res_address_tlv = tlv.encode(
             SETUP_ADDR_INFO["ADDRESS_VER"],
             self.stream_address_isv6,
@@ -795,7 +1095,7 @@ class Camera(Accessory):
             SETUP_ADDR_INFO["VIDEO_RTP_PORT"],
             struct.pack("<H", target_video_port),
             SETUP_ADDR_INFO["AUDIO_RTP_PORT"],
-            struct.pack("<H", target_audio_port),
+            struct.pack("<H", audio_rtp_port),
         )
 
         response_tlv = tlv.encode(
@@ -826,17 +1126,27 @@ class Camera(Accessory):
             "a_port": target_audio_port,
             "a_srtp_key": to_base64_str(audio_master_key + audio_master_salt),
             "a_ssrc": audio_ssrc,
+            "audio_backchannel": audio_backchannel,
         }
 
         self._management[stream_idx].get_characteristic("SetupEndpoints").set_value(
             response_tlv
         )
 
+    async def run(self):
+        """Start the HDS listener when recording transport is available."""
+        await super().run()
+        if self._recording_service is not None:
+            await self._ensure_hds_listener()
+
     async def stop(self):
-        """Stop all streaming sessions."""
+        """Stop all streaming sessions and the HDS listener."""
         await asyncio.gather(
             *(self.stop_stream(session_info) for session_info in self.sessions.values())
         )
+        if self._hds_listener is not None:
+            await self._hds_listener.stop()
+            self._hds_listener = None
 
     # ### For client extensions ###