casambi-bt-revamped 0.3.11__py3-none-any.whl → 0.3.12.dev3__py3-none-any.whl

CasambiBt/_casambi.py

@@ -10,7 +10,7 @@ from bleak.backends.device import BLEDevice
 from httpx import AsyncClient, RequestError
 
 from ._cache import Cache
-from ._client import CasambiClient, ConnectionState, IncommingPacketType
+from ._client import CasambiClient, ConnectionState, IncommingPacketType, ProtocolMode
 from ._network import Network
 from ._operation import OpCode, OperationsContext
 from ._unit import Group, Scene, Unit, UnitControlType, UnitState
@@ -169,8 +169,10 @@ class Casambi:
         self._casaClient = cast(CasambiClient, self._casaClient)
         await self._casaClient.connect()
         try:
-            await self._casaClient.exchangeKey()
-            await self._casaClient.authenticate()
+            # EVO requires key exchange + authenticate; Classic is ready after `connect()`.
+            if self._casaClient.protocolMode == ProtocolMode.EVO:
+                await self._casaClient.exchangeKey()
+                await self._casaClient.authenticate()
         except ProtocolError as e:
             await self._casaClient.disconnect()
             raise e
@@ -201,6 +203,23 @@ class Casambi:
             raise ValueError()
 
         payload = level.to_bytes(1, byteorder="big", signed=False)
