python-aidot-cameras 0.5.10__tar.gz → 0.5.12__tar.gz

{python_aidot_cameras-0.5.10/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.5.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.5.10
+Version: 0.5.12
 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.5.10 → python_aidot_cameras-0.5.12}/pyproject.toml

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

{python_aidot_cameras-0.5.10 → python_aidot_cameras-0.5.12}/src/aidot/client.py

@@ -4,6 +4,7 @@ import asyncio
 import json
 import logging
 import base64
+import random
 import aiohttp
 from aiohttp import ClientSession
 from typing import Any, Callable, Optional
@@ -54,6 +55,14 @@ def rsa_password_encrypt(message: str) -> str:
 
 
 
+async def _prefetch_ice_config(dc: "DeviceClient") -> None:
+    """Background task: warm the HTTP ICE config cache for a device."""
+    try:
+        await dc.async_get_ice_config_http()
+    except Exception:
+        pass  # best-effort; errors are logged inside async_get_ice_config_http
+
+
 class AidotClient:
     _base_url: str = BASE_URL
     _region: str = "us"
@@ -79,6 +88,7 @@ class AidotClient:
         self.login_info: dict[str, Any] = {}
         self._token_fresh_cb: Optional[Callable] = None
         self._device_clients = {}
+        self._refresh_task: "Optional[asyncio.Task]" = None
         # Single-flight guard so a burst of camera 21026s (all 7 pollers at once)
         # coalesces into ONE token refresh / re-login instead of 7 concurrent ones.
         self._ensure_token_inflight: "Optional[asyncio.Future]" = None
@@ -95,10 +105,42 @@ class AidotClient:
             self._region = token[CONF_REGION]
             self.country_name = token[CONF_COUNTRY]
             self._base_url = f"https://prod-{self._region}-api.arnoo.com/v17"
+            # Token loaded from storage: schedule a proactive refresh shortly
+            # after startup.  Exact remaining TTL is unknown, so pass a short
+            # synthetic TTL (120s → 78-138s delay) to catch tokens that are
+            # already near expiry.  After the refresh fires, _schedule_proactive_refresh
+            # sets the next cycle at the proper 90%-of-TTL interval.
+            _LOGGER.info("AidotClient: stored token loaded, scheduling startup proactive refresh")
+            self._schedule_proactive_refresh(120)
 
     def set_token_fresh_cb(self, callback) -> None:
         self._token_fresh_cb = callback
 
+    def _schedule_proactive_refresh(self, expires_in_secs: int) -> None:
+        """Schedule a proactive token refresh at 90% of the token's TTL."""
+        if self._refresh_task and not self._refresh_task.done():
+            self._refresh_task.cancel()
+        delay = max(60.0, expires_in_secs * 0.9 + random.uniform(-30, 30))
+        _LOGGER.debug(
+            "Proactive token refresh scheduled in %.0f s (TTL=%d s)", delay, expires_in_secs
+        )
+
+        async def _refresh_after_delay():
+            try:
+                await asyncio.sleep(delay)
+                await self.async_ensure_token()
+                _LOGGER.debug("Proactive token refresh complete")
+            except asyncio.CancelledError:
+                pass
+            except Exception as exc:
+                _LOGGER.warning("Proactive token refresh failed: %s", exc)
+
+        try:
+            loop = asyncio.get_running_loop()
+            self._refresh_task = loop.create_task(_refresh_after_delay())
+        except RuntimeError:
+            pass  # no running loop (e.g. called from sync test context)
+
     def get_identifier(self) -> str:
         return f"{self._region}-{self.username}"
 
@@ -145,6 +187,9 @@ class AidotClient:
             self.login_info[CONF_USERNAME] = self.username
             # Fetch MQTT password from /commons/userConfig (separate call required).
             await self._async_fetch_user_config()
+            # Schedule proactive refresh so tokens never expire mid-session.
+            _expires_in = int(response_data.get("expiresIn") or 7200)
+            self._schedule_proactive_refresh(_expires_in)
             return self.login_info
         except AidotUserOrPassIncorrect:
             raise
@@ -232,6 +277,8 @@ class AidotClient:
             _LOGGER.debug("refresh token ok  code=%s", response_data.get(CONF_CODE))
             if self._token_fresh_cb:
                 self._token_fresh_cb()
