Explorar o código

feat(lock): add Lock Pro battery bays and advertisement alarms (#582)

* Implement battery bay telemetry and advertisement parsing for hardware variants

- Introduce dedicated command handling and data parsing routines to extract individual battery levels from dual compartments during device status queries.
- Refactor advertisement payload decoding logic by separating parsing functions to isolate hardware-specific alarm flags and charging states between variants.
- Update test suites to validate command execution flows, payload validation guards, and bitmask extractions across different hardware models.

* refactor(lock): share Lock Pro adv parsing via common helper
Myrik hai 1 día
pai
achega
f1ee590e44

+ 3 - 2
switchbot/adv_parser.py

@@ -47,6 +47,7 @@ from .adv_parsers.lock import (
     process_locklite,
     process_wolock,
     process_wolock_pro,
+    process_wolock_pro_wifi,
 )
 from .adv_parsers.meter import process_wosensorth, process_wosensorth_c
 from .adv_parsers.motion import process_wopresence
@@ -928,13 +929,13 @@ SUPPORTED_TYPES: dict[str | bytes, SwitchbotSupportedType] = {
     b"\x00\x10\xff\x90": {
         "modelName": SwitchbotModel.LOCK_PRO_WIFI,
         "modelFriendlyName": "Lock Pro Wifi",
-        "func": process_wolock_pro,
+        "func": process_wolock_pro_wifi,
         "manufacturer_id": 2409,
     },
     b"\x01\x10\xff\x90": {
         "modelName": SwitchbotModel.LOCK_PRO_WIFI,
         "modelFriendlyName": "Lock Pro Wifi",
-        "func": process_wolock_pro,
+        "func": process_wolock_pro_wifi,
         "manufacturer_id": 2409,
     },
     b"\x00\x12\x11\x00": {

+ 24 - 6
switchbot/adv_parsers/lock.py

@@ -68,20 +68,38 @@ def parse_common_data(mfr_data: bytes | None) -> dict[str, bool | int]:
     }
 
 
+def _parse_lock_pro_common(mfr_data: bytes | None) -> dict[str, bool | int]:
+    common_data = parse_common_data(mfr_data)
+    if not common_data:
+        return {}
+
+    return common_data | {
+        "low_temperature_alarm": bool(mfr_data[11] & 0b00100000),
+        "left_battery_compartment_alarm": bool(mfr_data[11] & 0b00000100),
+        "right_battery_compartment_alarm": bool(mfr_data[11] & 0b00000010),
+    }
+
+
 def process_wolock_pro(
     data: bytes | None, mfr_data: bytes | None
 ) -> dict[str, bool | int]:
     """Support for lock pro process data."""
-    common_data = parse_common_data(mfr_data)
+    common_data = _parse_lock_pro_common(mfr_data)
     if not common_data:
         return {}
 
-    lock_pro_data = {
-        "low_temperature_alarm": bool(mfr_data[11] & 0b00100000),
-        "left_battery_compartment_alarm": mfr_data[11] & 0b000000100,
-        "right_battery_compartment_alarm": mfr_data[11] & 0b000000010,
+    return common_data | {
+        "battery_charging": bool(mfr_data[9] & 0b10000000),
+        "power_alarm": bool(mfr_data[11] & 0b00010000),
+        "door_magnet_alarm": bool(mfr_data[11] & 0b00001000),
     }
-    return common_data | lock_pro_data
+
+
+def process_wolock_pro_wifi(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, bool | int]:
+    """Support for lock pro wifi process data."""
+    return _parse_lock_pro_common(mfr_data)
 
 
 def process_lock_nano(

+ 30 - 1
switchbot/devices/lock.py

@@ -65,6 +65,9 @@ COMMAND_LOCK = {
     SwitchbotModel.LOCK_VISION: f"{COMMAND_HEADER}0f4e0101000000",
     SwitchbotModel.LOCK_PRO_WIFI: f"{COMMAND_HEADER}0f4e0101000000",
 }
+COMMAND_BATTERY_BAYS = {
+    SwitchbotModel.LOCK_PRO: f"{COMMAND_HEADER}0f4f0409",
+}
 COMMAND_HALF_LOCK = {
     SwitchbotModel.LOCK_ULTRA: f"{COMMAND_HEADER}0f4e0101000008",
 }
@@ -395,7 +398,12 @@ class SwitchbotLock(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
         lock_data = self._parse_lock_data(lock_raw_data[1:], self._model)
         if lock_data is None:
             return None
-        return lock_data | self._parse_basic_data(basic_data)
+        result = lock_data | self._parse_basic_data(basic_data)
+        if self._model in COMMAND_BATTERY_BAYS and (
+            bays_data := await self._get_battery_bays()
+        ):
+            result |= self._parse_battery_bays(bays_data)
+        return result
 
     def is_calibrated(self) -> Any:
         """Return True if lock is calibrated."""
@@ -441,6 +449,27 @@ class SwitchbotLock(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
 
         return _data
 
+    async def _get_battery_bays(self) -> bytes | None:
+        """Return battery bays info of device."""
+        _data = await self._send_command(
+            key=COMMAND_BATTERY_BAYS[self._model], retry=self._retry_count
+        )
+        if not self._check_command_result(_data, 0, COMMAND_RESULT_EXPECTED_VALUES):
+            _LOGGER.warning("Unable to read battery bays")
+            return None
+        if len(_data) < 3:
+            _LOGGER.warning("Invalid battery bays data received: %s", _data.hex())
+            return None
+        return _data
+
+    @staticmethod
+    def _parse_battery_bays(data: bytes) -> dict[str, int | None]:
+        """Parse battery bays data, None for an empty bay."""
+        return {
+            "left_battery": data[1] & 0b01111111 if data[1] & 0b10000000 else None,
+            "right_battery": data[2] & 0b01111111 if data[2] & 0b10000000 else None,
+        }
+
     async def _enable_notifications(self) -> bool:
         result = await self._send_command(COMMAND_ENABLE_NOTIFICATIONS[self._model])
         return self._check_command_result(result, 0, COMMAND_RESULT_EXPECTED_VALUES)

+ 39 - 8
tests/test_adv_parser.py

@@ -15,6 +15,7 @@ from switchbot.adv_parser import (
     populate_model_to_mac_cache,
 )
 from switchbot.adv_parsers.fan import process_circulator_fan_pro
+from switchbot.adv_parsers.lock import process_wolock_pro, process_wolock_pro_wifi
 from switchbot.const.lock import LockStatus
 from switchbot.models import SwitchBotAdvertisement
 
@@ -3020,9 +3021,12 @@ def test_hub3_with_empty_data() -> None:
                 "door_open_from_secondary_lock": False,
                 "double_lock_mode": False,
                 "is_secondary_lock": False,
-                "left_battery_compartment_alarm": 0,
-                "right_battery_compartment_alarm": 0,
+                "battery_charging": False,
+                "left_battery_compartment_alarm": False,
+                "right_battery_compartment_alarm": False,
                 "low_temperature_alarm": False,
+                "power_alarm": False,
+                "door_magnet_alarm": False,
                 "manual_unlock_linkage": False,
                 "unclosed_alarm": False,
                 "unlocked_alarm": False,
@@ -3113,8 +3117,8 @@ def test_hub3_with_empty_data() -> None:
                 "door_open_from_secondary_lock": False,
                 "double_lock_mode": False,
                 "is_secondary_lock": False,
-                "left_battery_compartment_alarm": 0,
-                "right_battery_compartment_alarm": 0,
+                "left_battery_compartment_alarm": False,
+                "right_battery_compartment_alarm": False,
                 "low_temperature_alarm": False,
                 "manual_unlock_linkage": False,
                 "unclosed_alarm": False,
@@ -3350,9 +3354,12 @@ def test_lock_active(test_case: AdvTestCase) -> None:
                 "door_open_from_secondary_lock": False,
                 "double_lock_mode": False,
                 "is_secondary_lock": False,
-                "left_battery_compartment_alarm": 0,
-                "right_battery_compartment_alarm": 0,
+                "battery_charging": False,
+                "left_battery_compartment_alarm": False,
+                "right_battery_compartment_alarm": False,
                 "low_temperature_alarm": False,
+                "power_alarm": False,
+                "door_magnet_alarm": False,
                 "manual_unlock_linkage": False,
                 "unclosed_alarm": False,
                 "unlocked_alarm": False,
@@ -3443,8 +3450,8 @@ def test_lock_active(test_case: AdvTestCase) -> None:
                 "door_open_from_secondary_lock": False,
                 "double_lock_mode": False,
                 "is_secondary_lock": False,
-                "left_battery_compartment_alarm": 0,
-                "right_battery_compartment_alarm": 0,
+                "left_battery_compartment_alarm": False,
+                "right_battery_compartment_alarm": False,
                 "low_temperature_alarm": False,
                 "manual_unlock_linkage": False,
                 "unclosed_alarm": False,
@@ -5384,3 +5391,27 @@ def test_with_special_manufacturer_data_length() -> None:
     )
     result = parse_advertisement_data(ble_device, adv_data)
     assert result.data["modelName"] == SwitchbotModel.HUMIDIFIER
+
+
+def test_lock_pro_alarm_bits() -> None:
+    """Test Lock Pro charging and alarm bits."""
+    mfr_data = bytes.fromhex("fb7d6962d3de2a8a00e4003e")
+    result = process_wolock_pro(b"$\x80d", mfr_data)
+    assert result["battery"] == 100
+    assert result["battery_charging"] is True
+    assert result["low_temperature_alarm"] is True
+    assert result["power_alarm"] is True
+    assert result["door_magnet_alarm"] is True
+    assert result["left_battery_compartment_alarm"] is True
+    assert result["right_battery_compartment_alarm"] is True
+    assert result["unclosed_alarm"] is False
+    assert result["unlocked_alarm"] is False
+
+
+def test_lock_pro_wifi_omits_lock_pro_only_bits() -> None:
+    """Test Lock Pro Wifi does not report bits only decoded for the Lock Pro."""
+    result = process_wolock_pro_wifi(None, bytes.fromhex("fb7d6962d3de2a8a00e4003e"))
+    assert result["left_battery_compartment_alarm"] is True
+    assert "battery_charging" not in result
+    assert "power_alarm" not in result
+    assert "door_magnet_alarm" not in result

+ 60 - 0
tests/test_lock.py

@@ -284,6 +284,7 @@ async def test_get_basic_info(model: str):
     with (
         patch.object(device, "_get_lock_info", return_value=lock_data),
         patch.object(device, "_get_basic_info", return_value=basic_data),
+        patch.object(device, "_get_battery_bays", return_value=None),
     ):
         result = await device.get_basic_info()
         assert result is not None
@@ -291,6 +292,7 @@ async def test_get_basic_info(model: str):
         assert "firmware" in result
         assert "calibration" in result
         assert "status" in result
+        assert "left_battery" not in result
 
 
 @pytest.mark.asyncio
@@ -341,6 +343,64 @@ async def test_get_basic_info_no_basic_data(model: str):
         assert result is None
 
 
+@pytest.mark.asyncio
+async def test_get_basic_info_lock_pro_battery_bays():
+    """Test get_basic_info reads both battery bays on the Lock Pro."""
+    device = create_device_for_command_testing(SwitchbotModel.LOCK_PRO)
+    with (
+        patch.object(
+            device, "_get_lock_info", return_value=b"\x00\x80\x00\x00\x00\x00\x00\x00"
+        ),
+        patch.object(device, "_get_basic_info", return_value=b"\x00\x64\x01"),
+        patch.object(
+            device, "_send_command", return_value=bytes.fromhex("01e4cd0000")
+        ) as mock_send,
+    ):
+        result = await device.get_basic_info()
+    mock_send.assert_awaited_once_with(key="570f4f0409", retry=device._retry_count)
+    assert result["left_battery"] == 100
+    assert result["right_battery"] == 77
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("reply", [b"\x00", b"\x01\xe4"])
+async def test_get_battery_bays_bad_reply(reply: bytes):
+    """Test _get_battery_bays rejects failed and short replies."""
+    device = create_device_for_command_testing(SwitchbotModel.LOCK_PRO)
+    with patch.object(device, "_send_command", return_value=reply):
+        assert await device._get_battery_bays() is None
+
+
+@pytest.mark.asyncio
+async def test_get_basic_info_lock_pro_without_battery_bays():
+    """Test get_basic_info still succeeds when the bays read is refused."""
+    device = create_device_for_command_testing(SwitchbotModel.LOCK_PRO)
+    with (
+        patch.object(
+            device, "_get_lock_info", return_value=b"\x00\x80\x00\x00\x00\x00\x00\x00"
+        ),
+        patch.object(device, "_get_basic_info", return_value=b"\x00\x64\x01"),
+        patch.object(device, "_send_command", return_value=b"\x00"),
+    ):
+        result = await device.get_basic_info()
+    assert result is not None
+    assert result["battery"] == 100
+    assert "left_battery" not in result
+
+
+@pytest.mark.parametrize(
+    ("data", "expected"),
+    [
+        (bytes.fromhex("01e4cd0000"), {"left_battery": 100, "right_battery": 77}),
+        (bytes.fromhex("01e4000000"), {"left_battery": 100, "right_battery": None}),
+        (bytes.fromhex("0100b20000"), {"left_battery": None, "right_battery": 50}),
+    ],
+)
+def test_parse_battery_bays(data: bytes, expected: dict[str, int | None]):
+    """Test _parse_battery_bays reports None for an empty bay."""
+    assert lock.SwitchbotLock._parse_battery_bays(data) == expected
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     "model",

+ 2 - 0
tests/test_short_payload_guards.py

@@ -45,6 +45,7 @@ from switchbot.adv_parsers.lock import (
     process_locklite,
     process_wolock,
     process_wolock_pro,
+    process_wolock_pro_wifi,
 )
 from switchbot.adv_parsers.meter import process_wosensorth
 from switchbot.adv_parsers.motion import process_wopresence
@@ -178,6 +179,7 @@ def test_lock_parsers_short_mfr(mfr_data):
     assert process_wolock(None, mfr_data) == {}
     assert parse_common_data(mfr_data) == {}
     assert process_wolock_pro(None, mfr_data) == {}
+    assert process_wolock_pro_wifi(None, mfr_data) == {}
     assert process_lock2(None, mfr_data) == {}