casambi-bt-revamped 0.3.7.dev3__py3-none-any.whl → 0.3.7.dev5__py3-none-any.whl

CasambiBt/_casambi.py

@@ -423,14 +423,14 @@ class Casambi:
                 f"Handling switch event: unit_id={data.get('unit_id')}, "
                 f"button={data.get('button')}, event={data.get('event')}"
             )
-
+            
             # Notify listeners
-            for switch_handler in self._switchEventCallbacks:
+            for h in self._switchEventCallbacks:
                 try:
-                    switch_handler(data)
+                    h(data)
                 except Exception:
                     self._logger.error(
-                        f"Exception occurred in switchEventCallback {switch_handler}.",
+                        f"Exception occurred in switchEventCallback {h}.",
                         exc_info=True,
                     )
         else:
@@ -457,9 +457,7 @@ class Casambi:
         self._unitChangedCallbacks.remove(handler)
         self._logger.debug(f"Removed unit changed handler {handler}")
 
-    def registerSwitchEventHandler(
-        self, handler: Callable[[dict[str, Any]], None]
-    ) -> None:
+    def registerSwitchEventHandler(self, handler: Callable[[dict[str, Any]], None]) -> None:
         """Register a new handler for switch events.
 
         This handler is called whenever a switch event is received.
@@ -476,9 +474,7 @@ class Casambi:
         self._switchEventCallbacks.append(handler)
         self._logger.debug(f"Registered switch event handler {handler}")
 
-    def unregisterSwitchEventHandler(
-        self, handler: Callable[[dict[str, Any]], None]
-    ) -> None:
+    def unregisterSwitchEventHandler(self, handler: Callable[[dict[str, Any]], None]) -> None:
         """Unregister an existing switch event handler.
 
         :param handler: The handler to unregister.

CasambiBt/_client.py

@@ -33,6 +33,12 @@ from .errors import (  # noqa: E402
     UnsupportedProtocolVersion,
 )
 
+# Import Android parser for comparison
+try:
+    from ._client_android_parser import AndroidPacketParser
+except ImportError:
+    AndroidPacketParser = None
+
 
 @unique
 class IncommingPacketType(IntEnum):
@@ -414,18 +420,28 @@ class CasambiClient:
     ) -> None:
         # TODO: Check incoming counter and direction flag
         self._inPacketCount += 1
-
-        # Store raw encrypted packet for reference
+        
+        # Store raw encrypted packet for Android parser analysis
         raw_encrypted_packet = data[:]
+        
+        # Android parser comparison - disabled as protocols are incompatible
+        android_switch_event = None
+        # The Android parser expects a completely different packet format than what
+        # this implementation uses. Logging disabled to reduce noise.
 
         try:
-            decrypted_data = self._encryptor.decryptAndVerify(
-                data, data[:4] + self._nonce[4:]
-            )
+            decrypted_data = self._encryptor.decryptAndVerify(data, data[:4] + self._nonce[4:])
         except InvalidSignature:
             # We only drop packets with invalid signature here instead of going into an error state
             self._logger.error(f"Invalid signature for packet {b2a(data)}!")
             return
+            
+        # Protocol analysis: Current implementation vs Android
+        # These are fundamentally different protocols:
+        # - Current: Type 0x07 + message-based protocol (0x10/0x08 messages)
+        # - Android: Complex header with command types 29-36 for buttons
+        # No conversion possible - they're incompatible formats
+        android_switch_event = None
 
         packetType = decrypted_data[0]
         self._logger.debug(f"Incoming data of type {packetType}: {b2a(decrypted_data)}")
@@ -433,9 +449,7 @@ class CasambiClient:
         if packetType == IncommingPacketType.UnitState:
             self._parseUnitStates(decrypted_data[1:])
         elif packetType == IncommingPacketType.SwitchEvent:
-            self._parseSwitchEvent(
-                decrypted_data[1:], self._inPacketCount, raw_encrypted_packet
-            )
+            self._parseSwitchEvent(decrypted_data[1:], self._inPacketCount, raw_encrypted_packet, android_switch_event)
         elif packetType == IncommingPacketType.NetworkConfig:
             # We don't care about the config the network thinks it has.
             # We assume that cloud config and local config match.
@@ -489,29 +503,26 @@ class CasambiClient:
                 f"Ran out of data while parsing unit state! Remaining data {b2a(data[oldPos:])} in {b2a(data)}."
             )
 
