python-aidot-cameras 0.6.0__tar.gz → 0.7.1__tar.gz

{python_aidot_cameras-0.6.0/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.7.1}/PKG-INFO

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

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

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.7.1}/src/aidot/camera/client.py

@@ -17,6 +17,7 @@ from typing import Any, Callable, List, Optional
 
 from ..aes_utils import aes_encrypt, aes_decrypt, aes_ecb_encrypt_str_key, aes_ecb_decrypt_str_key
 from ..exceptions import AidotCameraBusy
+from ..login_const import APP_ID as _AIDOT_APP_ID
 from ..const import (
     CONF_AES_KEY,
     CONF_ASCNUMBER,
@@ -49,12 +50,28 @@ _LOGGER = logging.getLogger(__name__)
 # Runtime import: device_client defines these classes BEFORE importing this
 # module (the package __init__ loads aidot.device_client first), so the
 # partially-initialized module already exposes them here.
-from ..device_client import DeviceStatusData, DeviceInformation
+try:
+    from ..device_client import DeviceStatusData, DeviceInformation
+except ImportError as _exc:  # pragma: no cover - ordering contract violation
+    raise ImportError(
+        "aidot.camera.client must be imported via aidot.device_client "
+        "(import aidot first); keep the camera import block in "
+        "device_client.py below the DeviceStatusData/DeviceInformation "
+        "definitions"
+    ) from _exc
 
 
 class CameraStatusData(DeviceStatusData):
     """Core status plus camera fields; accepts both typed-model and dict updates."""
 
+    # Restore None-as-unknown semantics: the core defaults (red/2700K/100)
+    # would otherwise be pushed to consumers as real state before the first
+    # getDevAttrReq reply arrives.
+    rgdb: "int | None" = None
+    rgbw: "tuple[int, int, int, int] | None" = None
+    cct: "int | None" = None
+    dimming: "int | None" = None
+
     # Camera-specific fields (None = unknown/not yet queried)
     motion_detection: Optional[bool] = None
     motion_sensitivity: Optional[int] = None  # MotionDetection_Sen 1-5
@@ -76,23 +93,16 @@ class CameraStatusData(DeviceStatusData):
             return
         if not isinstance(attr, dict):
             # Typed DeviceAttr model from the core local-control receive path.
+            # Guard: a malformed payload.attr (non-dict, non-model) must not
+            # kill the caller's receive loop.
+            if not hasattr(attr, "OnOff"):
+                return
             super().update(attr)
             return
-        # Dict path (camera attribute / cloud-properties payloads).
-        if attr.get(CONF_ON_OFF) is not None:
-            self.on = attr.get(CONF_ON_OFF)
-        if attr.get(CONF_DIMMING) is not None:
-            self.dimming = int(attr.get(CONF_DIMMING) * 255 / 100)
-        if attr.get(CONF_RGBW) is not None:
-            self.rgdb = attr.get(CONF_RGBW)
-            rgbw = ctypes.c_uint32(self.rgdb).value
-            r = (rgbw >> 24) & 0xFF
-            g = (rgbw >> 16) & 0xFF
-            b = (rgbw >> 8) & 0xFF
-            w = rgbw & 0xFF
-            self.rgbw = (r, g, b, w)
-        if attr.get(CONF_CCT) is not None:
-            self.cct = attr.get(CONF_CCT)
+        # Dict path: camera attributes ONLY.  Light keys (OnOff/Dimming/RGBW/
+        # CCT) are handled by the typed-model path in the core; the dict
+        # feeders either strip them (update_from_camera_attributes) or have
+        # already applied them via the model (receive_data raw-dict pass).
         # Camera attributes
         if (v := attr.get("MotionDetection_Enable")) is not None:
             self.motion_detection = bool(int(v))
@@ -2675,15 +2685,36 @@ def _ip_looks_ascii_garbled(ip_str) -> bool:
 class CameraMixin:
     """All camera/streaming methods, mixed into DeviceClient via inheritance."""
 
+    # Devices without an aesKey never get this set by the core constructor;
+    # default it so get_send_packet and friends see None instead of raising.
+    aes_key = None
+
+    # Optional LAN control client; when attached, attribute writes go local-first.
+    _lan_client = None
+
+    def attach_lan_client(self, lan_client) -> None:
+        """Route camera attribute writes through ``lan_client`` (local-first,
+        cloud-fallback).  Pass an ``aidot.camera.lan_control.CameraLanClient``."""
+        self._lan_client = lan_client
+
+    def detach_lan_client(self) -> None:
+        self._lan_client = None
+
     def _init_camera_state(self, device: dict, user_info: dict) -> None:
         """Camera-side state init, called once at the end of DeviceClient.__init__.
 
         Everything camera-specific that the upstream constructor does not set
         lives here, so the core __init__ body stays aligned with upstream.
         """
-        # Swap in the camera-aware status/info supersets created by the core.
+        # Swap in the camera-aware status/info supersets created by the core,
+        # carrying forward anything the core constructor seeded into the
+        # originals so upstream-added seeding cannot be lost silently.
+        _core_status, _core_info = self.status, self.info
         self.status = CameraStatusData()
+        self.status.__dict__.update(_core_status.__dict__)
         self.info = CameraDeviceInformation(device)
+        for _k, _v in _core_info.__dict__.items():
+            self.info.__dict__.setdefault(_k, _v)
         # livePlayReq dseq - app parity (Q0(): starts at 100, increments per
         # request).  Camera tracks the live-play sequence; 0 is not a valid seq.
         self._live_dseq = 100
@@ -2702,9 +2733,7 @@ class CameraMixin:
         self._token_refresh_cb: "Optional[Callable]" = None
         # Raw device dict retained for transport-type detection (isDTLS field)
         self._raw_device: dict = device
-        # Devices without an aesKey never set this in the core constructor.
-        if not hasattr(self, "aes_key"):
-            self.aes_key = None
+
         # Seed camera/diagnostic status from the cloud device "properties" payload
         # (Battery_remaining, Occupancy, SDcardStatus, MotionDetection_*, …).  This
         # is the authoritative, always-current source the official app itself reads
@@ -3169,7 +3198,7 @@ class CameraMixin:
         token = (self._user_info.get("accessToken")
                  or self._user_info.get("access_token") or "")
         return {
-            "Appid":        "1383974540041977857",
+            "Appid":        _AIDOT_APP_ID,
             "Token":        token,
             "Terminal":     "app",
             "Content-Type": "application/json",
@@ -3483,10 +3512,22 @@ class CameraMixin:
         we add it ourselves.  onlyPubAck=false means camera sends
         setDevAttrResp matched by seq.  _mqtt_device_cmd sends a
         lowPowerActiveStateReq wake signal before this command.
+        Local-first: if a LAN control client is attached (see
+        :meth:`attach_lan_client`) and reachable, the attribute is set over the
+        LAN and the cloud round-trip is skipped; any LAN failure falls through to
+        the MQTT path below.
         """
         import json as _json
         import random as _random
 
+        lan = getattr(self, "_lan_client", None)
+        if lan is not None:
+            try:
+                if await lan.async_set_attributes({attr: value}):
+                    return True
+            except Exception as _exc:  # noqa: BLE001 - any LAN error -> cloud fallback
+                _LOGGER.debug("LAN set %s failed (%s); falling back to cloud", attr, _exc)
+
         device_id = self.device_id
         user_id   = self.user_id
         # camera's local password (from device API dict 'password' field)

python_aidot_cameras-0.7.1/src/aidot/camera/lan_control.py

@@ -0,0 +1,311 @@
+"""Offline LAN device-control for AiDot cameras.
+
+This is the **control plane only** — settings, toggles, PTZ-adjacent attributes and
+status — over the camera's local TCP:10000 channel.  It does NOT do video; video is
+WebRTC (``liveType=2``) and stays cloud-MQTT-signaled.
+
+Design constraints (validated against LK.IPC.A000088 firmware):
+
+* The control channel speaks the lights' local protocol: an 8-byte header
+  (``magic 0x1EED`` + ``msgtype:int16`` + ``bodysize:int32``) followed by an
+  AES-ECB-encrypted JSON body, keyed by the device's 16-char ``aesKey``.
+* It is **single-session**: a second ``loginReq`` evicts the first.  So this client
+  never holds a socket open — every operation is a short-lived
+  *connect → login → command(s) → close*, serialized by a per-camera lock.
+* The camera acks changes with ``setDevAttrResp`` but emits no ``setDevAttrNotif``,
+  so there is no push; status is obtained by polling :meth:`async_get_attributes`.
+* Only cameras that advertise ``localCtrFlag == 1`` on unicast discovery AND are
+  mains-powered are eligible.  Battery models sleep and do not answer unicast.
+
+Credentials (``aesKey`` + ``password``) come from the cloud device dict once and are
+stable per device; cache them and this client runs with no cloud contact.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import socket
+import struct
+import time
+from datetime import datetime
+from typing import Any, Optional
+
+from ..aes_utils import aes_encrypt, aes_decrypt
+
+_LOGGER = logging.getLogger(__name__)
+
+_CONTROL_PORT = 10000
+_DISCOVER_PORT = 6666
+_MAGIC = 0x1EED
+# Well-known AES key for the unprovisioned discovery exchange (lights + cameras),
+# zero-padded to 32 bytes.  Matches aidot.discover.BroadcastProtocol.
+_DISCOVER_KEY = bytearray(b"T54uednca587".ljust(32, b"\x00"))
+
+# Camera attribute keys that are safe, mains-relevant device-control toggles.
+# (Maps a friendly name -> on-the-wire attr key.)
+ATTR_KEYS = {
+    "status_led": "LedOnOff",
+    "motion_detection": "MotionDetection_Enable",
+    "motion_sensitivity": "MotionDetection_Sen",
+    "night_vision_mode": "nightVisionMode",
+    "ir_light": "nightVisionIRLight",
+    "microphone": "micEnable",
+    "speaker_volume": "SoundLevel",
+    "ptz_tracking": "trackingMode",
+    "floodlight": "LightOnOff",
+    "siren": "sirenRing",
+}
+
+
+def _pack(msgtype: int, body: bytes) -> bytes:
+    return struct.pack(">Hhi", _MAGIC, msgtype, len(body)) + body
+
+
+async def _read_frame(reader: asyncio.StreamReader, timeout: float) -> dict:
+    """Read one 8-byte-header AES frame; return the decoded JSON dict."""
+    header = await asyncio.wait_for(reader.readexactly(8), timeout)
+    _magic, _mtype, bodysize = struct.unpack(">HHI", header)
+    body = await asyncio.wait_for(reader.readexactly(bodysize), timeout)
+    return body  # caller decrypts (key is on the client)
+
+
+async def discover_unicast(ip: str, timeout: float = 2.0) -> Optional[dict]:
+    """Send a unicast ``devDiscoveryReq`` to ``ip`` and return the reply payload.
+
+    Cameras ignore the broadcast sweep but answer a unicast probe.  Returns the
+    ``payload`` dict (``devId``, ``mac``, ``productModel``, ``lanMode``,
+    ``localCtrFlag`` …) or ``None`` if nothing answered.
+    """
+    msg = {
+        "protocolVer": "2.0.0",
+        "service": "device",
+        "method": "devDiscoveryReq",
+        "seq": str(int(time.time() * 1000))[-9:],
+        "srcAddr": "0.lan",
+        "tst": int(time.time() * 1000),
+        "payload": {"extends": {}, "localCtrFlag": 1,
+                    "timestamp": str(int(time.time() * 1000))},
+    }
+    enc = aes_encrypt(json.dumps(msg).encode(), _DISCOVER_KEY)
+
+    loop = asyncio.get_running_loop()
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.setblocking(False)
+    try:
+        await loop.sock_sendto(sock, enc, (ip, _DISCOVER_PORT))
+        try:
+            data = await asyncio.wait_for(loop.sock_recv(sock, 8192), timeout)
+        except asyncio.TimeoutError:
+            return None
+        try:
+            return json.loads(aes_decrypt(data, _DISCOVER_KEY)).get("payload")
+        except Exception:  # noqa: BLE001 - undecodable / foreign packet
+            return None
+    finally:
+        sock.close()
+
+
+def _local_ipv4() -> Optional[str]:
+    """Best-effort primary IPv4 of this host (no traffic sent)."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(("192.0.2.1", 9))  # TEST-NET-1; just selects an interface
+        return s.getsockname()[0]
+    except OSError:
+        return None
+    finally:
+        s.close()
+
+
+async def discover_subnet(cidr24: Optional[str] = None, timeout: float = 3.0,
+                          concurrency: int = 64) -> dict[str, str]:
+    """Unicast-sweep a /24 and return ``{devId: ip}`` for every camera that answers.
+
+    Cameras ignore the broadcast discovery sweep but answer a unicast probe, so the
+    only way to map a camera's devId to its LAN IP locally is to probe each host.
+    ``cidr24`` is the first three octets (e.g. ``"192.168.1"``); if omitted it is
+    derived from this host's primary IPv4.  Cheap (254 UDP probes, ~timeout wall).
+    """
+    if cidr24 is None:
+        ip = _local_ipv4()
+        if not ip:
+            return {}
+        cidr24 = ip.rsplit(".", 1)[0]
+
+    sem = asyncio.Semaphore(concurrency)
+    found: dict[str, str] = {}
+
+    async def probe(host: str) -> None:
+        async with sem:
+            payload = await discover_unicast(host, timeout=timeout)
+        if payload and payload.get("devId"):
+            found[payload["devId"]] = host
+
+    await asyncio.gather(*(probe(f"{cidr24}.{n}") for n in range(1, 255)))
+    return found
+
+
+class CameraLanError(Exception):
+    """A local control operation failed (connect, login, or protocol error)."""
+
+
+class CameraLanClient:
+    """Short-lived local device-control client for one camera.
+
+    Build from the cloud device dict + login info; optionally pass a known LAN ``ip``
+    (otherwise call :meth:`async_resolve` to unicast-discover it).  All control calls
+    are serialized and each opens/closes its own socket.
+    """
+
+    def __init__(self, device: dict[str, Any], user_info: dict[str, Any],
+                 ip: Optional[str] = None) -> None:
+        self.device_id: str = device.get("id") or device.get("devId")
+        _aes = device.get("aesKey") or []
+        key_str = _aes[0] if isinstance(_aes, list) and _aes else (_aes or "")
+        if not key_str:
+            raise CameraLanError(f"{self.device_id}: no aesKey in device dict")
+        self._key = bytearray(16)
+        kb = key_str.encode()
+        self._key[: len(kb)] = kb
+        self._password = device.get("password") or ""
+        self._user_id = user_info.get("id")
+        self._model_id = device.get("modelId") or ""
+        self._ip = ip
+        self._lock = asyncio.Lock()           # single in-flight session per camera
+        self._eligible: Optional[bool] = None  # set by async_resolve
+
+    # -- discovery / eligibility ------------------------------------------- #
+
+    @property
+    def ip(self) -> Optional[str]:
+        return self._ip
+
+    @property
+    def eligible(self) -> Optional[bool]:
+        """True/False once resolved, else None.  Eligible = local control advertised
+        and the device is mains-powered (battery models excluded)."""
+        return self._eligible
+
+    async def async_resolve(self, ip: Optional[str] = None) -> bool:
+        """Unicast-discover the camera (at ``ip`` or the configured ip) and gate
+        eligibility on ``localCtrFlag``.  Returns True if locally controllable."""
+        ip = ip or self._ip
+        if ip is None:
+            self._eligible = False
+            return False
+        payload = await discover_unicast(ip)
+        if not payload or payload.get("devId") != self.device_id:
+            self._eligible = False
+            return False
+        self._ip = ip
+        # localCtrFlag==1 / lanMode==1 advertise local control.  Battery gating is
+        # confirmed separately on the first getDevAttr (battery_remaining is None).
+        self._eligible = bool(payload.get("localCtrFlag")) or bool(payload.get("lanMode"))
+        return self._eligible
+
+    # -- low-level session ------------------------------------------------- #
+
+    async def _session(self, messages):
+        """Open one short-lived session, send each built message, collect replies.
+
+        ``messages`` is a callable ``(user_id, ascNumber) -> list[(msgtype, dict)]``
+        built after login so it can use the camera's ascNumber.  Returns the list of
+        decoded reply dicts (excluding the login response).
+        """
+        if self._ip is None:
+            raise CameraLanError(f"{self.device_id}: no LAN ip (call async_resolve)")
+        async with self._lock:
+            try:
+                reader, writer = await asyncio.wait_for(
+                    asyncio.open_connection(self._ip, _CONTROL_PORT), timeout=5.0
+                )
+            except (OSError, asyncio.TimeoutError) as exc:
+                raise CameraLanError(f"{self.device_id}: connect failed: {exc}") from exc
+            try:
+                asc = await self._login(reader, writer)
+                replies = []
+                for msgtype, body_obj in messages(self._user_id, asc):
+                    writer.write(_pack(msgtype, aes_encrypt(
+                        json.dumps(body_obj).encode(), self._key)))
+                    await writer.drain()
+                    # The camera may emit an intermediate frame before the
+                    # ``*Resp`` (e.g. a status echo before ``setDevAttrResp``), so
+                    # drain until a response method arrives or the read times out.
+                    for _ in range(4):
+                        try:
+                            raw = await _read_frame(reader, timeout=4.0)
+                        except (asyncio.TimeoutError, asyncio.IncompleteReadError):
+                            break
+                        frame = json.loads(aes_decrypt(raw, self._key))
+                        replies.append(frame)
+                        if str(frame.get("method", "")).endswith("Resp"):
+                            break
+                return replies
+            finally:
+                writer.close()
+                try:
+                    await writer.wait_closed()
+                except Exception:  # noqa: BLE001
+                    pass
+
+    async def _login(self, reader, writer) -> int:
+        seq = str(int(time.time() * 1000))[-9:]
+        msg = {
+            "service": "device", "method": "loginReq", "seq": seq,
+            "srcAddr": self._user_id, "deviceId": self.device_id,
+            "payload": {"userId": self._user_id, "password": self._password,
+                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S.000"),
+                        "ascNumber": 1},
+        }
+        writer.write(_pack(1, aes_encrypt(json.dumps(msg).encode(), self._key)))
+        await writer.drain()
+        resp = json.loads(aes_decrypt(await _read_frame(reader, timeout=8.0), self._key))
+        ack = (resp.get("ack") or {}).get("code")
+        if ack != 200:
+            raise CameraLanError(f"{self.device_id}: login rejected ack={ack}")
+        return (resp.get("payload") or {}).get("ascNumber", 1)
+
+    # -- public control ---------------------------------------------------- #
+
+    async def async_get_attributes(self) -> dict:
+        """Poll the full device attribute set over a short-lived session."""
+        def build(uid, asc):
+            return [(1, {"method": "getDevAttrReq", "service": "device",
+                         "clientId": "ha-" + uid, "srcAddr": "0." + uid,
+                         "seq": "g" + str(int(time.time() * 1000))[-9:],
+                         "payload": {"devId": self.device_id, "parentId": self.device_id,
+                                     "userId": uid, "password": self._password,
+                                     "attr": [], "channel": "tcp", "ascNumber": asc},
+                         "tst": int(time.time() * 1000), "deviceId": self.device_id})]
+        replies = await self._session(build)
+        return (replies[0].get("payload") or {}).get("attr") or {}
+
+    async def async_set_attributes(self, attr: dict) -> bool:
+        """Apply ``attr`` (on-the-wire keys, e.g. ``{"LedOnOff": 1}``) locally.
+
+        Returns True on a ``setDevAttrResp`` ack.  Raises CameraLanError on failure.
+        """
+        def build(uid, asc):
+            return [(1, {"method": "setDevAttrReq", "service": "device",
+                         "clientId": "ha-" + uid, "srcAddr": "0." + uid,
+                         "seq": "s" + str(int(time.time() * 1000))[-9:],
+                         "payload": {"devId": self.device_id, "parentId": self.device_id,
+                                     "userId": uid, "password": self._password,
+                                     "attr": attr, "channel": "tcp", "ascNumber": asc},
+                         "tst": int(time.time() * 1000), "deviceId": self.device_id})]
+        replies = await self._session(build)
+        return any(r.get("method") == "setDevAttrResp" for r in replies)
+
+    async def async_set(self, friendly: str, value: Any) -> bool:
+        """Set a single attribute by friendly name (see ``ATTR_KEYS``)."""
+        if friendly not in ATTR_KEYS:
+            raise CameraLanError(f"unknown control attribute: {friendly}")
+        return await self.async_set_attributes({ATTR_KEYS[friendly]: value})
+
+    @staticmethod
+    def is_mains_powered(attrs: dict) -> bool:
+        """Battery gating: cameras that report no battery level are mains-powered
+        (the eligible class).  Call with the dict from :meth:`async_get_attributes`."""
+        return attrs.get("Battery_remaining") is None

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.7.1}/src/aidot/client.py

@@ -58,6 +58,14 @@ def rsa_password_encrypt(message: str) -> str:
 
 
 
+def _is_camera(device_client: "DeviceClient") -> bool:
+    """Cameras get their LAN IP from WebRTC signaling, never from the UDP
+    sweep; pushing a discovered IP would trigger light-protocol logins on
+    TCP:10000 (which can hang - the camera accepts but never answers)."""
+    model = getattr(getattr(device_client, "info", None), "model_id", "") or ""
+    return "IPC" in model
+
+
 async def _prefetch_ice_config(dc: "DeviceClient") -> None:
     """Background task: warm the HTTP ICE config cache for a device."""
     try:
@@ -157,7 +165,11 @@ class AidotClient:
     def update_password(self, password: str) -> None:
         self.password = password
 
+    _terminal_id: "Optional[str]" = None
+
     async def get_terminal_id(self) -> str:
+        if self._terminal_id is not None:
+            return self._terminal_id
         file_path = Path.home() / ".aidot_terminal_id"
 
         def _read_or_create() -> str:
@@ -173,7 +185,8 @@ class AidotClient:
                 return 'gvz3gjae10l4zii00t7y0'
 
         raw_id = await asyncio.to_thread(_read_or_create)
-        return hashlib.md5(raw_id.encode()).hexdigest()
+        self._terminal_id = hashlib.md5(raw_id.encode()).hexdigest()
+        return self._terminal_id
 
     async def async_post_login(self) -> dict[str, Any]:
         """Login via loginWithFreeVerification (RSA-encrypted password)."""
@@ -456,11 +469,15 @@ class AidotClient:
             asyncio.get_running_loop().create_task(
                 _prefetch_ice_config(device_client)
             )
+        # Started lazily here as well: __init__ cannot start discovery when
+        # constructed outside a running event loop (stored-token sync path).
+        if self._discover is None:
+            self.setup_discover()
         # Lights get their LAN IP from UDP discovery.  Cameras do NOT use the
         # broadcast sweep: their LAN IP comes from the WebRTC signaling host
         # candidate (iceCandidateReq), which the camera advertises and we add
         # verbatim - the official app does the same.
-        if self._discover is not None:
+        if self._discover is not None and not _is_camera(device_client):
             ip = self._discover.discovered_device.get(device_id)
             device_client.update_ip_address(ip)
         return device_client
@@ -481,7 +498,7 @@ class AidotClient:
         def _discover_callback(dev_id, event: dict[str, str]) -> None:
             device_ip = event[CONF_IPADDRESS]
             device_client: DeviceClient = self._device_clients.get(dev_id)
-            if device_client is not None:
+            if device_client is not None and not _is_camera(device_client):
                 device_client.update_ip_address(device_ip)
 
         try:
@@ -493,6 +510,8 @@ class AidotClient:
 
     async def async_close(self) -> None:
         """Close the client and release resources."""
+        if self._refresh_task and not self._refresh_task.done():
+            self._refresh_task.cancel()
         if self._discover is not None:
             self._discover.close()
             self._discover = None
@@ -501,14 +520,8 @@ class AidotClient:
         self._device_clients.clear()
 
     def cleanup(self) -> None:
-        if self._discover is not None:
-            self._discover.close()
-            self._discover = None
-        for client in self._device_clients.values():
-            asyncio.get_running_loop().create_task(client.close())
-        self._device_clients.clear()
+        """Sync entry point: fire-and-forget async_close()."""
+        asyncio.get_running_loop().create_task(self.async_close())
 
     async def async_cleanup(self) -> None:
-        if self._refresh_task and not self._refresh_task.done():
-            self._refresh_task.cancel()
         await self.async_close()

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.7.1}/src/aidot/const.py

@@ -233,8 +233,9 @@ class ServerErrorCode(IntEnum):
 
 # ── Cloud API credentials ──────────────────────────────────────────────────── #
 
-APP_ID = "1383974540041977857"
-BASE_URL = "https://prod-us-api.arnoo.com/v17"
+from .login_const import APP_ID, PUBLIC_KEY_PEM  # noqa: E402 - back-compat re-export
+from .login_const import API_URL_TEMPLATE as _API_URL_TEMPLATE, DEFAULT_REGION as _DEFAULT_REGION  # noqa: E402
+BASE_URL = _API_URL_TEMPLATE.format(region=_DEFAULT_REGION)
 
 PUBLIC_KEY_PEM = b"""-----BEGIN PUBLIC KEY-----
 MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCtQAnPCi8ksPnS1Du6z96PsKfN

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.7.1}/src/aidot/device_client.py

@@ -201,6 +201,9 @@ class DeviceClient(CameraMixin, object):
             sock: socket.socket = self.writer.get_extra_info("socket")
             sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
             self.seq_num = 1
+            # Cloud polls may have seeded status.online; the gate below must
+            # reflect this TCP login only.
+            self.status.online = False
             await self.login()
             self._connect_and_login = self.status.online
         except Exception as e:
@@ -322,6 +325,9 @@ class DeviceClient(CameraMixin, object):
                     self.ascNumber = response.payload.ascNumber
                 if response.payload.attr:
                     self.status.update(response.payload.attr)
+                    # Camera/floodlight keys are not in the typed DeviceAttr
+                    # model; pass the raw dict so they are not dropped.
+                    self.status.update((json_data.get(CONF_PAYLOAD) or {}).get(CONF_ATTR))
                     self._notify_status_update()
     
     def _schedule_ping(self):
@@ -436,13 +442,29 @@ class DeviceClient(CameraMixin, object):
 
     async def close(self) -> None:
         self._is_close = True
+        if self._login_task is not None and not self._login_task.done():
+            self._login_task.cancel()
         await self.async_stop_streaming()
         await self.reset()
         _LOGGER.info(f"{self.device_id} connect close by user")
 
+    _last_login_attempt: float = 0.0
+
     def _schedule_reconnect(self) -> None:
         """延迟重连"""
+        if self._is_close:
+            return
+        if self._reconnect_handle is not None:
+            return  # a reconnect chain is already armed
         _LOGGER.info(f"{self.device_id} _schedule_reconnect")
         loop = asyncio.get_running_loop()
-        self._reconnect_handle = loop.call_later(60, self._schedule_reconnect)
+        self._reconnect_handle = loop.call_later(60, self._reconnect_fire)
+        now = time.monotonic()
+        if now - self._last_login_attempt < 30:
+            return  # too soon after the last attempt; the timer above retries
+        self._last_login_attempt = now
         self._login_task = asyncio.create_task(self.async_login())
+
+    def _reconnect_fire(self) -> None:
+        self._reconnect_handle = None
+        self._schedule_reconnect()

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.7.1}/src/aidot/discover.py

