python-aidot-cameras 1.0.0rc2__tar.gz → 1.0.0rc4__tar.gz

{python_aidot_cameras-1.0.0rc2/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0rc2
+Version: 1.0.0rc4
 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
@@ -418,6 +418,7 @@ audio, idle release, the sprop cache path) are documented in
 | `AIDOT_SDES_CONNECTION_MODE` | Which media path the SDES offer proposes: `auto` (default - every reachable candidate, and ICE priority prefers the LAN with the relay as last resort; measured on the full fleet, six of seven cameras stream direct and only the unit with no route to us rides the relay), `lan` (no relay at all - same lever as `AIDOT_SDES_SKIP_TURN_PREALLOC`, and battery cameras keep the relay regardless because a cloud-woken camera has no other path back), or `relay` (EXPERIMENTAL, and on the reference fleet it does not steer: even with `c=`/`m=` moved to the relay allocation and the WAN permission pre-installed, an A001064 and an A001513 both dialed our host address directly, learning it from our own ICE probes - forcing the relay for real would mean suppressing every direct-path outbound, which is unbuilt). Per-open `sdes_connection_mode` beats the env. Every session reports the path its media actually took as `media_stats().media_path` (`direct`/`relay`). | unset (`auto`) |
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed. Truthy value enables. Ignored for battery cameras, where the fast path cannot win and its short grace truncates the cold start. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
+| `AIDOT_SDES_LIVEPLAY_ECHO_S` | How long to wait for the broker to echo our own `livePlayReq` back before sending `webrtcReq`, in seconds (`0` disables the wait). The wait was 5.0 s on the models excluded from fast-liveplay and is pure latency: across 22 h of one deployment it ran 169 times and timed out 169 times, never once ending early, with no inbound `livePlayReq` among 5000+ messages the cameras and broker did send. The code proceeds on timeout anyway, so it never changed behaviour, only delayed it. Measured on an A001064: time to first media 11534 ms -> 6819 ms. Still honoured, so a broker that does echo short-circuits it. | 0.25 s (1.5 s for fast-liveplay models) |
 | `AIDOT_SDES_NACK` | Ask the camera to resend video RTP packets that never arrived (RTCP Generic NACK). A camera losing packets on a weak link otherwise delivers truncated H.264 slices, which a browser's WebRTC decoder conceals but Media Source Extensions treats as fatal. Measured on an A001064 at ~1-2% loss: 98.4% of losses recovered against none at all without it. Costs nothing on a clean link, where no requests are generated. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SDES_VIDEO_PT` | Pin the SDES offer to ONE video codec by payload type, so the camera cannot choose. The offer advertises 96 (H264) and 97 (H265) and the camera decides which to send; on an A001064 that means the same request comes back h264 1280x720 most sessions and hevc 2560x1440 occasionally, at a third of the bitrate. Set to `96` for H264 only (measured h264 720p in 4 of 4 sessions). **Do not set it to `97`** - an H265-only offer returned no video at all in 3 of 3 rounds; narrowing to H265 removes the option rather than selecting it. | unset (both offered) |
 | `AIDOT_SDES_VIDEO_PT_ORDER` | Reorder the SDES offer's video codec list without narrowing it, as a comma-separated preference list (`97,96`). RFC 3264 makes the `m=video` payload-type list a preference list, most-preferred first, and ours has always read `96 97` - not by decision, it has simply never been varied. Whatever is named leads and the rest is appended, so this can express a preference and can never produce a narrowed or empty video m-line. **Experimental and untested on hardware:** whether the camera acts on the order is the open question, so the default is deliberately unchanged. **Tested on hardware 2026-08-23 and it does not select the codec.** Eight sessions on an A001064 in blocks of two: H265 came back in 2 of 4 with the order reversed and 2 of 4 without it, receipts confirming the reordered list reached the SDP. The motive was real - an H265 session costs about half an H264 one (766-774 vs 1597-1685 Kbps) - but the camera picks the codec itself, roughly a coin flip, and RFC 3264 preference order does not move it. | unset (`96 97`) |

{python_aidot_cameras-1.0.0rc2 → python_aidot_cameras-1.0.0rc4}/README.md