-    def _parseSwitchEvent(
-        self, data: bytes, packet_seq: int = None, raw_packet: bytes = None
-    ) -> None:
-        """Parse switch event packet which contains multiple message types."""
-        self._logger.info(
-            f"Parsing incoming switch event packet #{packet_seq}... Data: {b2a(data)}"
-        )
-
+    def _parseSwitchEvent(self, data: bytes, packet_seq: int = None, raw_packet: bytes = None, android_switch_event: dict = None) -> None:
+        """Parse switch event packet which contains multiple message types"""
+        self._logger.info(f"Parsing incoming switch event packet #{packet_seq}... Data: {b2a(data)}")
+        
         # Special handling for message type 0x29 - not a switch event
         if len(data) >= 1 and data[0] == 0x29:
-            self._logger.debug(
-                f"Ignoring message type 0x29 (not a switch event): {b2a(data)}"
-            )
+            self._logger.debug(f"Ignoring message type 0x29 (not a switch event): {b2a(data)}")
             return
 
+        # NEW PARSING: Android-style protocol parsing (for comparison only)
+        self._parseAndroidProtocol(data, packet_seq, raw_packet)
+
         pos = 0
         oldPos = 0
         switch_events_found = 0
-
+        
         try:
             while pos <= len(data) - 3:
                 oldPos = pos
-
+                
                 # Parse message header
                 message_type = data[pos]
                 flags = data[pos + 1]
@@ -543,22 +554,41 @@ class CasambiClient:
                 # Process based on message type
                 if message_type == 0x08 or message_type == 0x10:  # Switch/button events
                     switch_events_found += 1
-                    # Extract button ID - try both upper and lower nibbles
-                    button_lower = parameter & 0x0F
-                    button_upper = (parameter >> 4) & 0x0F
-
-                    # Use upper 4 bits if lower 4 bits are 0, otherwise use lower 4 bits
-                    if button_lower == 0 and button_upper != 0:
-                        button = button_upper
+                    
+                    # Enhanced button extraction for battery-powered switches
+                    # For type 0x08, the parameter byte encodes the button differently
+                    if message_type == 0x08:
+                        # Type 0x08: Check if this might be using Android-style encoding
+                        # where button is in upper nibble when lower nibble is 0
+                        button_lower = parameter & 0x0F
+                        button_upper = (parameter >> 4) & 0x0F
+                        
+                        # Log both interpretations for comparison
                         self._logger.debug(
-                            f"EVO button extraction: parameter=0x{parameter:02x}, using upper nibble, button={button}"
+                            f"[TYPE 0x08 ANALYSIS] parameter=0x{parameter:02x}, "
+                            f"lower_nibble={button_lower}, upper_nibble={button_upper}"
                         )
+                        
+                        # If lower nibble is 0 and upper nibble is not, use upper
+                        # This handles cases like 0x20 (button 2), 0x30 (button 3), etc.
+                        if button_lower == 0 and button_upper != 0:
+                            button = button_upper
+                            self._logger.info(
+                                f"[TYPE 0x08 FIX] Using upper nibble for button: {button} "
+                                f"(parameter=0x{parameter:02x})"
+                            )
+                        else:
+                            button = button_lower
+                            self._logger.debug(
+                                f"[TYPE 0x08] Using lower nibble for button: {button} "
+                                f"(parameter=0x{parameter:02x})"
+                            )
                     else:
-                        button = button_lower
+                        # Type 0x10: Standard extraction from lower nibble
+                        button = parameter & 0x0F
                         self._logger.debug(
-                            f"EVO button extraction: parameter=0x{parameter:02x}, using lower nibble, button={button}"
+                            f"[TYPE 0x10] Button extraction: parameter=0x{parameter:02x}, button={button}"
                         )
-
                     # For type 0x10 messages, we need to pass additional data beyond the declared payload
                     if message_type == 0x10:
                         # Extend to include at least 10 bytes from message start for state byte
@@ -566,20 +596,11 @@ class CasambiClient:
                         full_message_data = data[oldPos:extended_end]
                     else:
                         full_message_data = data
-                    self._processSwitchMessage(
-                        message_type,
-                        flags,
-                        button,
-                        payload,
-                        full_message_data,
-                        oldPos,
-                        packet_seq,
-                        raw_packet,
-                    )
+                    self._processSwitchMessage(message_type, flags, button, payload, full_message_data, oldPos, packet_seq, raw_packet, android_switch_event)
                 elif message_type == 0x29:
                     # This shouldn't happen due to check above, but just in case