@@ -14,7 +14,6 @@ from .exceptions import AidotOSError
 from .models.discover_model import DiscoverResponse, DiscoverRequest
 
 _LOGGER = logging.getLogger(__name__)
-_DISCOVER_TIME = 5      # legacy repeat_broadcast() loop interval (seconds)
 _DISCOVER_FAST = 6      # fast discovery cadence right after startup
 _DISCOVER_SLOW = 120    # slow maintenance cadence once stable
 
@@ -141,13 +140,16 @@ class Discover:
         self._login_info = login_info
         self._callback = callback
         self._protocols: List[BroadcastProtocol] = []
+        self._is_close = False
+        self._broadcast_task: "asyncio.Task | None" = None
 
     async def _ensure_sockets(self) -> None:
         """Create one datagram endpoint per active interface (idempotent)."""
-        if self._protocols:
+        if self._is_close or self._protocols:
             return
 
-        candidates = _get_broadcast_candidates()
+        # subprocess-based interface enumeration must not block the loop
+        candidates = await asyncio.to_thread(_get_broadcast_candidates)
         user_id = self._login_info[CONF_ID]
 
         for bind_ip, broadcast_ip in candidates:
@@ -192,15 +194,6 @@ class Discover:
         for proto in self._protocols:
             proto.send_broadcast()
 