@@ -378,6 +378,7 @@ audio, idle release, the sprop cache path) are documented in
 | `AIDOT_SDES_CONNECTION_MODE` | Which media path the SDES offer proposes: `auto` (default - every reachable candidate, and ICE priority prefers the LAN with the relay as last resort; measured on the full fleet, six of seven cameras stream direct and only the unit with no route to us rides the relay), `lan` (no relay at all - same lever as `AIDOT_SDES_SKIP_TURN_PREALLOC`, and battery cameras keep the relay regardless because a cloud-woken camera has no other path back), or `relay` (EXPERIMENTAL, and on the reference fleet it does not steer: even with `c=`/`m=` moved to the relay allocation and the WAN permission pre-installed, an A001064 and an A001513 both dialed our host address directly, learning it from our own ICE probes - forcing the relay for real would mean suppressing every direct-path outbound, which is unbuilt). Per-open `sdes_connection_mode` beats the env. Every session reports the path its media actually took as `media_stats().media_path` (`direct`/`relay`). | unset (`auto`) |
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed. Truthy value enables. Ignored for battery cameras, where the fast path cannot win and its short grace truncates the cold start. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
+| `AIDOT_SDES_LIVEPLAY_ECHO_S` | How long to wait for the broker to echo our own `livePlayReq` back before sending `webrtcReq`, in seconds (`0` disables the wait). The wait was 5.0 s on the models excluded from fast-liveplay and is pure latency: across 22 h of one deployment it ran 169 times and timed out 169 times, never once ending early, with no inbound `livePlayReq` among 5000+ messages the cameras and broker did send. The code proceeds on timeout anyway, so it never changed behaviour, only delayed it. Measured on an A001064: time to first media 11534 ms -> 6819 ms. Still honoured, so a broker that does echo short-circuits it. | 0.25 s (1.5 s for fast-liveplay models) |
 | `AIDOT_SDES_NACK` | Ask the camera to resend video RTP packets that never arrived (RTCP Generic NACK). A camera losing packets on a weak link otherwise delivers truncated H.264 slices, which a browser's WebRTC decoder conceals but Media Source Extensions treats as fatal. Measured on an A001064 at ~1-2% loss: 98.4% of losses recovered against none at all without it. Costs nothing on a clean link, where no requests are generated. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SDES_VIDEO_PT` | Pin the SDES offer to ONE video codec by payload type, so the camera cannot choose. The offer advertises 96 (H264) and 97 (H265) and the camera decides which to send; on an A001064 that means the same request comes back h264 1280x720 most sessions and hevc 2560x1440 occasionally, at a third of the bitrate. Set to `96` for H264 only (measured h264 720p in 4 of 4 sessions). **Do not set it to `97`** - an H265-only offer returned no video at all in 3 of 3 rounds; narrowing to H265 removes the option rather than selecting it. | unset (both offered) |
 | `AIDOT_SDES_VIDEO_PT_ORDER` | Reorder the SDES offer's video codec list without narrowing it, as a comma-separated preference list (`97,96`). RFC 3264 makes the `m=video` payload-type list a preference list, most-preferred first, and ours has always read `96 97` - not by decision, it has simply never been varied. Whatever is named leads and the rest is appended, so this can express a preference and can never produce a narrowed or empty video m-line. **Experimental and untested on hardware:** whether the camera acts on the order is the open question, so the default is deliberately unchanged. **Tested on hardware 2026-08-23 and it does not select the codec.** Eight sessions on an A001064 in blocks of two: H265 came back in 2 of 4 with the order reversed and 2 of 4 without it, receipts confirming the reordered list reached the SDP. The motive was real - an H265 session costs about half an H264 one (766-774 vs 1597-1685 Kbps) - but the camera picks the codec itself, roughly a coin flip, and RFC 3264 preference order does not move it. | unset (`96 97`) |

{python_aidot_cameras-1.0.0rc2 → python_aidot_cameras-1.0.0rc4}/aidot_cameras/camera/client.py

@@ -2376,9 +2376,15 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
         timeout: float = 8.0,
         ack_keyword: str = "setDevAttr",
         seq: "Optional[str]" = None,
+        expect_ack: bool = True,
     ) -> bool:
         """Connect MQTT, optionally wake battery camera, publish command, wait for ack.
 
+        ``expect_ack=False`` reports whether the command was PUBLISHED, not
+        whether the camera answered. That is the honest result for an action
+        whose success removes the camera from the network -- a reboot acks by
+        going away, so waiting for one turns a working command into a False.
+
         All setDevAttrReq callers in the APK (b6.java, LiveCameraView, etc.)
         are in live-view screens where the camera is already awake and MQTT-
         connected.  For battery cameras we send lowPowerActiveStateReq first so
@@ -2454,6 +2460,17 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
                 duration=timeout,
             )
 
+        # A fire-and-forget caller only needs to know the publish left the host.
+        # `_st` separates that from "no ack came back", which the ack scan below
+        # cannot: it returns False for a failed publish and for a camera that
+        # rebooted before answering.
+        if not expect_ack:
+            _published = not (_st and _st.get("error"))
+            _LOGGER.info(
+                "_mqtt_device_cmd: published without waiting for an ack "
+                "(topic=%s published=%s)", pub_topic, _published)
+            return _published
+
         # Two passes, because being sure is worth more than being quick. A
         # response carrying OUR seq is proof; anything else on these topics is
         # only evidence that SOMETHING was acked - and several things are in
@@ -2546,6 +2563,7 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
         """
         import json as _json
         import random as _random