-                    self._logger.debug("Ignoring embedded type 0x29 message")
-                elif message_type in [0x00, 0x06, 0x09, 0x1F, 0x2A]:
+                    self._logger.debug(f"Ignoring embedded type 0x29 message")
+                elif message_type in [0x00, 0x06, 0x09, 0x1f, 0x2a]:
                     # Known non-switch message types - log at debug level
                     self._logger.debug(
                         f"Non-switch message type 0x{message_type:02x}: flags=0x{flags:02x}, "
@@ -599,10 +620,83 @@ class CasambiClient:
                 f"Ran out of data while parsing switch event packet! "
                 f"Remaining data {b2a(data[oldPos:])} in {b2a(data)}."
             )
-
+            
         if switch_events_found == 0:
             self._logger.debug(f"No switch events found in packet: {b2a(data)}")
 
+    def _parseAndroidProtocol(
+        self, data: bytes, packet_seq: int = None, raw_packet: bytes = None
+    ) -> None:
+        """
+        Parse using Android app's protocol structure (for comparison only).
+        This doesn't generate events, just logs what it would detect.
+        
+        Android protocol structure:
+        - 2 bytes: Header/flags
+        - 1 byte: Command type (29-36 for ButtonEvent0-7)
+        - 2 bytes: Origin
+        - 2 bytes: Target (lower byte = type, upper byte = unit ID)
+        - 2 bytes: Age
+        - Variable: Payload
+        """
+        try:
+            # Check if data looks like Android protocol format
+            if len(data) < 9:
+                return
+            
+            # Try to parse as Android protocol
+            pos = 0
+            if data[0] in [0x08, 0x10]:  # This is BLE protocol, not Android protocol
+                return
+                
+            # Attempt Android protocol parsing
+            try:
+                import struct
+                # Read header
+                header = struct.unpack_from(">H", data, 0)[0]
+                command_type = data[2] if len(data) > 2 else 0
+                origin = struct.unpack_from(">H", data, 3)[0] if len(data) > 4 else 0
+                target = struct.unpack_from(">H", data, 5)[0] if len(data) > 6 else 0
+                age = struct.unpack_from(">H", data, 7)[0] if len(data) > 8 else 0
+                
+                payload_length = (header & 0x3F)  # Lower 6 bits
+                lifetime = (header >> 11) & 0x0F  # Bits 11-14
+                
+                target_type = target & 0xFF  # Lower byte
+                unit_id = target >> 8  # Upper byte
+                
+                # Check if this is a switch event (target type = 6)
+                if target_type == 6 and 29 <= command_type <= 36:
+                    button_index = command_type - 29
+                    
+                    if len(data) >= 10:
+                        payload_start = 9
+                        if len(data) >= payload_start + 1:
+                            first_payload_byte = data[payload_start]
+                            param_p = (first_payload_byte >> 3) & 0x0F
+                            param_s = first_payload_byte & 0x07
+                            state = (first_payload_byte & 0x80) >> 7
+                            
+                            self._logger.info(
+                                f"[ANDROID PROTOCOL] Unit {unit_id} Switch event: "
+                                f"button #{button_index} (P{param_p} S{param_s}) = {state} "
+                                f"(1=pressed, 0=released)"
+                            )
+                            
+                            # Compare with what current parsing would detect
+                            self._logger.debug(
+                                f"[ANDROID PROTOCOL] Full parse: header=0x{header:04x}, "
+                                f"cmd={command_type}, origin={origin}, target=0x{target:04x}, "
+                                f"lifetime={lifetime}, age={age}, payload_len={payload_length}"
+                            )
+            except:
+                # Not Android protocol format, skip
+                pass
+                
+        except Exception as e:
+            # Silently ignore - this is just for comparison
+            pass
+
     def _processSwitchMessage(
         self,
         message_type: int,
@@ -623,14 +717,14 @@ class CasambiClient:
         if message_type == 0x10 and len(payload) >= 3:
             # Type 0x10: unit_id is at payload[2]
             unit_id = payload[2]
-            extra_data = payload[3:] if len(payload) > 3 else b""
+            extra_data = payload[3:] if len(payload) > 3 else b''
         else:
             # Standard parsing for other message types
             unit_id = payload[0]
-            extra_data = b""
+            extra_data = b''
             if len(payload) > 2:
                 extra_data = payload[2:]
-
+        
         # Extract action based on message type (action SHOULD be different for press vs release)
         if message_type == 0x10 and len(payload) > 1:
             # Type 0x10: action is at payload[1]
@@ -642,50 +736,91 @@ class CasambiClient:
             action = None
 
         event_string = "unknown"
-
+        
         # Different interpretation based on message type
         if message_type == 0x08:
             # Type 0x08: Use bit 1 of action for press/release
             if action is not None:
                 is_release = (action >> 1) & 1
                 event_string = "button_release" if is_release else "button_press"
+                
+                # NEW: Enhanced logging for battery-powered switches
+                self._logger.debug(
+                    f"[TYPE 0x08 STATE] action=0x{action:02x}, release_bit={is_release}, "
+                    f"event={event_string}, unit_id={unit_id}, button={button}"
+                )
         elif message_type == 0x10:
             # Type 0x10: The state byte is at position 9 (0-indexed) from message start
-            # This applies to all units, not just unit 31
+            # This applies to all units, including battery-powered switches
             # full_data for type 0x10 is the message data starting from position 0
             state_pos = 9
             if len(full_data) > state_pos:
                 state_byte = full_data[state_pos]
+                
+                # NEW: Enhanced state detection with logging
+                self._logger.debug(
+                    f"[TYPE 0x10 STATE] State byte at pos {state_pos}: 0x{state_byte:02x}"
+                )
+                
                 if state_byte == 0x01:
                     event_string = "button_press"
                 elif state_byte == 0x02:
                     event_string = "button_release"
                 elif state_byte == 0x09:
                     event_string = "button_hold"
-                elif state_byte == 0x0C:
+                elif state_byte == 0x0c:
                     event_string = "button_release_after_hold"
                 else:
-                    self._logger.debug(
-                        f"Type 0x10: Unknown state byte 0x{state_byte:02x} at message pos {state_pos}"
+                    # More detailed logging for unknown states
+                    self._logger.info(
+                        f"[TYPE 0x10 STATE] Unknown state byte 0x{state_byte:02x} at pos {state_pos}, "
+                        f"unit_id={unit_id}, button={button}, full_data={b2a(full_data)}"
                     )
-                    # Fallback: check if extra_data starts with 0x12 (indicates release)
-                    if len(extra_data) >= 1 and extra_data[0] == 0x12:
-                        event_string = "button_release"
+                    
+                    # Enhanced fallback logic for battery-powered switches
+                    # Check multiple patterns that indicate release
+                    if len(extra_data) >= 1:
+                        first_extra = extra_data[0]
+                        if first_extra == 0x12:
+                            event_string = "button_release"
+                            self._logger.debug("[TYPE 0x10 STATE] Detected release via 0x12 pattern")
+                        elif first_extra in [0x00, 0x10]:
+                            event_string = "button_press"
+                            self._logger.debug(f"[TYPE 0x10 STATE] Detected press via 0x{first_extra:02x} pattern")
+                        else:
+                            # Check action byte patterns
+                            if action is not None:
+                                # Common patterns: 0xf8/0xfb = press, 0xfa/0xfc = release
+                                if action in [0xf8, 0xfb, 0xf7, 0xf9]:
+                                    event_string = "button_press"
+                                    self._logger.debug(f"[TYPE 0x10 STATE] Detected press via action 0x{action:02x}")
+                                elif action in [0xfa, 0xfc, 0xfd, 0xfe]:
+                                    event_string = "button_release"
+                                    self._logger.debug(f"[TYPE 0x10 STATE] Detected release via action 0x{action:02x}")
+                                else:
+                                    event_string = "button_press"  # Default to press
+                                    self._logger.debug(f"[TYPE 0x10 STATE] Defaulting to press for action 0x{action:02x}")
+                            else:
+                                event_string = "button_press"  # Default to press
                     else:
-                        event_string = "button_press"
+                        event_string = "button_press"  # Default to press when no extra data
             else:
                 # Fallback when message is too short
+                self._logger.warning(
+                    f"[TYPE 0x10 STATE] Message too short for state byte (len={len(full_data)}), "
+                    f"unit_id={unit_id}, button={button}, payload={b2a(payload)}"
+                )
+                
+                # Use enhanced fallback detection
                 if len(extra_data) >= 1 and extra_data[0] == 0x12:
                     event_string = "button_release"
-                    self._logger.debug(
-                        "Type 0x10: Using extra_data pattern for release detection"
-                    )
+                    self._logger.debug("[TYPE 0x10 STATE] Using 0x12 pattern for release (short message)")
+                elif action is not None and action in [0xfa, 0xfc, 0xfd, 0xfe]:
+                    event_string = "button_release"
+                    self._logger.debug(f"[TYPE 0x10 STATE] Using action pattern 0x{action:02x} for release (short message)")
                 else:
-                    # Cannot determine state
-                    self._logger.warning(
-                        f"Type 0x10 message missing state info, unit_id={unit_id}, payload={b2a(payload)}"
-                    )
-                    event_string = "unknown"
+                    event_string = "button_press"  # Default to press
+                    self._logger.debug("[TYPE 0x10 STATE] Defaulting to press (short message)")
 
         action_display = f"{action:#04x}" if action is not None else "N/A"
 
@@ -693,11 +828,33 @@ class CasambiClient:
             f"Switch event (type 0x{message_type:02x}): button={button}, unit_id={unit_id}, "
             f"action={action_display} ({event_string}), flags=0x{flags:02x}"
         )
-
-        # Filter out type 0x08 messages with button=0 (likely notifications)
-        if message_type == 0x08 and button == 0:
+        
+        # Include Android parser comparison if available
+        android_comparison = None
+        if android_switch_event:
+            android_comparison = {
+                'unit_id': android_switch_event['unit_id'],
+                'button': android_switch_event['button'],
+                'state': android_switch_event['state'],
+                'param_p': android_switch_event['param_p'],
+                'param_s': android_switch_event['param_s'],
+                'android_log': android_switch_event['android_log']
+            }
+            # Log differences
+            if android_switch_event['unit_id'] != unit_id:
+                self._logger.warning(f"Unit ID mismatch: current={unit_id}, android={android_switch_event['unit_id']}")
+            if android_switch_event['button'] != button:
+                self._logger.warning(f"Button mismatch: current={button}, android={android_switch_event['button']}")
+                
+        # Extract controlling unit if present
+        controlling_unit = None
+        # This is redundant since we already return early if unit_id_echo != unit_id
+        # Removing to avoid confusion
+        
+        # Filter out all type 0x08 messages
+        if message_type == 0x08:
             self._logger.debug(
-                f"Filtering out type 0x08 notification event: button={button}, unit_id={unit_id}, "
+                f"Filtering out type 0x08 event: button={button}, unit_id={unit_id}, "
                 f"action={action_display}, flags=0x{flags:02x}"
             )
             return
@@ -712,11 +869,13 @@ class CasambiClient:
                 "event": event_string,
                 "flags": flags,
                 "extra_data": extra_data,
+                "controlling_unit": controlling_unit,
                 "packet_sequence": packet_seq,
                 "raw_packet": b2a(raw_packet) if raw_packet else None,
                 "decrypted_data": b2a(full_data),
                 "message_position": start_pos,
                 "payload_hex": b2a(payload),
+                "android_comparison": android_comparison,
             },
         )
 