+            _expires_in = int(response_data.get("expiresIn") or 7200)
+            self._schedule_proactive_refresh(_expires_in)
             return response_data
         except aiohttp.ClientError as e:
             _LOGGER.info("async_refresh_token ClientError %s  code=%s", e, response_data.get(CONF_CODE))
@@ -374,6 +421,10 @@ class AidotClient:
             device_client.set_token_refresh_cb(self.async_ensure_token)
             self._device_clients[device_id] = device_client
             asyncio.get_running_loop().create_task(device_client.ping_task())
+            # Pre-warm ICE config cache so stream open does not block on this fetch.
+            asyncio.get_running_loop().create_task(
+                _prefetch_ice_config(device_client)
+            )
         # NOTE: no LAN-broadcast discovery here.  For APK parity, the camera's LAN
         # IP comes from the WebRTC signaling host candidate (iceCandidateReq), which
         # the camera advertises and we add verbatim - the official app does the same
@@ -392,6 +443,8 @@ class AidotClient:
         self._device_clients.clear()
 
     async def async_cleanup(self) -> None:
+        if self._refresh_task and not self._refresh_task.done():
+            self._refresh_task.cancel()
         for client in self._device_clients.values():
             await client.close()
         self._device_clients.clear()

{python_aidot_cameras-0.5.10 → python_aidot_cameras-0.5.12}/src/aidot/device_client.py

@@ -2898,9 +2898,12 @@ class DeviceClient(object):
         cb = self._token_refresh_cb
         if cb is None:
             return False
-        # A fresh token invalidates the cached smarthome auth / MQTT URL.
+        # A fresh token invalidates the cached smarthome auth / MQTT URL and
+        # any cached ICE/TURN config (credentials are bound to the access token).
         self._smarthome_auth = None
         self._mqtt_url = None
+        self._cached_ice_config = None
+        self._ice_config_fetched_at = 0.0
         try:
             return bool(await cb())
         except Exception as exc:  # noqa: BLE001
@@ -3701,7 +3704,8 @@ class DeviceClient(object):
         smarthome_auth = await self._async_get_smarthome_auth()
         mqtt_user = (smarthome_auth or {}).get("mqttUser") or str(self.user_id)
         mqtt_pwd  = (smarthome_auth or {}).get("mqttPassword") or ""
-        client_id = (self._user_info.get("mqttClientId") or f"app-{mqtt_user}")
+        _base_cid = (self._user_info.get("mqttClientId") or f"app-{mqtt_user}")
+        client_id = f"{_base_cid}-cmd"
         user_id   = self.user_id
         device_id = self.device_id
 
@@ -6214,6 +6218,21 @@ class DeviceClient(object):
                     "AIDOT_FAST_CONNECT: skipping getIceConfigResp wait"
                     " (~2.5s) - STUN/host candidates only, LAN-direct"
                 )
+            # Second livePlayResp check: catches late rejections that arrived
+            # while we were waiting for ice_config (fast-ICE + slow-reject path).
+            if not _fast_connect and liveplay_resp_fut.done():
+                try:
+                    _lp_resp2 = liveplay_resp_fut.result()
+                    _lp_code2 = int(_lp_resp2.get("code", 200))
+                    _lp_on2   = int(_lp_resp2.get("livePlay", 1))
+                    if _lp_code2 not in (0, 200) or _lp_on2 == 0:
+                        raise RuntimeError(
+                            f"livePlay rejected by camera (code={_lp_code2}, livePlay={_lp_on2})"
+                        )
+                except RuntimeError:
+                    raise
+                except Exception:
+                    pass
 
         # ------------------------------------------------------------------ #
         # Branch: SDES-SRTP cameras use ffmpeg; DTLS cameras use aiortc
@@ -11911,39 +11930,48 @@ class DeviceClient(object):
             # promptly after stream_source() returns; PLI re-arms an IDR so a
             # late consumer still gets decodable frames within ~5 s.
             #