+        import time as _time
 
         lan = getattr(self, "_lan_client", None)
         if lan is not None:
@@ -2567,11 +2585,17 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
             inner["userId"] = str(user_id)
         if cam_pwd:
             inner["password"] = cam_pwd
+        # `tst` matches the app, which stamps every setDevAttrReq and
+        # devActionReq it builds. The camera accepts the message without it --
+        # this path is proven and reads back within one poll -- so this is
+        # parity rather than a fix; it costs nothing and removes one more way
+        # our traffic differs from the vendor's.
         payload = _json.dumps({
             "id":      device_id,
             "method":  "setDevAttrReq",
             "service": "device",
             "seq":     seq,
+            "tst":     int(_time.time() * 1000),
             "payload": inner,
         })
         pub_topic = f"iot/v1/c/{device_id}/device/setDevAttrReq"
@@ -2592,12 +2616,92 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
                 _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_set_device_attribute', exc_info=True)
         return ok
 
+    async def async_query_device_action(
+        self,
+        action: str,
+        params=None,
+        *,
+        timeout: float = 8.0,
+    ):
+        """Send a read-only devActionReq and return the camera's ``out`` payload.
+
+        :meth:`async_trigger_device_action` answers "did it go", which is all a
+        control needs. But the camera *answers* its ``get`` actions with real
+        data -- wifi details, SD capacity, which sound algorithms are armed --
+        and none of that was reachable while the only helper returned a bool.
+
+        Returns the decoded ``out`` exactly as the camera sent it (list or
+        dict), or ``None`` when nothing came back. ``None`` means UNKNOWN, not
+        "off": several of these actions answer with ``out: null`` on models that
+        do not implement them, and a caller that reads that as a disabled
+        feature will report a camera as having something switched off when it
+        simply cannot say.
+
+        Deliberately built on the module-level session helper rather than on
+        :meth:`_mqtt_device_cmd`: that method reduces a reply to a bool and is
+        the proven control path, so it is left alone.
+        """
+        import json as _json
+        import random as _random
+        import time as _time
+
+        user_id   = self.user_id
+        device_id = self.device_id
+        smarthome_auth = await self._async_get_smarthome_auth()
+        mqtt_url = await self._async_get_mqtt_url()
+        if not mqtt_url:
+            _LOGGER.debug("async_query_device_action: no MQTT URL for %s", device_id)
+            return None
+        mqtt_user = (smarthome_auth or {}).get("mqttUser") or str(user_id)
+        mqtt_pwd  = (smarthome_auth or {}).get("mqttPassword") or ""
+        client_id = (self._user_info.get("mqttClientId") or f"app-{mqtt_user}")
+
+        _dev = self._camera_properties() or {}
+        parent_id = (getattr(getattr(self, "info", None), "direct_id", None)
+                     or _dev.get("directId") or _dev.get("parentId") or device_id)
+        seq = f"ap{_random.randint(1000000, 9999999)}"
+        payload = _json.dumps({
+            "method":  "devActionReq",
+            "service": "device",
+            "seq":     seq,
+            "tst":     int(_time.time() * 1000),
+            "payload": {
+                "devId":    device_id,
+                "parentId": parent_id,
+                "action":   action,
+                "in":       params if params is not None else [],
+            },
+        })
+        publish_items = [
+            (f"iot/v1/s/{user_id}/device/devActionReq", payload),
+        ]
+        messages, _st = await _mqtt_session_with_status(
+            mqtt_url, mqtt_user, mqtt_pwd, client_id,
+            subscribe_topics=[f"iot/v1/c/{user_id}/#", f"iot/v1/cb/{user_id}/#"],
+            publish_items=publish_items,
+            duration=timeout,
+        )
+        for topic, raw in messages:
+            if "devAction" not in topic:
+                continue
+            try:
+                msg = _json.loads(raw)
+            except Exception:
+                continue
+            body = msg.get("payload") or {}
+            if body.get("action") != action:
+                continue
+            return body.get("out")
+        _LOGGER.debug("devActionReq %s: no reply from %s", action, device_id)
+        return None
+
     async def async_trigger_device_action(
         self,
         action: str,
         params,
         *,
         timeout: float = 4.0,
+        expect_ack: bool = True,
     ) -> bool:
         """Send a devActionReq (e.g. siren/alarm trigger).
 
@@ -2607,23 +2711,42 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
                     "payload": {"devId": deviceId, "action": action, "in": params}}
         """
         import json as _json
