python-aidot-cameras 0.5.11__tar.gz → 0.5.13__tar.gz

{python_aidot_cameras-0.5.11/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.5.13}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.5.11"
+version = "0.5.13"
 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.11 → python_aidot_cameras-0.5.13}/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.11 → python_aidot_cameras-0.5.13}/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
 
@@ -4192,6 +4196,7 @@ class DeviceClient(object):
         self,
         rtsp_push_url: Optional[str] = None,
         fast_connect: Optional[bool] = None,
+        sdes_audio: Optional[bool] = None,
     ) -> None:
         """Start a persistent stream that keeps the camera session alive.
 
@@ -4213,6 +4218,8 @@ class DeviceClient(object):
         """
         if fast_connect is not None:
             self._fast_connect_opt = fast_connect
+        if sdes_audio is not None:
+            self._sdes_audio_opt = sdes_audio
         if self._stream_task is not None and not self._stream_task.done():
             return
         self._keepalive_rtsp_url = rtsp_push_url
@@ -6214,6 +6221,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
@@ -11933,7 +11955,10 @@ class DeviceClient(object):
             # 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":
+            _sdes_audio = getattr(self, "_sdes_audio_opt", None)
+            if _sdes_audio is None:
+                _sdes_audio = os.environ.get("AIDOT_SDES_SERVE_AUDIO", "0") == "1"
+            if _sdes_audio:
                 try:
                     _sdes_gain_db = float(
                         os.environ.get("AIDOT_SDES_AUDIO_GAIN_DB", "-8")

{python_aidot_cameras-0.5.11 → python_aidot_cameras-0.5.13/src/python_aidot_cameras.egg-info}/PKG-INFO

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