python-aidot-cameras 0.12.8__tar.gz → 0.12.10__tar.gz

{python_aidot_cameras-0.12.8/python_aidot_cameras.egg-info → python_aidot_cameras-0.12.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.12.8
+Version: 0.12.10
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT

{python_aidot_cameras-0.12.8 → python_aidot_cameras-0.12.10}/aidot_cameras/camera/client.py

@@ -2762,7 +2762,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_register_with_go2rtc', exc_info=True)
         if not (self._streaming_active and self._go2rtc_url and self._keepalive_rtsp_url):
             return
-        name = f"aidot_{self.device_id[:12]}"
+        name = self._go2rtc_stream_name()
         try:
             async with aiohttp.ClientSession() as _s2:
                 url = await prefer_go2rtc(
@@ -2788,7 +2788,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             return
         import aiohttp
         from .go2rtc import Go2rtcClient
-        name = f"aidot_{self.device_id[:12]}"
+        name = self._go2rtc_stream_name()
         try:
             async with aiohttp.ClientSession() as _s2:
                 await Go2rtcClient(_s2, base).remove_stream(name)
@@ -2903,6 +2903,56 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 found = True
         return found if read_any else None
 
+    def _go2rtc_stream_name(self) -> str:
+        """The go2rtc stream name for this camera - one definition, so the
+        register, deregister and viewer-count paths cannot drift apart."""
+        return f"aidot_{self.device_id[:12]}"
+
+    async def _viewer_present(self, port: int) -> "Optional[bool]":
+        """Is anyone ACTUALLY watching?  True / False / None (unknown).
+
+        Ask go2rtc first when the stream is registered with it, because the serve
+        socket cannot answer this question: go2rtc attaches to the serve as its
+        producer and stays attached for as long as the stream exists, viewer or
+        no viewer.  A TCP peer is therefore always present, idle-release never
+        fires, and every camera keeps streaming indefinitely after a single view -
+        which is what "why are all my cameras streaming?" looks like from outside.
+        Confirmed live: five cameras, no viewers, still producing after 7 minutes
+        against a 5 minute idle window.
+
+        Falls back to the TCP-table check when go2rtc is not in use, and returns
+        None (never release) if neither can answer.
+        """
+        name = self._go2rtc_stream_name()
+        base = self._go2rtc_url
+        if not base:
+            # No go2rtc to ask.  In PUSH mode the fallback below is not merely
+            # unavailable, it is WRONG: the "serve port" is go2rtc's shared RTSP
+            # port (8554), where every camera's own publisher is connected, so the
+            # check reports a viewer for every camera forever and nothing ever
+            # releases.  Answer "unknown" instead of a confident lie - the caller
+            # then holds the stream rather than tearing down a live view, and the
+            # honest way out is for the consumer to pass go2rtc_url.
+            if self._keepalive_rtsp_url and not str(
+                    self._keepalive_rtsp_url).startswith("http"):
+                _LOGGER.debug(
+                    "no go2rtc url and the serve is an RTSP push to a shared "
+                    "port; cannot tell whether anyone is watching",
+                )
+                return None
+        if base and name:
+            try:
+                import aiohttp
+
+                from .go2rtc import Go2rtcClient
+                async with aiohttp.ClientSession() as _s:
+                    viewers = await Go2rtcClient(_s, base).viewer_count(name)
+                if viewers is not None:
+                    return viewers > 0
+            except Exception as exc:
+                _LOGGER.debug("go2rtc viewer check failed: %s", exc)
+        return self._sdes_serve_consumer_present(port)
+
     async def _sdes_keepalive_loop(self) -> None:
         """Keep the cold-start serve relay alive around the SDES keepalive loop.
 
@@ -3019,7 +3069,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                         _stalled = True
                         break
                     if _idle_on and _serve_port is not None:
-                        _present = self._sdes_serve_consumer_present(_serve_port)
+                        _present = await self._viewer_present(_serve_port)
                         if _present:  # True -> a viewer is pulling; stay alive
                             _last_consumer = time.monotonic()
                         elif _idle_release_due(_present, _last_consumer,
@@ -3657,8 +3707,14 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 self.device_id,
             )
         await slots.acquire()
-        self._serve_relay = self._maybe_start_serve_relay(self._keepalive_rtsp_url)
         try:
+            # Inside the try on purpose: _maybe_start_serve_relay catches OSError
+            # but Thread.start() raises RuntimeError when the host is out of
+            # threads, and escaping here would skip slots.release() and burn a
+            # permit for the life of the process - the cap would silently shrink
+            # until nothing could stream at all.
+            self._serve_relay = self._maybe_start_serve_relay(
+                self._keepalive_rtsp_url)
             await self._dtls_serve_loop_inner()
         finally:
             _relay = self._serve_relay
@@ -3916,6 +3972,8 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     _stall_pli_s = float(os.environ.get("AIDOT_STALL_PLI_S", "1.0"))
                     _last_gop_pli = loop.time()
                     _stall_pli_armed = True
+                    _last_viewer_dtls = loop.time()
+                    _serve_port_dtls = _sdes_serve_port(serve_url) or 0
                     # Wait for ffmpeg to exit (go2rtc disconnect) or idle release.
                     while self._streaming_active and proc.returncode is None:
                         await asyncio.sleep(0.5)
@@ -3933,11 +3991,26 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                             await self._send_video_pli(pc)
                             _last_gop_pli = _now           # also satisfies cadence
                             _stall_pli_armed = False       # one shot per stall
-                        # No consumer -> the pipe fills, the mux blocks, progress
-                        # goes stale.  A real viewer keeps it fresh.  idle_secs<=0
-                        # disables release entirely (keep warm for instant views).
-                        if idle_secs > 0 and _now - progress[0] > idle_secs:
-                            idle_release = True
+                        # Whether anyone is WATCHING.  Pipe-progress staleness
+                        # cannot answer that: the pipe only backs up when nothing
+                        # drains the serve socket, and go2rtc drains it forever as
+                        # the stream's producer, viewer or not.  So progress never
+                        # goes stale, the release never fires, and every DTLS
+                        # camera streams for the life of the process - the same
+                        # defect fixed for the SDES loop, in the other loop.
+                        # Ask go2rtc, and only fall back to staleness when it
+                        # cannot answer.
+                        if idle_secs > 0:
+                            _watching = await self._viewer_present(_serve_port_dtls)
+                            if _watching:
+                                _last_viewer_dtls = _now
+                            elif _watching is False:
+                                if _now - _last_viewer_dtls > idle_secs:
+                                    idle_release = True
+                            elif _now - progress[0] > idle_secs:
+                                # Unknown: keep the old staleness heuristic rather
+                                # than holding the stream open forever.
+                                idle_release = True
                             break
                     # Tear down this ffmpeg+mux cycle before the next.
                     stop_flag.set()
@@ -3964,7 +4037,12 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                         wfile.close()
                     except Exception:
                         _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_pc_dead', exc_info=True)
-                if mux_thread is not None:
+                if mux_thread is not None and mux_thread.is_alive():
+                    # is_alive() guards the never-started case: if Thread.start()
+                    # itself raised, join() raises "cannot join thread before it
+                    # is started", which would replace the real exception AND skip
+                    # the ffmpeg terminate plus session stop below - orphaning the
+                    # process on its serve port and leaking the camera's session.
                     mux_thread.join(timeout=2.0)
                 _terminate_proc(proc)  # never orphan ffmpeg on teardown
                 self._stream_session = None

{python_aidot_cameras-0.12.8 → python_aidot_cameras-0.12.10}/aidot_cameras/camera/go2rtc.py

@@ -72,6 +72,29 @@ class Go2rtcClient:
     async def has_stream(self, name: str) -> bool:
         return name in (await self.list_streams())
 
+    async def viewer_count(self, name: str) -> "Optional[int]":
+        """How many CONSUMERS go2rtc has for ``name``; None if it cannot be read.
+
+        This is the only trustworthy answer to "is anyone actually watching?".
+        The serve socket cannot answer it: go2rtc attaches to the serve as its
+        producer and stays attached, so a TCP peer is always present whether or
+        not a viewer exists.  Idle-release keyed on the socket therefore never
+        fires and every camera streams forever after a single view.
+
+        None means unknown (go2rtc unreachable or the stream absent), and callers
+        must fail safe by not releasing on it.
+        """
+        streams = await self.list_streams()
+        entry = streams.get(name)
+        if not isinstance(entry, dict):
+            return None
+        consumers = entry.get("consumers")
+        if consumers is None:
+            return 0          # go2rtc reports null rather than [] when there are none
+        if isinstance(consumers, list):
+            return len(consumers)
+        return None
+
     async def ensure_stream(self, name: str, source: str) -> bool:
         """Register (or replace) ``name`` -> ``source``. Returns True on 200."""
         try:

{python_aidot_cameras-0.12.8 → python_aidot_cameras-0.12.10}/aidot_cameras/camera/sdes_open.py

@@ -45,7 +45,7 @@ _SDP_ALTERNATE_PT = {96: 97, 97: 96, 0: 8, 8: 0}
 # session started media at ~21s, which the previous 15s deadline missed entirely -
 # it launched blind with BOTH payload types still unknown, which is what left the
 # audio line advertising PCMU on a PCMA camera.
-_FIRST_MEDIA_WAIT_S = 45.0
+_FIRST_MEDIA_WAIT_S = 75.0
 
 # Extra time for the audio payload type once video is known.  Measured on an
 # A001513: audio follows video by 40-70ms, because the camera answers BUNDLE and
@@ -3843,20 +3843,44 @@ class _SdesOpenMixin:
                         except Exception:
                             proc.kill()
                         _ts2 = int(time.time())
+                        # Match the PRIMARY SDP on both counts, or this restart
+                        # undoes two fixes at once.
+                        #
+                        # Transport: for _use_plain_rtp models - which is every
+                        # SDES camera this library supports - the bridge decrypts
+                        # and forwards PLAIN RTP, so the primary SDP is RTP/AVP
+                        # with no a=crypto.  Writing RTP/SAVP here makes ffmpeg
+                        # try to authenticate already-decrypted packets: every one
+                        # fails its HMAC check and a working stream drops to zero
+                        # bytes mid-session.
+                        #
+                        # Payload types: hard-coding "0 8" and "96 97" throws away
+                        # the narrowing, and ffmpeg binds the FIRST type on each
+                        # line - so an H.265 camera silently loses all video (and
+                        # with it the PAT/PMT, hence the whole output), and a PCMA
+                        # camera loses its audio.  Both types are known by now.
+                        _proto = "RTP/AVP" if _use_plain_rtp else "RTP/SAVP"
+
+                        def _crypto(key: str) -> str:
+                            if _use_plain_rtp:
+                                return ""
+                            return (f"a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
+                                    f"inline:{key}\r\n")
+
                         _new_sdp = (
                             "v=0\r\n"
                             f"o=- {_ts2} {_ts2} IN IP4 0.0.0.0\r\n"
                             "s=aidot-sdes-rx\r\n"
                             "t=0 0\r\n"
-                            f"m=audio {_lo_audio_port} RTP/SAVP 0 8\r\n"
+                            f"m=audio {_lo_audio_port} {_proto} 0 8\r\n"
                             "c=IN IP4 127.0.0.1\r\n"
-                            f"a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:{srtp_key_audio}\r\n"
+                            f"{_crypto(srtp_key_audio)}"
                             "a=rtpmap:0 PCMU/8000\r\n"
                             "a=rtpmap:8 PCMA/8000\r\n"
                             "a=rtcp-mux\r\n"
-                            f"m=video {_lo_video_port} RTP/SAVP 96 97\r\n"
+                            f"m=video {_lo_video_port} {_proto} 96 97\r\n"
                             "c=IN IP4 127.0.0.1\r\n"
-                            f"a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:{srtp_key_video}\r\n"
+                            f"{_crypto(srtp_key_video)}"
                             "a=rtpmap:96 H264/90000\r\n"
                             "a=fmtp:96 level-asymmetry-allowed=1;packetization-mode=1;"
                             "profile-level-id=42e01f\r\n"
@@ -3864,6 +3888,13 @@ class _SdesOpenMixin:
                             "a=fmtp:97 level-id=93\r\n"
                             "a=rtcp-mux\r\n"
                         )
+                        _new_sdp = narrow_sdp_payload_types(
+                            _new_sdp,
+                            keep_video=(_first_video_pt[0]
+                                        if _first_video_pt[0] in (96, 97) else None),
+                            keep_audio=(_first_audio_pt[0]
+                                        if _first_audio_pt[0] in (0, 8) else None),
+                        )
                         try:
                             # Re-apply the cached sprop-parameter-sets here too:
                             # this serve-restart rewrite is the SDP the keepalive

{python_aidot_cameras-0.12.8 → python_aidot_cameras-0.12.10}/aidot_cameras/camera/webrtc_open.py

@@ -1660,6 +1660,22 @@ class _WebRTCOpenMixin:
                     _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_on_remote_dc_message', exc_info=True)
 
         track_tasks: list = []
+
+        def _cancel_track_tasks() -> None:
+            """Cancel the per-session background tasks.
+
+            Only ``WebRTCSession.stop()`` cancels these, and it is reached only
+            when a session is actually returned.  Every failure exit below closes
+            the peer connection and re-raises, which leaves them running - and the
+            AVIO heartbeat loop has no terminal condition (its senders swallow
+            every error), so a camera that fails to open repeatedly accumulates
+            one immortal 10s-tick task per attempt, each pinning the closed
+            RTCPeerConnection graph in memory.
+            """
+            for _t in track_tasks:
+                if not _t.done():
+                    _t.cancel()
+            track_tasks.clear()
         _kvs_dc = None
         if self._offer_should_include_datachannel:
             # Match the official client's label exactly: f0.java:2923 uses
@@ -2346,10 +2362,12 @@ class _WebRTCOpenMixin:
                 _code, _desc = terminal_error_fut.result()
                 _status(f"camera refused: ack {_code} {_desc} - terminal, not retrying")
                 outgoing_q.put_nowait(None)
+                _cancel_track_tasks()
                 await pc.close()
                 raise AidotCameraBusy(_code, _desc)
             _status(f"no webrtcResp in {timeout}s")
             outgoing_q.put_nowait(None)
+            _cancel_track_tasks()
             await pc.close()
             raise RuntimeError(
                 f"async_open_webrtc_stream: no webrtcResp received within {timeout}s"
@@ -2556,6 +2574,7 @@ class _WebRTCOpenMixin:
                     f" {_rr_srd_exc}"
                 )
                 outgoing_q.put_nowait(None)
+                _cancel_track_tasks()
                 await pc.close()
                 raise RuntimeError(
                     f"async_open_webrtc_stream: setRemoteDescription failed:"
@@ -3205,6 +3224,7 @@ class _WebRTCOpenMixin:
                 # co-fail into the full 15s-gated generic retry.
                 outgoing_q.put_nowait(None)   # stop MQTT thread (avoid orphan)
                 try:
+                    _cancel_track_tasks()
                     await pc.close()
                 except Exception:
                     pass
@@ -3347,6 +3367,7 @@ class _WebRTCOpenMixin:
                 )
                 _status(f"setRemoteDescription failed: {exc}")
                 outgoing_q.put_nowait(None)
+                _cancel_track_tasks()
                 await pc.close()
                 raise RuntimeError(
                     f"async_open_webrtc_stream: setRemoteDescription failed: {exc}"
@@ -3569,6 +3590,7 @@ class _WebRTCOpenMixin:
 
         if pc.connectionState not in ("connected", "completed"):
             outgoing_q.put_nowait(None)
+            _cancel_track_tasks()
             await pc.close()
             raise RuntimeError(
                 f"async_open_webrtc_stream: ICE connection not established "

{python_aidot_cameras-0.12.8 → python_aidot_cameras-0.12.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.12.8"
+version = "0.12.10"
 description = "Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)"
 readme = "README.md"
 license = "MIT"

{python_aidot_cameras-0.12.8 → python_aidot_cameras-0.12.10/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.12.8
+Version: 0.12.10
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT

{python_aidot_cameras-0.12.8 → python_aidot_cameras-0.12.10}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -84,7 +84,9 @@ tests/test_go2rtc_cli.py
 tests/test_h264_decode_rate_limit.py
 tests/test_highport_nomination.py
 tests/test_ice_config_cache.py
+tests/test_idle_release_both_loops.py
 tests/test_keepalive_renew.py
+tests/test_key_restart_sdp.py
 tests/test_keyframe_prompter.py
 tests/test_lan_control.py
 tests/test_light_active_color_mode.py
@@ -134,4 +136,5 @@ tests/test_terminal_ack.py
 tests/test_token_file_robustness.py
 tests/test_token_refresh.py
 tests/test_upstream_compat.py
+tests/test_viewer_presence.py
 tests/test_wait_or_event.py

python_aidot_cameras-0.12.10/tests/test_idle_release_both_loops.py

@@ -0,0 +1,48 @@
+"""Both serve loops must decide idleness by asking who is WATCHING.
+
+0.12.9 fixed this for the SDES loop and left the DTLS loop on its old signal -
+pipe-progress staleness - which is the same unanswerable question in disguise: the
+pipe only backs up when nothing drains the serve socket, and go2rtc drains it
+forever as the stream's producer. On a fleet that is mostly DTLS cameras (this one
+is 4 of 5) the fix therefore did nothing.
+"""
+import inspect
+
+import aidot_cameras.camera.client as cc
+
+
+def _src(name):
+    return inspect.getsource(getattr(cc.CameraMixin, name))
+
+
+def test_sdes_loop_asks_who_is_watching():
+    assert "_viewer_present" in _src("_sdes_keepalive_loop_inner")
+
+
+def test_dtls_loop_asks_who_is_watching():
+    # The regression: this loop used only `_now - progress[0] > idle_secs`.
+    assert "_viewer_present" in _src("_dtls_serve_loop_inner")
+
+
+def test_dtls_loop_still_has_a_fallback_when_nobody_can_answer():
+    # If go2rtc cannot be reached the old staleness heuristic must remain, so an
+    # unreachable go2rtc does not mean "hold every stream open forever".
+    src = _src("_dtls_serve_loop_inner")
+    assert "progress[0] > idle_secs" in src
+
+
+def test_the_stream_slot_is_released_even_if_the_relay_fails_to_start():
+    # _maybe_start_serve_relay catches OSError, but Thread.start() raises
+    # RuntimeError under thread exhaustion. Starting it outside the try meant the
+    # permit was lost for the life of the process and the cap silently shrank.
+    src = _src("_dtls_serve_loop")
+    acquire = src.index("slots.acquire()")
+    try_at = src.index("try:", acquire)
+    relay_at = src.index("_maybe_start_serve_relay", acquire)
+    assert try_at < relay_at, "relay start must be inside the try that releases"
+
+
+def test_teardown_does_not_join_a_thread_that_never_started():
+    # join() on an unstarted thread raises and would skip the ffmpeg terminate
+    # and the session stop that follow it.
+    assert "mux_thread.is_alive()" in _src("_dtls_serve_loop_inner")

python_aidot_cameras-0.12.10/tests/test_key_restart_sdp.py

@@ -0,0 +1,61 @@
+"""The SRTP key-restart must rewrite the SDP the same way the primary path does.
+
+It rebuilds the ffmpeg SDP from scratch and relaunches. Two things it got wrong,
+each undoing a shipped fix:
+
+- Transport. Every SDES model this library supports is in `_use_plain_rtp`: the
+  bridge decrypts and forwards PLAIN RTP, so the primary SDP is RTP/AVP with no
+  a=crypto. Writing RTP/SAVP makes ffmpeg authenticate already-decrypted packets,
+  every HMAC check fails, and a working stream drops to zero bytes mid-session.
+- Payload types. Hard-coding "0 8" and "96 97" discards the narrowing, and ffmpeg
+  binds the FIRST type per line - so an H.265 camera loses all video, and with it
+  the PAT/PMT and therefore the entire output.
+"""
+import re
+
+import aidot_cameras.camera.sdes_open as so
+
+
+def _restart_block() -> str:
+    src = so.__loader__.get_source("aidot_cameras.camera.sdes_open")
+    i = src.index("_new_sdp = (")
+    return src[i:i + 3000]
+
+
+def test_restart_respects_plain_rtp_transport():
+    block = _restart_block()
+    assert "_proto" in block, "transport must follow _use_plain_rtp, not be fixed"
+    assert 'f"m=audio {_lo_audio_port} {_proto}' in block
+    assert 'f"m=video {_lo_video_port} {_proto}' in block
+
+
+def test_restart_omits_crypto_for_plain_rtp():
+    block = _restart_block()
+    assert "_crypto(" in block, "a=crypto must be conditional on the transport"
+    assert "a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:{srtp_key_audio}" not in block
+
+
+def test_restart_narrows_the_payload_types():
+    block = _restart_block()
+    assert "narrow_sdp_payload_types(" in block
+    assert "keep_video=" in block and "keep_audio=" in block
+
+
+def test_first_media_wait_covers_the_documented_cold_start():
+    # The repo documents a 25-70s cold start for battery cameras in several
+    # places. A 45s deadline sat inside that range, so a camera at the slow end
+    # launched with no payload types known - the exact failure the wait exists to
+    # prevent.
+    assert so._FIRST_MEDIA_WAIT_S >= 70.0
+
+
+def test_narrowing_still_produces_a_single_payload_type_per_line():
+    sdp = (
+        "m=audio 1000 RTP/AVP 0 8\r\n"
+        "a=rtpmap:0 PCMU/8000\r\na=rtpmap:8 PCMA/8000\r\n"
+        "m=video 1002 RTP/AVP 96 97\r\n"
+        "a=rtpmap:96 H264/90000\r\na=rtpmap:97 H265/90000\r\n"
+    )
+    out = so.narrow_sdp_payload_types(sdp, keep_video=97, keep_audio=8)
+    assert re.search(r"m=audio 1000 RTP/AVP 8\r\n", out)
+    assert re.search(r"m=video 1002 RTP/AVP 97\r\n", out)

python_aidot_cameras-0.12.10/tests/test_viewer_presence.py

@@ -0,0 +1,71 @@
+"""Idle-release must key on real viewers, not on go2rtc being attached.
+
+go2rtc attaches to the camera serve as its PRODUCER and stays attached for as long
+as the stream is registered - viewer or no viewer. So the serve socket always has
+an ESTABLISHED peer, the idle window never elapses, and every camera keeps
+streaming forever after a single view. Confirmed live: five cameras, nobody
+watching, still producing after 7 minutes against a 5 minute idle window.
+"""
+import asyncio
+
+from aidot_cameras.camera.go2rtc import Go2rtcClient
+
+
+class _Resp:
+    def __init__(self, payload, status=200):
+        self._p, self.status = payload, status
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *a):
+        return False
+
+    async def json(self):
+        return self._p
+
+
+class _Session:
+    def __init__(self, payload, status=200):
+        self._p, self._status = payload, status
+
+    def get(self, *a, **kw):
+        return _Resp(self._p, self._status)
+
+
+def _count(payload, name="aidot_abc", status=200):
+    client = Go2rtcClient(_Session(payload, status), "http://go2rtc:1984")
+    return asyncio.run(client.viewer_count(name))
+
+
+def test_no_viewers_when_consumers_is_empty():
+    # A producer attached with no consumers is exactly the idle case that was
+    # being misread as "someone is watching".
+    assert _count({"aidot_abc": {"producers": [{"url": "x"}], "consumers": []}}) == 0
+
+
+def test_no_viewers_when_go2rtc_reports_null():
+    # go2rtc returns null rather than [] for some streams; that is still nobody.
+    assert _count({"aidot_abc": {"producers": [{"url": "x"}], "consumers": None}}) == 0
+
+
+def test_counts_real_viewers():
+    assert _count({"aidot_abc": {"consumers": [{"id": 1}, {"id": 2}]}}) == 2
+
+
+def test_unknown_when_the_stream_is_absent():
+    # Unknown must stay unknown so the caller fails safe and does NOT release.
+    assert _count({"something_else": {"consumers": []}}) is None
+
+
+def test_unknown_when_go2rtc_is_unreachable():
+    assert _count({}, status=500) is None
+
+
+def test_release_policy_treats_unknown_as_do_not_release():
+    from aidot_cameras.camera.protocol import _idle_release_due
+    now = 1000.0
+    assert _idle_release_due(None, now - 9999, now, 300) is False   # unknown
+    assert _idle_release_due(True, now - 9999, now, 300) is False   # watching
+    assert _idle_release_due(False, now - 9999, now, 300) is True   # idle, elapsed
+    assert _idle_release_due(False, now - 10, now, 300) is False    # idle, too soon