+        import random as _random
+        import time as _time
 
         user_id   = self.user_id
         device_id = self.device_id
 
+        # The app's own builder (main chunk, DeviceControl) sends five things we
+        # did not: `seq`, `tst`, and a `parentId` alongside `devId`. The camera
+        # answers nothing at all to a devActionReq without them -- a RebootFunc
+        # sent in the short form drew zero replies and did not reboot, while the
+        # same action with these fields is what the settings page uses.
+        #
+        # `password` is deliberately NOT sent: the H5 passes it to its wrapper,
+        # but the wrapper does not put it on the wire, and a read-only
+        # `WifiBaseInfo` acks without it.
+        _dev = self._camera_properties() or {}
+        parent_id = (getattr(getattr(self, "info", None), "direct_id", None)
+                     or _dev.get("directId") or _dev.get("parentId") or device_id)
+        seq = f"ap{_random.randint(1000000, 9999999)}"
         payload = _json.dumps({
             "method":  "devActionReq",
             "service": "device",
+            "seq":     seq,
+            "tst":     int(_time.time() * 1000),
             "payload": {
-                "devId":  device_id,
-                "action": action,
-                "in":     params,
+                "devId":    device_id,
+                "parentId": parent_id,
+                "action":   action,
+                "in":       params,
             },
         })
         pub_topic = f"iot/v1/s/{user_id}/device/devActionReq"
         _LOGGER.info("devActionReq: %s %s -> %s", action, params, device_id)
         return await self._mqtt_device_cmd(
-            pub_topic, payload, timeout=timeout, ack_keyword="devAction")
+            pub_topic, payload, timeout=timeout, ack_keyword="devAction",
+            seq=seq, expect_ack=expect_ack)
 
     # Convenience wrappers - confirmed attribute names/types from APK source
 

{python_aidot_cameras-1.0.0rc2 → python_aidot_cameras-1.0.0rc4}/aidot_cameras/camera/controls.py

@@ -9,6 +9,8 @@ mixin must be combined into CameraMixin (it is not usable standalone).
 import logging
 import struct
 
+from typing import Optional
+
 from .constants import _PTZ_DIR_CODES, _STREAM_QUALITY, SETSTREAMCTRL_CMD
 
 _LOGGER = logging.getLogger(__name__)
@@ -87,6 +89,131 @@ class _CameraControlsMixin:
         self.status.siren = on
         return result
 