-    async def repeat_broadcast(self) -> None:
-        self._is_close = False
-        while True:
-            await self.send_broadcast()
-            for _ in range(_DISCOVER_TIME):
-                await asyncio.sleep(1)
-                if self._is_close:
-                    return
-
     def start_repeat_broadcast(self) -> None:
         """Timer-driven discovery: a few fast rounds at startup, then slow."""
         self._is_close = False
@@ -208,6 +201,8 @@ class Discover:
         self._schedule_broadcast()
 
     def _schedule_broadcast(self) -> None:
+        if self._is_close:
+            return
         if self._fast_discover_count > 0:
             interval = _DISCOVER_FAST
             self._fast_discover_count -= 1
@@ -215,20 +210,17 @@ class Discover:
             interval = _DISCOVER_SLOW
 
         loop = asyncio.get_running_loop()
-        asyncio.create_task(self._do_broadcast())
+        self._broadcast_task = asyncio.create_task(self._do_broadcast())
         self._timer_handle = loop.call_later(interval, self._schedule_broadcast)
 
     async def _do_broadcast(self) -> None:
+        if self._is_close:
+            return
         try:
             await self.send_broadcast()
         except Exception as e:
             _LOGGER.error(f"Broadcast failed: {e}")
 
-    async def fetch_devices_info(self) -> dict[str, str]:
-        await self.send_broadcast()
-        await asyncio.sleep(2)
-        return self.discovered_device
-
     def _discover_callback(self, dev_id, event: dict[str, str]) -> None:
         self.discovered_device[dev_id] = event[CONF_IPADDRESS]
         if self._callback:
@@ -236,6 +228,8 @@ class Discover:
 
     def close(self) -> None:
         self._is_close = True
+        if self._broadcast_task is not None and not self._broadcast_task.done():
+            self._broadcast_task.cancel()
         if self._timer_handle is not None:
             self._timer_handle.cancel()
             self._timer_handle = None

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.7.1/src/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.6.0
+Version: 0.7.1
 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.6.0 → python_aidot_cameras-0.7.1}/src/python_aidot_cameras.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/aidot/g711.py
 src/aidot/login_const.py
 src/aidot/camera/__init__.py
 src/aidot/camera/client.py
+src/aidot/camera/lan_control.py
 src/aidot/models/__init__.py
 src/aidot/models/device_client_model.py
 src/aidot/models/device_model.py
@@ -24,8 +25,10 @@ src/python_aidot_cameras.egg-info/requires.txt
 src/python_aidot_cameras.egg-info/top_level.txt
 tests/test_alarm_event.py
 tests/test_highport_nomination.py
+tests/test_lan_control.py
 tests/test_motion_poll.py
 tests/test_no_undefined_names.py
+tests/test_post_merge_hardening.py
 tests/test_sdes_idle_release.py
 tests/test_sdes_sprop.py
 tests/test_sdes_talk.py

python_aidot_cameras-0.7.1/tests/test_lan_control.py

