Merge remote-tracking branch 'upstream/master' into feat/motion

kasa/smartcam/modules/__init__.py

@@ -1,6 +1,7 @@
 """Modules for SMARTCAM devices."""
 
 from .alarm import Alarm
+from .babycrydetection import BabyCryDetection
 from .camera import Camera
 from .childdevice import ChildDevice
 from .device import DeviceModule
@@ -8,20 +9,25 @@ from .homekit import HomeKit
 from .led import Led
 from .lensmask import LensMask
 from .matter import Matter
-from .motion import Motion
+from .motiondetection import MotionDetection
 from .pantilt import PanTilt
+from .persondetection import PersonDetection
+from .tamperdetection import TamperDetection
 from .time import Time
 
 __all__ = [
     "Alarm",
+    "BabyCryDetection",
     "Camera",
     "ChildDevice",
     "DeviceModule",
     "Led",
     "PanTilt",
+    "PersonDetection",
     "Time",
     "HomeKit",
     "Matter",
-    "Motion",
+    "MotionDetection",
     "LensMask",
+    "TamperDetection",
 ]

kasa/smartcam/modules/babycrydetection.py

@@ -0,0 +1,47 @@
+"""Implementation of baby cry detection module."""
+
+from __future__ import annotations
+
+import logging
+
+from ...feature import Feature
+from ..smartcammodule import SmartCamModule
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class BabyCryDetection(SmartCamModule):
+    """Implementation of baby cry detection module."""
+
+    REQUIRED_COMPONENT = "babyCryDetection"
+
+    QUERY_GETTER_NAME = "getBCDConfig"
+    QUERY_MODULE_NAME = "sound_detection"
+    QUERY_SECTION_NAMES = "bcd"
+
+    def _initialize_features(self) -> None:
+        """Initialize features after the initial update."""
+        self._add_feature(
+            Feature(
+                self._device,
+                id="baby_cry_detection",
+                name="Baby cry detection",
+                container=self,
+                attribute_getter="enabled",
+                attribute_setter="set_enabled",
+                type=Feature.Type.Switch,
+                category=Feature.Category.Primary,
+            )
+        )
+
+    @property
+    def enabled(self) -> bool:
+        """Return the baby cry detection enabled state."""
+        return self.data["bcd"]["enabled"] == "on"
+
+    async def set_enabled(self, enable: bool) -> dict:
+        """Set the baby cry detection enabled state."""
+        params = {"enabled": "on" if enable else "off"}
+        return await self._device._query_setter_helper(
+            "setBCDConfig", self.QUERY_MODULE_NAME, "bcd", params
+        )

kasa/smartcam/modules/device.py

@@ -14,6 +14,13 @@ class DeviceModule(SmartCamModule):
     QUERY_MODULE_NAME = "device_info"
     QUERY_SECTION_NAMES = ["basic_info", "info"]
 
+    def query(self) -> dict:
+        """Query to execute during the update cycle."""
+        q = super().query()
+        q["getConnectionType"] = {"network": {"get_connection_type": []}}
+
+        return q
+
     def _initialize_features(self) -> None:
         """Initialize features after the initial update."""
         self._add_feature(
@@ -26,6 +33,32 @@ class DeviceModule(SmartCamModule):
                 type=Feature.Type.Sensor,
             )
         )