+    #: Sound-detection algorithms, in the order the camera reports them. The
+    #: camera answers ``soundAlgorithmGet`` with a list of single-key dicts --
+    #: ``[{"sound_enable": 0}, {"glass_Break": 0}, {"smoke_T3": 0}, ...]`` --
+    #: so the key names come from the camera rather than from us. The vendor
+    #: app's own strings name baby_cry and dog_bark alongside these.
+    #: ``sound_enable`` is the master switch; the rest are individual detectors.
+    SOUND_MASTER_KEY = "sound_enable"
+
+    async def async_get_sound_detection(self) -> "Optional[dict]":
+        """Which sound detectors are armed, as ``{key: bool}``.
+
+        ``None`` means the camera did not answer -- unknown, NOT all-off. A
+        model that does not implement this replies with a null ``out``, and
+        reporting that as a set of disabled switches would invent a state the
+        camera never claimed.
+        """
+        out = await self.async_query_device_action("soundAlgorithmGet")
+        if not isinstance(out, list):
+            return None
+        flags: dict = {}
+        for item in out:
+            if isinstance(item, dict):
+                for key, value in item.items():
+                    flags[key] = bool(value)
+        return flags or None
+
+    async def async_set_sound_detection(self, key: str, enabled: bool) -> bool:
+        """Arm or disarm one sound detector.
+
+        Read-modify-write: the camera is asked for the current list and gets
+        the same structure back with one flag changed. The alternative is
+        inventing a payload schema for ``soundAlgorithmSet``, and the camera
+        reports the shape it wants -- so echo it rather than guess it.
+        """
+        out = await self.async_query_device_action("soundAlgorithmGet")
+        if not isinstance(out, list):
+            _LOGGER.warning(
+                "sound detection: %s did not report its algorithms; not writing",
+                self.device_id)
+            return False
+        found = False
+        payload = []
+        for item in out:
+            if isinstance(item, dict) and key in item:
+                payload.append({key: 1 if enabled else 0})
+                found = True
+            else:
+                payload.append(item)
+        if not found:
+            _LOGGER.warning("sound detection: %s does not report %r", self.device_id, key)
+            return False
+        return await self.async_trigger_device_action("soundAlgorithmSet", payload)
+
+    async def async_get_wifi_info(self) -> "Optional[dict]":
+        """``{"ssid": str, "rssi": int}`` for the camera's own WiFi link.
+
+        The camera answers ``WifiBaseInfo`` with a positional list whose first
+        two entries are the SSID and signal strength. Only those two are named
+        here -- the third is an integer that looks like an encoded address, and
+        naming a field we have not confirmed is how a guess becomes a fact.
+        """
+        out = await self.async_query_device_action("WifiBaseInfo")
+        if not isinstance(out, list) or not out:
+            return None
+        info: dict = {"ssid": out[0] if isinstance(out[0], str) else None}
+        if len(out) > 1 and isinstance(out[1], (int, float)):
+            info["rssi"] = int(out[1])
+        return info
+
+    async def async_get_sd_card_info(self) -> "Optional[dict]":
+        """``{"present": bool, "total": int, "used": int, "raw": list}``.
+
+        ``SDcardBaseInfo`` answers positionally: ``[False, 0, 0, 0, 0]`` with no
+        card, ``[True, 29838, 28848, 3, ...]`` on a nearly-full one.
+
+        Only the first three fields are named. The fourth was almost called
+        "free" -- but 29838 - 28848 is 990, not 3, so it is not a remainder;
+        28848/29838 is 96.7%, which makes 3 look like a percentage. "Looks
+        like" is not confirmation, so it stays unnamed in ``raw`` rather than
+        shipping a field that reports 3 MB free on a 30 GB card.
+
+        Units for ``total`` and ``used`` are unconfirmed too (MB is plausible
+        at these magnitudes), so the numbers are passed through exactly as the
+        camera reports them rather than converted.
+        """
+        out = await self.async_query_device_action("SDcardBaseInfo")
+        if not isinstance(out, list) or not out:
+            return None
+        def _n(i):
+            return int(out[i]) if len(out) > i and isinstance(out[i], (int, float)) else None
+        return {"present": bool(out[0]), "total": _n(1), "used": _n(2),
+                "raw": list(out)}
+
+    async def async_reboot(self) -> bool:
+        """Ask the camera to reboot. True means the request was SENT.
+
+        The vendor app's camera settings page does exactly this -- its H5
+        bundle calls ``devActionReq({action: "RebootFunc", in: []})`` -- and
+        ``RebootFunc`` also appears in the native ``NewLivePresenter``. It is
+        the same ``devActionReq`` transport the siren already uses.
+
+        Two deliberate choices:
+
+        * **No ack is awaited.** A reboot succeeds by taking the camera off the
+          network, so a camera that reboots before answering would otherwise be
+          reported as a failure. The app passes no timeout for this action
+          either, unlike the reads beside it. So this reports "requested", and
+          the caller must not read it as "rebooted".
+        * **Refused when the cloud says the camera is offline.** The app only
+          renders its reboot button when the device is reachable
+          (``isCanUseStatus``), and a wake-then-reboot on a sleeping battery
+          camera is not something to fire blind.
+
+        The camera is gone for about a minute afterwards (the app's own wording
+        is "The device Needs a minute to reboot"), during which a viewer sees a
+        session that connects and delivers nothing.
+        """
+        if (not self.status.online) and getattr(self, "_cloud_online_explicit", False):
+            _LOGGER.warning(
+                "reboot refused for %s: the cloud reports it offline", self.device_id)
+            return False
+        _LOGGER.info("reboot requested for %s", self.device_id)
+        return await self.async_trigger_device_action(
+            "RebootFunc", [], expect_ack=False)
+
     async def async_set_night_vision(self, mode: str) -> bool:
         """mode: 'auto' (0), 'on' (1), 'off' (2)"""
         _modes = {"auto": 0, "on": 1, "off": 2}

{python_aidot_cameras-1.0.0rc2 → python_aidot_cameras-1.0.0rc4}/aidot_cameras/camera/protocol.py

@@ -1058,6 +1058,11 @@ class _DirectTsServer:
         self._pmt: "Optional[bytes]" = None
         self._pmt_pid: "Optional[int]" = None
         self._synced = False        # has the current consumer been given a start