CasambiBt/_client_android_parser.py

@@ -0,0 +1,215 @@
+"""
+Android App Compatible Parser for Casambi Switch Events
+
+This module implements the exact parsing logic from the decompiled Android app
+to compare with our current implementation.
+"""
+
+import struct
+from typing import Dict, Any, Optional, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AndroidPacketParser:
+    """Parser that follows the exact Android app implementation"""
+    
+    @staticmethod
+    def parse_packet_header(data: bytes, pos: int = 0) -> Tuple[Dict[str, Any], int]:
+        """
+        Parse packet header according to Android app C1775b.Q method (lines 230-243)
+        
+        Returns: (header_dict, new_position)
+        """
+        if len(data) - pos < 9:
+            raise ValueError("Insufficient data for packet header")
+            
+        # Read header (2 bytes)
+        unsigned_short = struct.unpack_from('>H', data, pos)[0]
+        pos += 2
+        
+        # Extract flags from header
+        has_origin_handle = (unsigned_short & 64) != 0    # bit 6
+        is_unique = (unsigned_short & 128) != 0           # bit 7
+        has_session = (unsigned_short & 256) != 0         # bit 8
+        has_origin_handle_alt = (unsigned_short & 512) != 0  # bit 9
+        flag_1024 = (unsigned_short & 1024) != 0         # bit 10
+        
+        # Read command type (1 byte) - this is the EnumC1777d ordinal
+        command_type = data[pos] & 0xFF
+        pos += 1
+        
+        # Read origin (2 bytes)
+        origin = struct.unpack_from('>H', data, pos)[0]
+        pos += 2
+        
+        # Read target (2 bytes)
+        target = struct.unpack_from('>H', data, pos)[0]
+        pos += 2
+        
+        # Extract lifetime from header bits 11-14
+        lifetime = (unsigned_short >> 11) & 15
+        
+        # Read age (2 bytes)
+        age = struct.unpack_from('>H', data, pos)[0]
+        pos += 2
+        
+        # Read optional origin handle if flag is set
+        origin_handle = None
+        if has_origin_handle_alt:
+            origin_handle = data[pos] & 0xFF
+            pos += 1
+            
+        # Extract payload length from header bits 0-5
+        payload_length = unsigned_short & 63
+        
+        header = {
+            'header_raw': unsigned_short,
+            'command_type': command_type,
+            'origin': origin,
+            'target': target,
+            'lifetime': lifetime,
+            'age': age,
+            'origin_handle': origin_handle,
+            'payload_length': payload_length,
+            'flags': {
+                'has_origin_handle': has_origin_handle,
+                'is_unique': is_unique,
+                'has_session': has_session,
+                'has_origin_handle_alt': has_origin_handle_alt,
+                'flag_1024': flag_1024
+            }
+        }
+        
+        return header, pos
+    
+    @staticmethod
+    def parse_switch_event(header: Dict[str, Any], payload: bytes) -> Optional[Dict[str, Any]]:
+        """
+        Parse switch event according to Android app logic (lines 271-280)
+        
+        The Android app checks:
+        - target & 0xFF == 6 (lower byte of target must be 6)
+        - command_type ordinal must be between 29-36 (FunctionButtonEvent0-7)
+        - payload must have at least 3 bytes
+        """
+        target_type = header['target'] & 0xFF
+        target_unit_id = header['target'] >> 8
+        command_type = header['command_type']
+        
+        # Check if this is a switch event
+        if target_type != 6:
+            return None
+            
+        # Check if command type is in range for button events (29-36)
+        if command_type < 29 or command_type > 36:
+            return None
+            
+        # Check payload length
+        if len(payload) < 3:
+            logger.warning(f"Switch event payload too short: {len(payload)} bytes")
+            return None
+            
+        # Parse according to Android logic
+        first_byte = payload[0]
+        button_index = command_type - 29  # 0-7
+        
+        # Extract parameters from first byte
+        param_p = (first_byte >> 3) & 15  # bits 3-6
+        param_s = first_byte & 7          # bits 0-2
+        state = 1 if (first_byte & 128) else 0  # bit 7
+        
+        return {
+            'unit_id': target_unit_id,
+            'button': button_index,
+            'state': state,  # 1 = pressed, 0 = released
+            'param_p': param_p,
+            'param_s': param_s,
+            'target_type': target_type,
+            'command_type': command_type,
+            'payload_hex': payload.hex(),
+            'android_log': f"Unit {target_unit_id} Switch event: #{button_index} (P{param_p} S{param_s}) = {state}"
+        }
+    
+    @staticmethod
+    def parse_complete_packet(data: bytes) -> Dict[str, Any]:
+        """Parse a complete packet and extract switch events if present"""
+        try:
+            header, payload_start = AndroidPacketParser.parse_packet_header(data)
+            
+            # Read payload
+            payload_length = header['payload_length']
+            if len(data) - payload_start < payload_length:
+                raise ValueError(f"Insufficient data for payload: need {payload_length}, have {len(data) - payload_start}")
+                
+            payload = data[payload_start:payload_start + payload_length]
+            
+            # Try to parse as switch event
+            switch_event = AndroidPacketParser.parse_switch_event(header, payload)
+            
+            return {
+                'header': header,
+                'payload': payload.hex(),
+                'switch_event': switch_event
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to parse packet: {e}")
+            return {'error': str(e), 'data': data.hex()}
+
+
+# Command type constants from EnumC1777d
+class FunctionType:
+    """Function type constants from Android app"""
+    BUTTON_EVENT_0 = 29
+    BUTTON_EVENT_1 = 30
+    BUTTON_EVENT_2 = 31
+    BUTTON_EVENT_3 = 32
+    BUTTON_EVENT_4 = 33
+    BUTTON_EVENT_5 = 34
+    BUTTON_EVENT_6 = 35
+    BUTTON_EVENT_7 = 36
+
+
+def compare_with_current_parser(data: bytes, current_parser_result: Dict[str, Any]) -> Dict[str, Any]:
+    """Compare Android parser results with current implementation"""
+    android_result = AndroidPacketParser.parse_complete_packet(data)
+    
+    comparison = {
+        'android_parser': android_result,
+        'current_parser': current_parser_result,
+        'differences': []
+    }
+    
+    # Compare results
+    if android_result.get('switch_event') and current_parser_result:
+        android_evt = android_result['switch_event']
+        
+        # Check unit_id
+        if android_evt['unit_id'] != current_parser_result.get('unit_id'):
+            comparison['differences'].append({
+                'field': 'unit_id',
+                'android': android_evt['unit_id'],
+                'current': current_parser_result.get('unit_id')
+            })
+            
+        # Check button
+        if android_evt['button'] != current_parser_result.get('button'):
+            comparison['differences'].append({
+                'field': 'button',
+                'android': android_evt['button'],
+                'current': current_parser_result.get('button')
+            })
+            
+        # Map Android state to current event names
+        android_event = 'button_press' if android_evt['state'] == 1 else 'button_release'
+        if android_event != current_parser_result.get('event'):
+            comparison['differences'].append({
+                'field': 'event',
+                'android': android_event,
+                'current': current_parser_result.get('event'),
+                'note': 'Android only has press/release, no hold detection'
+            })
+    
+    return comparison

CasambiBt/_unit.py

@@ -111,6 +111,7 @@ class UnitState:
         self._colorsource: ColorSource | None = None
         self._xy: tuple[float, float] | None = None
         self._slider: int | None = None
+        self._onoff: bool | None = None
 
     def _check_range(
         self, value: int | float, min: int | float, max: int | float
@@ -269,8 +270,20 @@ class UnitState:
     def slider(self) -> None:
         self.slider = None
 
+    @property
+    def onoff(self) -> bool | None:
+        return self._onoff
+
+    @onoff.setter
+    def onoff(self, value: bool) -> None:
+        self._onoff = value
+
+    @onoff.deleter
+    def onoff(self) -> None:
+        self._onoff = None
+
     def __repr__(self) -> str:
-        return f"UnitState(dimmer={self.dimmer}, vertical={self._vertical}, rgb={self.rgb.__repr__()}, white={self.white}, temperature={self.temperature}, colorsource={self.colorsource}, xy={self.xy}, slider={self.slider})"
+        return f"UnitState(dimmer={self.dimmer}, vertical={self._vertical}, rgb={self.rgb.__repr__()}, white={self.white}, temperature={self.temperature}, colorsource={self.colorsource}, xy={self.xy}, slider={self.slider}, onoff={self.onoff})"
 
 
 # TODO: Make unit immutable (refactor state, on, online out of it)
@@ -308,6 +321,8 @@ class Unit:
     @property
     def is_on(self) -> bool:
         """Determine whether the unit is turned on."""
+        if self.unitType.get_control(UnitControlType.ONOFF) and self._state:
+            return self._on and self._state.onoff is True
         if self.unitType.get_control(UnitControlType.DIMMER) and self._state:
             return (
                 self._on and self._state.dimmer is not None and self._state.dimmer > 0
@@ -385,6 +400,8 @@ class Unit:
             elif c.type == UnitControlType.SLIDER and state.slider is not None:
                 scale = UnitState.SLIDER_RESOLUTION - c.length
                 scaledValue = state.slider >> scale
+            elif c.type == UnitControlType.ONOFF and state.onoff is not None:
+                scaledValue = 1 if state.onoff else 0
 
             # Use default if unsupported type or unset value in state
             else:
@@ -477,6 +494,8 @@ class Unit:
             elif c.type == UnitControlType.SLIDER:
                 scale = UnitState.SLIDER_RESOLUTION - c.length
                 self._state.slider = cInt << scale
+            elif c.type == UnitControlType.ONOFF:
+                self._state.onoff = cInt != 0
             elif c.type == UnitControlType.UNKOWN:
                 # Might be useful for implementing more state types
                 _LOGGER.debug(

{casambi_bt_revamped-0.3.7.dev3.dist-info → casambi_bt_revamped-0.3.7.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.7.dev3
+Version: 0.3.7.dev5
 Summary: Enhanced Casambi Bluetooth client library with switch event support
 Home-page: https://github.com/rankjie/casambi-bt
 Author: rankjie
@@ -46,7 +46,7 @@ Have a look at `demo.py` for a small example.
 
 ### Switch Event Support
 
-This library now supports receiving switch button events:
+This fork adds support for receiving switch button events:
 
 ```python
 from CasambiBt import Casambi

{casambi_bt_revamped-0.3.7.dev3.dist-info → casambi_bt_revamped-0.3.7.dev5.dist-info}/RECORD

@@ -1,18 +1,19 @@
 CasambiBt/__init__.py,sha256=TW445xSu5PV3TyMjJfwaA1JoWvQQ8LXhZgGdDTfWf3s,302
 CasambiBt/_cache.py,sha256=KZ2xbiHAHXUPa8Gw_75Nw9NL4QSY_sTWHbyYXYUDaB0,3865
-CasambiBt/_casambi.py,sha256=tQgmG-8lHbl4_FDS7NwPrucrqcQZd2kimcJa43TYFaw,23156
-CasambiBt/_client.py,sha256=2kHgkf3ERobTDF47ZMNSFl5WrEkWYgDSXfh6R6PsU0Q,28926
+CasambiBt/_casambi.py,sha256=gLLkhEcObgapqTx5Mk7WRClyG29UyfZYZCCIhhOg4H4,23101
+CasambiBt/_client.py,sha256=zjenWQE6EuedFJS87HunDvFLYZnnIO-BmM-zqqXfX1Q,38235
+CasambiBt/_client_android_parser.py,sha256=1lVkVYMO0Nhh9_nkNwgb68hlCS_uD8WxYQDir5hOdHs,7744
 CasambiBt/_constants.py,sha256=_AxkG7Btxl4VeS6mO7GJW5Kc9dFs3s9sDmtJ83ZEKNw,359
 CasambiBt/_discover.py,sha256=H7HpiFYIy9ELvmPXXd_ck-5O5invJf15dDIRk-vO5IE,1696
 CasambiBt/_encryption.py,sha256=CLcoOOrggQqhJbnr_emBnEnkizpWDvb_0yFnitq4_FM,3831
 CasambiBt/_keystore.py,sha256=Jdiq0zMPDmhfpheSojKY6sTUpmVrvX_qOyO7yCYd3kw,2788
 CasambiBt/_network.py,sha256=qcsWn_EsBexzXCv14JcpSIymhuR6Eaf479lZdzpfYBM,14417
 CasambiBt/_operation.py,sha256=-BuC1Bvtg-G-zSN_b_0JMvXdHZaR6LbTw0S425jg96c,842
-CasambiBt/_unit.py,sha256=M-Q8-Xd3qjJSUEvsFtic8E4xDc_gtWYakbTGyoIA-P8,16377
+CasambiBt/_unit.py,sha256=YiQWoHmMDWHHo4XAjtW8rHsBqIqpmp9MVdv1Mbu2xw4,17043
 CasambiBt/errors.py,sha256=0JgDjaKlAKDes0poWzA8nrTUYQ8qdNfBb8dfaqqzCRA,1664
 CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-casambi_bt_revamped-0.3.7.dev3.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
-casambi_bt_revamped-0.3.7.dev3.dist-info/METADATA,sha256=grmzh3IRXluM845lDfwqMJHeP-2QlqslRyOI-wlebAk,3048
-casambi_bt_revamped-0.3.7.dev3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-casambi_bt_revamped-0.3.7.dev3.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
-casambi_bt_revamped-0.3.7.dev3.dist-info/RECORD,,
+casambi_bt_revamped-0.3.7.dev5.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
+casambi_bt_revamped-0.3.7.dev5.dist-info/METADATA,sha256=bVPa_6JqEvAHMjmUZbdjpb2T0bElv2uA69OIQQvZ7Aw,3049
+casambi_bt_revamped-0.3.7.dev5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+casambi_bt_revamped-0.3.7.dev5.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
+casambi_bt_revamped-0.3.7.dev5.dist-info/RECORD,,