-            # Audio MUST be transcoded: the camera sends G.711 PCMA (PT=8), which
-            # MPEG-TS cannot carry as a recognized stream - a raw `-c copy` writes
-            # it as an undecodable private-data stream and the player plays video
-            # with NO sound.  Transcode PCMA->AAC@48k (matching the DTLS serve's
-            # mux), `-c:v copy` the H.264 untouched.
-            #
-            # `volume`: this camera's PCMA mic runs hot (validated live: "a bit
-            # too loud" vs the -15 dBFS the DTLS AGC targets).  Trim with a
-            # STATELESS `volume` filter (per-sample gain, no look-ahead/buffer) -
-            # safe on the real-time RTP->mpegts serve, unlike the dynamic
-            # normalizers (dynaudnorm/loudnorm) whose buffering broke the DTLS
-            # pipe path.  Env-tunable; default -8 dB.  (SDES has no adaptive AGC
-            # like DTLS's PyAV mux - that lives in numpy on decoded samples and
-            # isn't reusable in this ffmpeg-only serve.)
+            # VIDEO-ONLY BY DEFAULT (the AAC audio transcode was DEADLOCKING the
+            # serve under loss; root-caused live 2026-06-08).  The mpegts muxer
+            # cannot write its PAT/PMT until every mapped output stream has
+            # produced a first packet.  `-c:v copy` knows the H.264 params from
+            # the input SDP immediately, but `-c:a aac` must ENCODE a first AAC
+            # frame, which needs real PCMA samples.  On a battery camera over a
+            # weak uplink the PCMA (PT=8) audio arrives sparse/late, the encoder
+            # yields "No filtered frames for output stream", the PMT is never
+            # written, and the consumer (go2rtc/HA) receives ZERO bytes -> the
+            # dashboard spins forever with no error and no timeout.  Proven by a
+            # serve-path A/B: production AAC config -> 0 bytes; `-an` -> 3.8 MB /
+            # 408 frames / 10 IDRs in 25 s.  (`-max_interleave_delta 0` does NOT
+            # rescue it - the block is the PMT, not interleaving.)  So drop audio
+            # by default and let video flow; the H.264 is `-c:v copy` untouched.
             #
-            # (NOTE: `-max_interleave_delta 0` was tried here to keep AAC-encode
-            # latency from holding video back, but it made the mpegts muxer flush
-            # audio with gaps -> repeating ~100 ms audio CUTOUTS (validated live).
-            # Reverted to the default interleave; video stutter is handled by the
-            # bounded startup-PLI burst instead, not by starving the muxer.)
-            try:
-                _sdes_gain_db = float(
-                    os.environ.get("AIDOT_SDES_AUDIO_GAIN_DB", "-8")
-                )
-            except (ValueError, TypeError):
-                _sdes_gain_db = -8.0
-            dest_args = [
-                "-c:v", "copy",
-                "-af", f"volume={_sdes_gain_db}dB",
-                "-c:a", "aac", "-ar", "48000", "-b:a", "128k",
-                "-f", "mpegts", "-listen", "1",
-                rtsp_push_url,
-            ]
+            # Opt back into audio with AIDOT_SDES_SERVE_AUDIO=1 (e.g. a strong-
+            # signal/mains camera where PCMA arrives densely enough to keep the
+            # AAC encoder fed).  When enabled: transcode PCMA->AAC@48k with a
+            # STATELESS `volume` trim (the mic runs hot; default -8 dB, env-tunable
+            # via AIDOT_SDES_AUDIO_GAIN_DB).  Dynamic normalizers (dynaudnorm/
+            # loudnorm) and `-max_interleave_delta 0` are avoided - both regressed
+            # the pipe (buffering / ~100 ms audio cutouts) in earlier live tests.
+            if os.environ.get("AIDOT_SDES_SERVE_AUDIO", "0") == "1":
+                try:
+                    _sdes_gain_db = float(
+                        os.environ.get("AIDOT_SDES_AUDIO_GAIN_DB", "-8")
+                    )
+                except (ValueError, TypeError):
+                    _sdes_gain_db = -8.0
+                dest_args = [
+                    "-c:v", "copy",
+                    "-af", f"volume={_sdes_gain_db}dB",
+                    "-c:a", "aac", "-ar", "48000", "-b:a", "128k",
+                    "-f", "mpegts", "-listen", "1",
+                    rtsp_push_url,
+                ]
+            else:
+                dest_args = [
+                    "-c:v", "copy", "-an",
+                    "-f", "mpegts", "-listen", "1",
+                    rtsp_push_url,
+                ]
         elif rtsp_push_url:
             # Legacy PUSH model: publish to an RTSP server (e.g. go2rtc at :8554).
             # Requires the stream to be pre-registered in go2rtc; retained for

{python_aidot_cameras-0.5.10 → python_aidot_cameras-0.5.12/src/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.5.10
+Version: 0.5.12
 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