+        # Set by the mux immediately before it writes a video keyframe, so a new
+        # consumer can be spliced where the picture is actually decodable.
+        self._kf_pending = False
+        self._kf_ever = False
+        self._waiting_since: "Optional[float]" = None
 
     @property
     def port(self) -> int:
@@ -1141,6 +1146,51 @@ class _DirectTsServer:
         except (IndexError, ValueError):
             return
 
+    #: How long a new consumer may wait for a keyframe signal before the old
+    #: PID-blind random-access test is allowed to start it anyway. The signal is
+    #: the correct trigger, but a stream that never sends one must not hang
+    #: forever - gating solely on a video-pid flag served ZERO bytes when tried
+    #: (2026-08-29), because the muxer does not set it.
+    _LEGACY_SYNC_AFTER_S = 5.0
+
+    def mark_keyframe(self) -> None:
+        """Tell the server the next bytes written begin a video keyframe.
+
+        The mux knows this and used to throw it away: it pulls ``(data, ts, kf)``
+        off the queue and ``kf`` came from ``_h264_has_keyframe`` at the tap.
+        Everything downstream then tried to rediscover it from the container,
+        which does not carry it - PyAV's mpegts muxer does not set
+        ``random_access_indicator`` on the video PID in this stream, so a sync
+        gated on that flag never fires at all.
+
+        Splicing a consumer anywhere else hands it video mid-GOP referencing an
+        SPS/PPS it never received, which decodes as "non-existing PPS 0
+        referenced": a video track that never produces a frame.
+        """
+        if not self._kf_ever:
+            _LOGGER.debug("direct-ts: first keyframe signal reached the server")
+        self._kf_ever = True
+        self._kf_pending = True
+
+    def _legacy_sync_ok(self, pkt: bytes) -> bool:
+        """The pre-signal behaviour, allowed only after a grace period.
+
+        Kept because a source that never calls ``mark_keyframe`` must still be
+        servable. Deliberately NOT the first choice: this test accepts a
+        random-access point on ANY pid, and AAC audio sets that flag ~50x/s, so
+        before the signal existed a late joiner was spliced onto audio and never
+        received a decodable picture.
+        """
+        if self._kf_ever:
+            return False        # this source signals; wait for the real thing
+        if not self._is_random_access(pkt):
+            return False
+        now = time.monotonic()
+        if self._waiting_since is None:
+            self._waiting_since = now
+            return False
+        return (now - self._waiting_since) >= self._LEGACY_SYNC_AFTER_S
+
     def write(self, b: bytes) -> int:
         data = self._tail + b if self._tail else b
         out = bytearray()
@@ -1164,7 +1214,11 @@ class _DirectTsServer:
                 self._pmt = pkt
             if self._synced:
                 out += pkt
-            elif self._is_random_access(pkt):
+            elif self._kf_pending or self._legacy_sync_ok(pkt):
+                _LOGGER.debug(
+                    "direct-ts: spliced a consumer via=%s signals=%s pid=%s",
+                    "keyframe-signal" if self._kf_pending else "legacy-rai",
+                    self._kf_ever, pid)
                 # Start this consumer here: tables first, then the keyframe.
                 if self._pat is not None:
                     out += self._pat
@@ -1172,6 +1226,8 @@ class _DirectTsServer:
                     out += self._pmt
                 out += pkt
                 self._synced = True
+                self._kf_pending = False
+                self._waiting_since = None
         self._tail = data[i:] if i < n else b""
 
         with self._lock:
@@ -1568,6 +1624,16 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
         def close(self):
             self._f.close()
 
+        def mark_keyframe(self):
+            """Forward the keyframe signal when the sink understands it.
+
+            The sink is a _DirectTsServer on the direct path and an os pipe to
+            ffmpeg otherwise; only the former can use this.
+            """
+            fn = getattr(self._f, "mark_keyframe", None)
+            if fn is not None:
+                fn()
+
     wsink = _FailFlagWriter(out_fileobj)
     try:
         # max_interleave_delta (default 10s of stream time): with an AAC stream
@@ -1659,6 +1725,10 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
             pkt.stream = vs
             pkt.pts, pkt.dts = video_pts_dts(_ts_state, _rel, _slack)
             pkt.time_base = Fraction(1, 90000)
+            if kf:
+                # Announce it BEFORE muxing: the bytes this produces are where a
+                # new consumer can safely be spliced, and only we know that.
+                wsink.mark_keyframe()
             try:
                 out.mux(pkt)
                 progress[0] = _t.monotonic()