@@ -0,0 +1,82 @@
+"""Unit tests for the LAN device-control client (no camera required)."""
+
+import json
+import os
+import struct
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+import pytest
+
+from aidot.aes_utils import aes_decrypt, aes_encrypt
+from aidot.camera.lan_control import (
+    ATTR_KEYS,
+    CameraLanClient,
+    CameraLanError,
+    _local_ipv4,
+    _pack,
+    discover_subnet,
+)
+
+DEVICE = {"id": "dev1", "modelId": "LK.IPC.A000088", "aesKey": ["k" * 16], "password": "pw"}
+USER = {"id": "user1"}
+
+
+def test_pack_header_is_8_bytes_and_well_formed():
+    body = b'{"x":1}'
+    frame = _pack(1, body)
+    assert len(frame) == 8 + len(body)
+    magic, mtype, blen = struct.unpack(">HHI", frame[:8])
+    assert magic == 0x1EED and mtype == 1 and blen == len(body)
+    assert frame[8:] == body
+
+
+def test_construction_derives_16byte_key():
+    c = CameraLanClient(DEVICE, USER, ip="192.0.2.10")
+    assert c.device_id == "dev1"
+    assert len(c._key) == 16 and c._key.startswith(b"k" * 16)
+    assert c.ip == "192.0.2.10"
+    assert c.eligible is None  # not resolved yet
+
+
+def test_construction_requires_aeskey():
+    with pytest.raises(CameraLanError):
+        CameraLanClient({"id": "d", "password": "p"}, USER)
+
+
+def test_friendly_attr_map_round_trips_through_aes():
+    # the keys we expose must encrypt/decrypt cleanly in a setDevAttr body
+    c = CameraLanClient(DEVICE, USER, ip="192.0.2.10")
+    body = {ATTR_KEYS["status_led"]: 1}
+    blob = aes_encrypt(json.dumps(body).encode(), c._key)
+    assert json.loads(aes_decrypt(blob, c._key)) == {"LedOnOff": 1}
+
+
+def test_async_set_rejects_unknown_attr():
+    c = CameraLanClient(DEVICE, USER, ip="192.0.2.10")
+    import asyncio
+    with pytest.raises(CameraLanError):
+        asyncio.run(c.async_set("not_a_real_control", 1))
+
+
+def test_battery_gating():
+    assert CameraLanClient.is_mains_powered({"Battery_remaining": None}) is True
+    assert CameraLanClient.is_mains_powered({"LedOnOff": 0}) is True  # key absent -> mains
+    assert CameraLanClient.is_mains_powered({"Battery_remaining": 87}) is False
+
+
+@pytest.mark.parametrize("friendly,wire", list(ATTR_KEYS.items()))
+def test_attr_keys_are_strings(friendly, wire):
+    assert isinstance(friendly, str) and isinstance(wire, str)
+
+
+def test_network_helpers_are_callable():
+    # Real behaviour is covered by the live smoke test; here just assert the
+    # discovery helpers are importable and have the expected shape (the test
+    # sandbox blocks sockets, so we don't invoke them).
+    import inspect
+    assert callable(_local_ipv4)
+    assert inspect.iscoroutinefunction(discover_subnet)
+    sig = inspect.signature(discover_subnet)
+    assert list(sig.parameters) == ["cidr24", "timeout", "concurrency"]