+        if self.rssi is not None:
+            self._add_feature(
+                Feature(
+                    self._device,
+                    container=self,
+                    id="rssi",
+                    name="RSSI",
+                    attribute_getter="rssi",
+                    icon="mdi:signal",
+                    unit_getter=lambda: "dBm",
+                    category=Feature.Category.Debug,
+                    type=Feature.Type.Sensor,
+                )
+            )
+            self._add_feature(
+                Feature(
+                    self._device,
+                    container=self,
+                    id="signal_level",
+                    name="Signal Level",
+                    attribute_getter="signal_level",
+                    icon="mdi:signal",
+                    category=Feature.Category.Info,
+                    type=Feature.Type.Sensor,
+                )
+            )
 
     async def _post_update_hook(self) -> None:
         """Overriden to prevent module disabling.
@@ -37,4 +70,14 @@ class DeviceModule(SmartCamModule):
     @property
     def device_id(self) -> str:
         """Return the device id."""
-        return self.data["basic_info"]["dev_id"]
+        return self.data[self.QUERY_GETTER_NAME]["basic_info"]["dev_id"]
+
+    @property
+    def rssi(self) -> int | None:
+        """Return the device id."""
+        return self.data["getConnectionType"].get("rssiValue")
+
+    @property
+    def signal_level(self) -> int | None:
+        """Return the device id."""
+        return self.data["getConnectionType"].get("rssi")

kasa/smartcam/modules/motiondetection.py

@@ -10,7 +10,7 @@ from ..smartcammodule import SmartCamModule
 _LOGGER = logging.getLogger(__name__)
 
 
-class Motion(SmartCamModule):
+class MotionDetection(SmartCamModule):
     """Implementation of motion detection module."""
 
     REQUIRED_COMPONENT = "detection"
@@ -24,8 +24,8 @@ class Motion(SmartCamModule):
         self._add_feature(
             Feature(
                 self._device,
-                id="motion_detection_enabled",
-                name="Motion detection enabled",
+                id="motion_detection",
+                name="Motion detection",
                 container=self,
                 attribute_getter="enabled",
                 attribute_setter="set_enabled",
@@ -36,12 +36,12 @@ class Motion(SmartCamModule):
 
     @property
     def enabled(self) -> bool:
-        """Return the lens mask state."""
+        """Return the motion detection enabled state."""
         return self.data["motion_det"]["enabled"] == "on"
 
-    async def set_enabled(self, state: bool) -> dict:
-        """Set the lens mask state."""
-        params = {"enabled": "on" if state else "off"}
+    async def set_enabled(self, enable: bool) -> dict:
+        """Set the motion detection enabled state."""
+        params = {"enabled": "on" if enable else "off"}
         return await self._device._query_setter_helper(
-            "setLensMaskConfig", self.QUERY_MODULE_NAME, "motion_det", params
+            "setDetectionConfig", self.QUERY_MODULE_NAME, "motion_det", params
         )

kasa/smartcam/modules/persondetection.py

@@ -0,0 +1,47 @@
+"""Implementation of person detection module."""
+
+from __future__ import annotations
+
+import logging
+
+from ...feature import Feature
+from ..smartcammodule import SmartCamModule
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class PersonDetection(SmartCamModule):
+    """Implementation of person detection module."""
+
+    REQUIRED_COMPONENT = "personDetection"
+
+    QUERY_GETTER_NAME = "getPersonDetectionConfig"
+    QUERY_MODULE_NAME = "people_detection"
+    QUERY_SECTION_NAMES = "detection"
+
+    def _initialize_features(self) -> None:
+        """Initialize features after the initial update."""
+        self._add_feature(
+            Feature(
+                self._device,
+                id="person_detection",
+                name="Person detection",
+                container=self,
+                attribute_getter="enabled",
+                attribute_setter="set_enabled",
+                type=Feature.Type.Switch,
+                category=Feature.Category.Primary,
+            )
+        )
+
+    @property
+    def enabled(self) -> bool:
+        """Return the person detection enabled state."""
+        return self.data["detection"]["enabled"] == "on"
+
+    async def set_enabled(self, enable: bool) -> dict:
+        """Set the person detection enabled state."""
+        params = {"enabled": "on" if enable else "off"}
+        return await self._device._query_setter_helper(
+            "setPersonDetectionConfig", self.QUERY_MODULE_NAME, "detection", params
+        )

kasa/smartcam/modules/tamperdetection.py

@@ -0,0 +1,47 @@
+"""Implementation of tamper detection module."""
+
+from __future__ import annotations
+
+import logging
+
+from ...feature import Feature
+from ..smartcammodule import SmartCamModule
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class TamperDetection(SmartCamModule):
+    """Implementation of tamper detection module."""
+
+    REQUIRED_COMPONENT = "tamperDetection"
+
+    QUERY_GETTER_NAME = "getTamperDetectionConfig"
+    QUERY_MODULE_NAME = "tamper_detection"
+    QUERY_SECTION_NAMES = "tamper_det"
+
+    def _initialize_features(self) -> None:
+        """Initialize features after the initial update."""
+        self._add_feature(
+            Feature(
+                self._device,
+                id="tamper_detection",
+                name="Tamper detection",
+                container=self,
+                attribute_getter="enabled",
+                attribute_setter="set_enabled",
+                type=Feature.Type.Switch,
+                category=Feature.Category.Primary,
+            )
+        )
+
+    @property
+    def enabled(self) -> bool:
+        """Return the tamper detection enabled state."""
+        return self.data["tamper_det"]["enabled"] == "on"
+
+    async def set_enabled(self, enable: bool) -> dict:
+        """Set the tamper detection enabled state."""
+        params = {"enabled": "on" if enable else "off"}
+        return await self._device._query_setter_helper(
+            "setTamperDetectionConfig", self.QUERY_MODULE_NAME, "tamper_det", params
+        )