{python_aidot_cameras-1.0.0rc2 → python_aidot_cameras-1.0.0rc4}/aidot_cameras/camera/sdes_open.py

@@ -108,6 +108,70 @@ def _sctp_reassemble(flags: int, stream_id: int, payload: bytes,
     return None
 
 
+async def _await_rtsp_publish_target(url: "Optional[str]", *,
+                                     timeout: float = 20.0) -> bool:
+    """Wait until an ``rtsp://host:port`` target accepts a connection.
+
+    Publishing into go2rtc is a race after a Home Assistant restart: the serve
+    ffmpeg is launched as soon as media arrives, and go2rtc's RTSP listener may
+    not be back yet. ffmpeg then fails its very first connect with
+    ``Connection refused``, reports ``Could not write header (incorrect codec
+    parameters ?)``, and exits 145 -- which reads as "stream ended" and takes
+    that camera's view down until something retries.
+
+    Measured on a live box: every occurrence of that failure sat inside a
+    one-minute window around an HA restart (11:32, 11:43, 11:49, 11:52, 11:54,
+    11:56, 11:57 on 2026-09-01, and the same shape the night before), and none
+    in steady state.
+
+    Returns True when the port accepts, False on timeout. False is not fatal --
+    the caller launches ffmpeg anyway, because a target that never opens is a
+    different problem and should surface as ffmpeg's own error rather than as a
+    silent refusal to start.
+    """
+    if not url or not url.startswith("rtsp://"):
+        return True
+    try:
+        rest = url[len("rtsp://"):]
+        hostport = rest.split("/", 1)[0]
+        if "@" in hostport:
+            hostport = hostport.rsplit("@", 1)[1]
+        if hostport.startswith("["):            # IPv6 literal
+            if "]" not in hostport:
+                return True                      # malformed: do not block
+            host, _, tail = hostport[1:].partition("]")
+            port = int(tail.lstrip(":") or 554)
+        else:
+            host, _, port_s = hostport.partition(":")
+            port = int(port_s or 554)
+    except (ValueError, IndexError):
+        return True                              # unparseable: do not block
+
+    _deadline = time.monotonic() + timeout
+    _attempt = 0
+    while time.monotonic() < _deadline:
+        _attempt += 1
+        try:
+            _r, _w = await asyncio.wait_for(
+                asyncio.open_connection(host, port), timeout=3.0)
+            _w.close()
+            try:
+                await _w.wait_closed()
+            except Exception:
+                pass
+            if _attempt > 1:
+                _LOGGER.info(
+                    "publish target %s:%s accepted after %d attempts",
+                    host, port, _attempt)
+            return True
+        except (OSError, TimeoutError):
+            await asyncio.sleep(0.5)
+    _LOGGER.warning(
+        "publish target %s:%s did not accept a connection within %.0fs - "
+        "launching ffmpeg anyway so its own error surfaces", host, port, timeout)
+    return False
+
+
 def _sctp_sack_chunk(cum_tsn: int, a_rwnd: int = 131072) -> bytes:
     """An SCTP SACK (RFC 4960 s3.3.4) with no gap blocks and no duplicates.
 
@@ -6820,6 +6884,8 @@ class _SdesOpenMixin:
                        if _keep_a is not None else ""))
             except Exception:
                 _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_open_sdes_stream', exc_info=True)
+        # Do not launch the publisher into a listener that is not up yet.
+        await _await_rtsp_publish_target(rtsp_push_url)
         _LOGGER.info("SDES ffmpeg cmd: %s", " ".join(cmd))
         if _ffmpeg_path() is None:
             # ffmpeg is not installed - clean up and surface a clear error

{python_aidot_cameras-1.0.0rc2 → python_aidot_cameras-1.0.0rc4}/pyproject.toml

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

{python_aidot_cameras-1.0.0rc2 → python_aidot_cameras-1.0.0rc4/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0rc2
+Version: 1.0.0rc4
 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
@@ -418,6 +418,7 @@ audio, idle release, the sprop cache path) are documented in
 | `AIDOT_SDES_CONNECTION_MODE` | Which media path the SDES offer proposes: `auto` (default - every reachable candidate, and ICE priority prefers the LAN with the relay as last resort; measured on the full fleet, six of seven cameras stream direct and only the unit with no route to us rides the relay), `lan` (no relay at all - same lever as `AIDOT_SDES_SKIP_TURN_PREALLOC`, and battery cameras keep the relay regardless because a cloud-woken camera has no other path back), or `relay` (EXPERIMENTAL, and on the reference fleet it does not steer: even with `c=`/`m=` moved to the relay allocation and the WAN permission pre-installed, an A001064 and an A001513 both dialed our host address directly, learning it from our own ICE probes - forcing the relay for real would mean suppressing every direct-path outbound, which is unbuilt). Per-open `sdes_connection_mode` beats the env. Every session reports the path its media actually took as `media_stats().media_path` (`direct`/`relay`). | unset (`auto`) |
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed. Truthy value enables. Ignored for battery cameras, where the fast path cannot win and its short grace truncates the cold start. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
+| `AIDOT_SDES_LIVEPLAY_ECHO_S` | How long to wait for the broker to echo our own `livePlayReq` back before sending `webrtcReq`, in seconds (`0` disables the wait). The wait was 5.0 s on the models excluded from fast-liveplay and is pure latency: across 22 h of one deployment it ran 169 times and timed out 169 times, never once ending early, with no inbound `livePlayReq` among 5000+ messages the cameras and broker did send. The code proceeds on timeout anyway, so it never changed behaviour, only delayed it. Measured on an A001064: time to first media 11534 ms -> 6819 ms. Still honoured, so a broker that does echo short-circuits it. | 0.25 s (1.5 s for fast-liveplay models) |
 | `AIDOT_SDES_NACK` | Ask the camera to resend video RTP packets that never arrived (RTCP Generic NACK). A camera losing packets on a weak link otherwise delivers truncated H.264 slices, which a browser's WebRTC decoder conceals but Media Source Extensions treats as fatal. Measured on an A001064 at ~1-2% loss: 98.4% of losses recovered against none at all without it. Costs nothing on a clean link, where no requests are generated. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SDES_VIDEO_PT` | Pin the SDES offer to ONE video codec by payload type, so the camera cannot choose. The offer advertises 96 (H264) and 97 (H265) and the camera decides which to send; on an A001064 that means the same request comes back h264 1280x720 most sessions and hevc 2560x1440 occasionally, at a third of the bitrate. Set to `96` for H264 only (measured h264 720p in 4 of 4 sessions). **Do not set it to `97`** - an H265-only offer returned no video at all in 3 of 3 rounds; narrowing to H265 removes the option rather than selecting it. | unset (both offered) |
 | `AIDOT_SDES_VIDEO_PT_ORDER` | Reorder the SDES offer's video codec list without narrowing it, as a comma-separated preference list (`97,96`). RFC 3264 makes the `m=video` payload-type list a preference list, most-preferred first, and ours has always read `96 97` - not by decision, it has simply never been varied. Whatever is named leads and the rest is appended, so this can express a preference and can never produce a narrowed or empty video m-line. **Experimental and untested on hardware:** whether the camera acts on the order is the open question, so the default is deliberately unchanged. **Tested on hardware 2026-08-23 and it does not select the codec.** Eight sessions on an A001064 in blocks of two: H265 came back in 2 of 4 with the order reversed and 2 of 4 without it, receipts confirming the reordered list reached the SDP. The motive was real - an H265 session costs about half an H264 one (766-774 vs 1597-1685 Kbps) - but the camera picks the codec itself, roughly a coin flip, and RFC 3264 preference order does not move it. | unset (`96 97`) |

{python_aidot_cameras-1.0.0rc2 → python_aidot_cameras-1.0.0rc4}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ tests/test_bitrate_campaign_arms.py
 tests/test_ble_gateway.py
 tests/test_bridge_state_sentinels.py
 tests/test_busy_backoff.py
+tests/test_camera_properties.py
 tests/test_canary_log_names_the_camera.py
 tests/test_cloud_count.py
 tests/test_cloud_plan.py
@@ -102,6 +103,7 @@ tests/test_deferred_hardening.py
 tests/test_device_cmd_seq_match.py
 tests/test_device_login_guard.py
 tests/test_device_user_info_cache.py
+tests/test_direct_ts_keyframe_signal.py
 tests/test_direct_ts_serve.py
 tests/test_dormant_camera_cleanup.py
 tests/test_drain_is_cancellable.py
@@ -177,7 +179,9 @@ tests/test_playback_tls.py
 tests/test_post_merge_hardening.py
 tests/test_ptz_probe_reads_what_it_is_told.py
 tests/test_public_signature_matches_impl.py
+tests/test_publish_target_readiness.py
 tests/test_quality_campaign_in_session.py
+tests/test_reboot_action.py
 tests/test_recent_recordings.py
 tests/test_remb.py
 tests/test_remb_goes_out_the_relay_aware_sender.py