Add battery module to smartcam devices (#1452)

kasa/smartcam/modules/__init__.py

@@ -2,6 +2,7 @@
 
 from .alarm import Alarm
 from .babycrydetection import BabyCryDetection
+from .battery import Battery
 from .camera import Camera
 from .childdevice import ChildDevice
 from .device import DeviceModule
@@ -18,6 +19,7 @@ from .time import Time
 __all__ = [
     "Alarm",
     "BabyCryDetection",
+    "Battery",
     "Camera",
     "ChildDevice",
     "DeviceModule",

kasa/smartcam/modules/battery.py

@@ -0,0 +1,113 @@
+"""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 Battery(SmartCamModule):
+    """Implementation of a battery module."""
+
+    REQUIRED_COMPONENT = "battery"
+
+    def _initialize_features(self) -> None:
+        """Initialize features."""
+        self._add_feature(
+            Feature(
+                self._device,
+                "battery_low",
+                "Battery low",
+                container=self,
+                attribute_getter="battery_low",
+                icon="mdi:alert",
+                type=Feature.Type.BinarySensor,
+                category=Feature.Category.Debug,
+            )
+        )
+
+        self._add_feature(
+            Feature(
+                self._device,
+                "battery_level",
+                "Battery level",
+                container=self,
+                attribute_getter="battery_percent",
+                icon="mdi:battery",
+                unit_getter=lambda: "%",
+                category=Feature.Category.Info,
+                type=Feature.Type.Sensor,
+            )
+        )
+
+        self._add_feature(
+            Feature(
+                self._device,
+                "battery_temperature",
+                "Battery temperature",
+                container=self,
+                attribute_getter="battery_temperature",
+                icon="mdi:battery",
+                unit_getter=lambda: "celsius",
+                category=Feature.Category.Debug,
+                type=Feature.Type.Sensor,
+            )
+        )
+        self._add_feature(
+            Feature(
+                self._device,
+                "battery_voltage",
+                "Battery voltage",
+                container=self,
+                attribute_getter="battery_voltage",
+                icon="mdi:battery",
+                unit_getter=lambda: "V",
+                category=Feature.Category.Debug,
+                type=Feature.Type.Sensor,
+            )
+        )
+        self._add_feature(
+            Feature(
+                self._device,
+                "battery_charging",
+                "Battery charging",
+                container=self,
+                attribute_getter="battery_charging",
+                icon="mdi:alert",
+                type=Feature.Type.BinarySensor,
+                category=Feature.Category.Debug,
+            )
+        )
+
+    def query(self) -> dict:
+        """Query to execute during the update cycle."""
+        return {}
+
+    @property
+    def battery_percent(self) -> int:
+        """Return battery level."""
+        return self._device.sys_info["battery_percent"]
+
+    @property
+    def battery_low(self) -> bool:
+        """Return True if battery is low."""
+        return self._device.sys_info["low_battery"]
+
+    @property
+    def battery_temperature(self) -> bool:
+        """Return battery voltage in C."""
+        return self._device.sys_info["battery_temperature"]
+
+    @property
+    def battery_voltage(self) -> bool:
+        """Return battery voltage in V."""
+        return self._device.sys_info["battery_voltage"] / 1_000
+
+    @property
+    def battery_charging(self) -> bool:
+        """Return True if battery is charging."""
+        return self._device.sys_info["battery_voltage"] != "NO"

kasa/smartcam/smartcamchild.py

@@ -63,18 +63,14 @@ class SmartCamChild(SmartChildDevice, SmartCamDevice):
             None,
         )
 
-    def _map_child_info_from_parent(self, device_info: dict) -> dict:
-        return {
-            "model": device_info["device_model"],
-            "device_type": device_info["device_type"],
-            "alias": device_info["alias"],
-            "fw_ver": device_info["sw_ver"],
-            "hw_ver": device_info["hw_ver"],
-            "mac": device_info["mac"],
-            "hwId": device_info.get("hw_id"),
-            "oem_id": device_info["oem_id"],
-            "device_id": device_info["device_id"],
+    @staticmethod
+    def _map_child_info_from_parent(device_info: dict) -> dict:
+        mappings = {
+            "device_model": "model",
+            "sw_ver": "fw_ver",
+            "hw_id": "hwId",
         }
+        return {mappings.get(k, k): v for k, v in device_info.items()}
 
     def _update_internal_state(self, info: dict[str, Any]) -> None:
         """Update the internal info state.

kasa/smartcam/smartcamdevice.py

@@ -238,18 +238,17 @@ class SmartCamDevice(SmartDevice):
             await self._initialize_children()
 
     def _map_info(self, device_info: dict) -> dict:
+        """Map the basic keys to the keys used by SmartDevices."""
         basic_info = device_info["basic_info"]
-        return {
-            "model": basic_info["device_model"],
-            "device_type": basic_info["device_type"],
-            "alias": basic_info["device_alias"],
-            "fw_ver": basic_info["sw_version"],
-            "hw_ver": basic_info["hw_version"],
-            "mac": basic_info["mac"],
-            "hwId": basic_info.get("hw_id"),
-            "oem_id": basic_info["oem_id"],
-            "device_id": basic_info["dev_id"],
+        mappings = {
+            "device_model": "model",
+            "device_alias": "alias",
+            "sw_version": "fw_ver",
+            "hw_version": "hw_ver",
+            "hw_id": "hwId",
+            "dev_id": "device_id",
         }
+        return {mappings.get(k, k): v for k, v in basic_info.items()}
 
     @property
     def is_on(self) -> bool:

kasa/smartcam/smartcammodule.py

@@ -33,6 +33,8 @@ class SmartCamModule(SmartModule):
         "BabyCryDetection"
     )
 
+    SmartCamBattery: Final[ModuleName[modules.Battery]] = ModuleName("Battery")
+
     SmartCamDeviceModule: Final[ModuleName[modules.DeviceModule]] = ModuleName(
         "devicemodule"
     )