+
+        # Classic protocol uses signed command frames (u1.C1753e / u1.EnumC1754f).
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals (ground truth: casambi-android u1.EnumC1754f):
+            # - AllUnitsLevel=4, UnitLevel=7, GroupLevel=26
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(7, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(26, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(4, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetLevel)
 
     async def setVertical(self, target: Unit | Group | None, vertical: int) -> None:
@@ -219,6 +238,21 @@ class Casambi:
             raise ValueError()
 
         payload = vertical.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsVertical=22, UnitVertical=24, GroupVertical=29
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(24, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(29, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(22, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetVertical)
 
     async def setSlider(self, target: Unit | Group | None, value: int) -> None:
@@ -255,6 +289,21 @@ class Casambi:
             raise ValueError()
 
         payload = level.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsWhite=23, UnitWhite=25, GroupWhite=30
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(25, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(30, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(23, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetWhite)
 
     async def setColor(
@@ -272,6 +321,27 @@ class Casambi:
         :raises ValueError: The supplied rgbColor isn't in range
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses RGB payload (3 bytes) directly.
+            r, g, b = rgbColor
+            if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255):
+                raise ValueError("rgbColor out of range.")
+            payload = bytes([r & 0xFF, g & 0xFF, b & 0xFF])
+
+            # EnumC1754f ordinals: AllUnitsColor=6, UnitColor=9, GroupColor=28
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(9, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(28, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(6, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
+        # Evolution uses HS payload (hue 10-bit + sat 8-bit) for SetColor.
         state = UnitState()
         state.rgb = rgbColor
         hs: tuple[float, float] = state.hs  # type: ignore[assignment]
@@ -300,6 +370,21 @@ class Casambi:
 
         temperature = int(temperature / 50)
         payload = temperature.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsTemperature=5, UnitTemperature=8, GroupTemperature=27
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(8, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(27, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(5, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetTemperature)
 
     async def setColorXY(
@@ -317,6 +402,10 @@ class Casambi:
         :raises ValueError: The supplied XYColor isn't in range or not supported by the supplied unit.
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic command set (u1.EnumC1754f) only exposes RGB color control.
+            raise ValueError("XY color control is not supported on Classic networks.")
+
         if xyColor[0] < 0.0 or xyColor[0] > 1.0 or xyColor[1] < 0.0 or xyColor[1] > 1.0:
             raise ValueError("Color out of range.")
 
@@ -345,6 +434,22 @@ class Casambi:
         :return: Nothing is returned by this function. To get the new state register a change handler.
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses a longer payload for "restore last level" (ground truth: casambi-android u1.C1751c.o()).
+            payload = bytes([0xFF, 0x01, 0x00, 0x00, 0x01])
+            # EnumC1754f ordinals: AllUnitsLevel=4, UnitLevel=7, GroupLevel=26
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(7, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(26, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(4, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         # Use -1 to indicate special packet format
         # Use RestoreLastLevel flag (1) and UseFullTimeFlag (4).
         # Not sure what UseFullTime does but this is what the app uses.
@@ -367,6 +472,11 @@ class Casambi:
                 ConnectionState.AUTHENTICATED,
                 ConnectionState.NONE,
             )
+        if self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses a completely different command encoding (u1.C1753e/u1.EnumC1754f).
+            # Public APIs that support Classic handle it explicitly; anything reaching here would
+            # send an EVO INVOCATION packet which is not valid on Classic.
+            raise ProtocolError(f"Operation {opcode.name} is not supported on Classic networks via INVOCATION.")
 
         targetCode = 0
         if isinstance(target, Unit):
@@ -400,7 +510,7 @@ class Casambi:
     def _dataCallback(
         self, packetType: IncommingPacketType, data: dict[str, Any]
     ) -> None:
-        self._logger.info(f"Incomming data callback of type {packetType}")
+        self._logger.debug("Incomming data callback of type %s", packetType)
         if packetType == IncommingPacketType.UnitState:
             self._logger.debug(
                 f"Handling changed state {b2a(data['state'])} for unit {data['id']}"
@@ -473,13 +583,17 @@ class Casambi:
         """Register a new handler for switch events.
 
         This handler is called whenever a switch event is received.
-        The handler is supplied with a dictionary containing:
-        - unit_id: The ID of the switch unit
-        - button: The button number that was pressed/released
-        - event: Either "button_press" or "button_release"
-        - message_type: The raw message type (0x08 or 0x10)
-        - flags: Additional flags from the message
-        - extra_data: Any additional data from the message
+        The handler is supplied with a dictionary containing (at minimum):
+        - unit_id: target unit id (from INVOCATION target high byte)
+        - button: best-effort "label" (typically 1..4 for 4-gang switches)
+        - event: "button_press" | "button_release" | "input_event"
+
+        Switch events are parsed from decrypted packet type=7 (INVOCATION stream),
+        matching casambi-android `v1.C1775b.Q(Q2.h)`. Extra diagnostic keys include:
+        - invocation_flags, opcode, origin, target, target_type, age, origin_handle
+        - button_event_index (0..7), param_p, param_s
+        - input_index (0..7), input_code, input_b1, input_channel, input_value16, input_mapped_event
+        - packet_sequence, arrival_sequence, raw_packet, decrypted_data, payload_hex, frame_offset, event_id
 
         :param handler: The method to call when a switch event is received.
         """

CasambiBt/_classic_crypto.py

@@ -0,0 +1,31 @@
+"""Classic Casambi protocol helpers (CMAC signing/verification).
+
+Ground truth:
+- casambi-android `t1.P.o(...)` calculates a CMAC over:
+    connection_hash[0:8] + payload
+  and stores the CMAC (prefix) into the packet header.
+"""
+
+from __future__ import annotations
+
+from cryptography.hazmat.primitives.cmac import CMAC
+from cryptography.hazmat.primitives.ciphers.algorithms import AES
+
+
+def classic_cmac(key: bytes, conn_hash8: bytes, payload: bytes) -> bytes:
+    """Compute the Classic CMAC (16 bytes) over connection hash + payload."""
+    if len(conn_hash8) != 8:
+        raise ValueError("conn_hash8 must be 8 bytes")
+    cmac = CMAC(AES(key))
+    cmac.update(conn_hash8)
+    cmac.update(payload)
+    return cmac.finalize()
+
+
+def classic_cmac_prefix(
+    key: bytes, conn_hash8: bytes, payload: bytes, prefix_len: int
+) -> bytes:
+    """Return the prefix bytes that are embedded into the Classic packet header."""
+    mac = classic_cmac(key, conn_hash8, payload)
+    return mac[:prefix_len]
+