python_aidot_cameras-0.7.1/tests/test_post_merge_hardening.py

@@ -0,0 +1,178 @@
+"""Regression tests for the post-upstream-sync hardening fixes.
+
+Covers: the connect() login gate, reconnect chain dedup/backoff, discovery
+quiescence after close(), the camera filter on discovered IPs, status
+None-defaults, the dict/model update dispatch, and the DeviceClient/
+CameraMixin name-collision tripwire for future upstream merges.
+"""
+
+import asyncio
+import os
+import sys
+import time
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+import pytest
+
+from aidot.camera.client import CameraMixin, CameraStatusData, CameraDeviceInformation
+from aidot.client import _is_camera
+from aidot.device_client import DeviceClient, DeviceStatusData
+from aidot.discover import Discover
+from aidot.models.device_client_model import DeviceAttr
+
+
+DEVICE = {
+    "id": "dev1",
+    "name": "Test Light",
+    "modelId": "LK.light.A001497",
+    "aesKey": ["k" * 16],
+    "password": "pw",
+    "online": True,
+}
+CAMERA = {**DEVICE, "id": "cam1", "name": "Test Cam", "modelId": "LK.IPC.A000088"}
+USER = {"id": "user1", "region": "us"}
+
+
+def make_dc(device=DEVICE):
+    return DeviceClient(dict(device), dict(USER))
+
+
+# --------------------------------------------------------------------------- #
+# connect() gate
+# --------------------------------------------------------------------------- #
+
+def test_connect_gate_ignores_cloud_seeded_online(monkeypatch):
+    """A swallowed login failure must not report as connected just because
+    the cloud device dict said online=true."""
+    dc = make_dc()
+    dc.status.online = True  # cloud-seeded (update_status_from_device)
+
+    class _W:
+        def get_extra_info(self, _):
+            import socket as _s
+            s = _s.socket()
+            return s
+
+    async def fake_open(*a, **k):
+        return object(), _W()
+
+    async def fake_login(self):
+        return  # login fails silently (exception swallowed inside login())
+
+    monkeypatch.setattr(asyncio, "open_connection", fake_open)
+    monkeypatch.setattr(DeviceClient, "login", fake_login)
+    asyncio.run(dc.connect("127.0.0.1"))
+    assert dc.connect_and_login is False
+
+
+# --------------------------------------------------------------------------- #
+# reconnect chain
+# --------------------------------------------------------------------------- #
+
+def test_schedule_reconnect_single_chain_and_backoff():
+    async def run():
+        dc = make_dc()
+        dc._ip_address = "127.0.0.1"
+        dc._last_login_attempt = time.monotonic()  # recent attempt -> backoff
+
+        dc._schedule_reconnect()
+        first_handle = dc._reconnect_handle
+        assert first_handle is not None
+        assert dc._login_task is None  # backoff floor suppressed immediate login
+
+        dc._schedule_reconnect()  # concurrent reset path
+        assert dc._reconnect_handle is first_handle  # no second chain
+
+        first_handle.cancel()
+
+    asyncio.run(run())
+
+
+def test_schedule_reconnect_noop_after_close():
+    async def run():
+        dc = make_dc()
+        dc._ip_address = "127.0.0.1"
+        dc._is_close = True
+        dc._schedule_reconnect()
+        assert dc._reconnect_handle is None
+
+    asyncio.run(run())
+
+
+# --------------------------------------------------------------------------- #
+# discovery
+# --------------------------------------------------------------------------- #
+
+def test_discover_quiescent_after_close():
+    async def run():
+        d = Discover({"id": "user1"}, None)
+        d.close()
+        await d._do_broadcast()  # in-flight task firing after close
+        await d._ensure_sockets()
+        assert d._protocols == []  # no sockets recreated
+
+    asyncio.run(run())
+
+
+def test_camera_filter():
+    assert _is_camera(make_dc(CAMERA)) is True
+    assert _is_camera(make_dc(DEVICE)) is False
+
+
+# --------------------------------------------------------------------------- #
+# status semantics
+# --------------------------------------------------------------------------- #
+
+def test_status_defaults_are_unknown():
+    s = CameraStatusData()
+    assert s.dimming is None and s.cct is None and s.rgbw is None and s.rgdb is None
+
+
+def test_update_dispatch_model_vs_dict():
+    s = CameraStatusData()
+    s.update(DeviceAttr(OnOff=1, CCT=4000))
+    assert s.on == 1 and s.cct == 4000
+    # dict path: camera keys applied, light keys ignored (model path owns them)
+    s.update({"Battery_remaining": "77", "CCT": 9999})
+    assert s.battery_remaining == 77
+    assert s.cct == 4000
+    # malformed model-path payload must not raise
+    s.update("garbage")
+    s.update(["garbage"])
+
+
+def test_camera_state_carry_forward():
+    """State seeded into the core status object before the camera swap must
+    survive on the replacement object."""
+    dc = make_dc()
+    # simulate: as if the core constructor had seeded state pre-swap
+    core_status = DeviceStatusData()
+    core_status.online = True
+    dc.status = core_status
+    dc._init_camera_state(dict(DEVICE), dict(USER))
+    assert isinstance(dc.status, CameraStatusData)
+    assert dc.status.online is True
+
+
+# --------------------------------------------------------------------------- #
+# upstream-merge tripwire
+# --------------------------------------------------------------------------- #
+
+def test_no_silent_mro_shadowing():
+    """If upstream adds a DeviceClient method whose name CameraMixin already
+    defines, the upstream version silently shadows the camera one after a
+    conflict-free merge.  Keep this intersection explicitly reviewed."""
+    intentional = {
+        # device_client.py deliberately overrides/joins these:
+        "__init__",
+    }
+    # Compare only non-dunder names: interpreter-added dunders vary by
+    # Python version (3.13 adds __firstlineno__/__static_attributes__).
+    core = {n for n in DeviceClient.__dict__ if not n.startswith("__")}
+    camera = {n for n in CameraMixin.__dict__ if not n.startswith("__")}
+    collisions = (core & camera) - intentional
+    assert collisions == set(), (
+        f"DeviceClient now shadows CameraMixin names {sorted(collisions)}; "
+        "verify intent and update this test's allowlist"
+    )