casambi-bt-revamped 0.3.7.dev5__py3-none-any.whl → 0.3.7.dev6__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 h in self._switchEventCallbacks:
+            for switch_handler in self._switchEventCallbacks:
                 try:
-                    h(data)
+                    switch_handler(data)
                 except Exception:
                     self._logger.error(
-                        f"Exception occurred in switchEventCallback {h}.",
+                        f"Exception occurred in switchEventCallback {switch_handler}.",
                         exc_info=True,
                     )
         else:
@@ -457,7 +457,9 @@ 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.
@@ -474,7 +476,9 @@ 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

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 import struct
-from binascii import b2a_hex as b2a
+from binascii import b2a_hex as b2a, hexlify
 from collections.abc import Callable
 from enum import IntEnum, unique
 from hashlib import sha256
@@ -33,12 +33,6 @@ 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):
@@ -420,36 +414,34 @@ class CasambiClient:
     ) -> None:
         # TODO: Check incoming counter and direction flag
         self._inPacketCount += 1
-        
-        # Store raw encrypted packet for Android parser analysis
+
+        # Store raw encrypted packet for reference
         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.
+        # Log raw encrypted packet with special marker for easy filtering
+        self._logger.info(f"[CASAMBI_RAW_PACKET] Encrypted #{self._inPacketCount}: {b2a(raw_encrypted_packet)}")
 
         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)}")
+        
+        # Log decrypted packet with special marker
+        self._logger.info(f"[CASAMBI_DECRYPTED] Type={packetType} #{self._inPacketCount}: {b2a(decrypted_data)}")
 
         if packetType == IncommingPacketType.UnitState:
             self._parseUnitStates(decrypted_data[1:])
         elif packetType == IncommingPacketType.SwitchEvent:
-            self._parseSwitchEvent(decrypted_data[1:], self._inPacketCount, raw_encrypted_packet, android_switch_event)
+            self._parseSwitchEvent(
+                decrypted_data[1:], self._inPacketCount, raw_encrypted_packet
+            )
         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.
@@ -503,32 +495,45 @@ 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, 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)}")
+    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)}"
+        )
         
+        # Log complete packet structure with marker
+        self._logger.info(f"[CASAMBI_SWITCH_PACKET] Full data #{packet_seq}: hex={b2a(data)} len={len(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
-        
+        all_messages_found = []
+
         try:
             while pos <= len(data) - 3:
                 oldPos = pos
-                
+
                 # Parse message header
                 message_type = data[pos]
                 flags = data[pos + 1]
                 length = ((data[pos + 2] >> 4) & 15) + 1
                 parameter = data[pos + 2]  # Full byte, not just lower 4 bits
                 pos += 3
+                
+                # Log every message found with detailed structure
+                self._logger.info(
+                    f"[CASAMBI_MSG_FOUND] At pos={oldPos}: type=0x{message_type:02x} flags=0x{flags:02x} "
+                    f"len={length} param=0x{parameter:02x}"
+                )
 
                 # Sanity check: message type should be reasonable
                 if message_type > 0x80:
@@ -550,45 +555,41 @@ class CasambiClient:
                 # Extract the payload
                 payload = data[pos : pos + length]
                 pos += length
+                
+                # Log the payload
+                self._logger.info(
+                    f"[CASAMBI_MSG_PAYLOAD] Type 0x{message_type:02x} payload: {b2a(payload)} "
+                    f"(bytes {oldPos+3} to {oldPos+3+length-1})"
+                )
+                
+                # Track all messages
+                all_messages_found.append({
+                    'type': message_type,
+                    'pos': oldPos,
+                    'flags': flags,
+                    'param': parameter,
+                    'payload': b2a(payload)
+                })
 
                 # Process based on message type
                 if message_type == 0x08 or message_type == 0x10:  # Switch/button events
                     switch_events_found += 1
-                    
-                    # 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
+                    # 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
                         self._logger.debug(
-                            f"[TYPE 0x08 ANALYSIS] parameter=0x{parameter:02x}, "
-                            f"lower_nibble={button_lower}, upper_nibble={button_upper}"
+                            f"EVO button extraction: parameter=0x{parameter:02x}, using upper nibble, button={button}"
                         )
-                        
-                        # 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:
-                        # Type 0x10: Standard extraction from lower nibble
-                        button = parameter & 0x0F
+                        button = button_lower
                         self._logger.debug(
-                            f"[TYPE 0x10] Button extraction: parameter=0x{parameter:02x}, button={button}"
+                            f"EVO button extraction: parameter=0x{parameter:02x}, using lower nibble, 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
@@ -596,11 +597,20 @@ 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, android_switch_event)
+                    self._processSwitchMessage(
+                        message_type,
+                        flags,
+                        button,
+                        payload,
+                        full_message_data,
+                        oldPos,
+                        packet_seq,
+                        raw_packet,
+                    )
                 elif message_type == 0x29:
                     # This shouldn't happen due to check above, but just in case
-                    self._logger.debug(f"Ignoring embedded type 0x29 message")
-                elif message_type in [0x00, 0x06, 0x09, 0x1f, 0x2a]:
+                    self._logger.debug("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}, "
@@ -620,83 +630,21 @@ class CasambiClient:
                 f"Ran out of data while parsing switch event packet! "
                 f"Remaining data {b2a(data[oldPos:])} in {b2a(data)}."
             )
-            
+
+        # Log summary of all messages found
+        self._logger.info(
+            f"[CASAMBI_PARSE_SUMMARY] Packet #{packet_seq}: Found {len(all_messages_found)} messages, "
+            f"{switch_events_found} switch events"
+        )
+        for i, msg in enumerate(all_messages_found):
+            self._logger.info(
+                f"[CASAMBI_MSG_{i+1}] Type=0x{msg['type']:02x} Pos={msg['pos']} "
+                f"Flags=0x{msg['flags']:02x} Param=0x{msg['param']:02x} Payload={msg['payload']}"
+            )
+
         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,
@@ -717,14 +665,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]
@@ -736,91 +684,50 @@ 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, including battery-powered switches
+            # This applies to all units, not just unit 31
             # 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:
-                    # 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)}"
+                    self._logger.debug(
+                        f"Type 0x10: Unknown state byte 0x{state_byte:02x} at message pos {state_pos}"
                     )
-                    
-                    # 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
+                    # Fallback: check if extra_data starts with 0x12 (indicates release)
+                    if len(extra_data) >= 1 and extra_data[0] == 0x12:
+                        event_string = "button_release"
                     else:
-                        event_string = "button_press"  # Default to press when no extra data
+                        event_string = "button_press"
             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 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)")
+                    self._logger.debug(
+                        "Type 0x10: Using extra_data pattern for release detection"
+                    )
                 else:
-                    event_string = "button_press"  # Default to press
-                    self._logger.debug("[TYPE 0x10 STATE] Defaulting to press (short message)")
+                    # Cannot determine state
+                    self._logger.warning(
+                        f"Type 0x10 message missing state info, unit_id={unit_id}, payload={b2a(payload)}"
+                    )
+                    event_string = "unknown"
 
         action_display = f"{action:#04x}" if action is not None else "N/A"
 
@@ -828,31 +735,14 @@ 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}"
         )
-        
-        # 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
+
+        # Log detailed info about type 0x08 messages before filtering
         if message_type == 0x08:
+            self._logger.info(
+                f"[CASAMBI_TYPE08_FILTERED] Type 0x08 event detected: button={button}, unit_id={unit_id}, "
+                f"action={action_display}, event={event_string}, flags=0x{flags:02x}, "
+                f"payload={hexlify(payload).decode()}, extra_data={hexlify(extra_data).decode() if extra_data else 'none'}"
+            )
             self._logger.debug(
                 f"Filtering out type 0x08 event: button={button}, unit_id={unit_id}, "
                 f"action={action_display}, flags=0x{flags:02x}"
@@ -869,13 +759,11 @@ 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/_unit.py

@@ -111,7 +111,6 @@ 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
@@ -270,20 +269,8 @@ 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}, onoff={self.onoff})"
+        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})"
 
 
 # TODO: Make unit immutable (refactor state, on, online out of it)
@@ -321,8 +308,6 @@ 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
@@ -400,8 +385,6 @@ 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:
@@ -494,8 +477,6 @@ 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.dev5.dist-info → casambi_bt_revamped-0.3.7.dev6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.7.dev5
+Version: 0.3.7.dev6
 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 fork adds support for receiving switch button events:
+This library now supports receiving switch button events:
 
 ```python
 from CasambiBt import Casambi

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

@@ -1,19 +1,18 @@
 CasambiBt/__init__.py,sha256=TW445xSu5PV3TyMjJfwaA1JoWvQQ8LXhZgGdDTfWf3s,302
 CasambiBt/_cache.py,sha256=KZ2xbiHAHXUPa8Gw_75Nw9NL4QSY_sTWHbyYXYUDaB0,3865
-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/_casambi.py,sha256=tQgmG-8lHbl4_FDS7NwPrucrqcQZd2kimcJa43TYFaw,23156
+CasambiBt/_client.py,sha256=lcF6N8QoVBOvtYK8EAND6emAdIVHutLTzA_A3l1wTng,31235
 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=YiQWoHmMDWHHo4XAjtW8rHsBqIqpmp9MVdv1Mbu2xw4,17043
+CasambiBt/_unit.py,sha256=M-Q8-Xd3qjJSUEvsFtic8E4xDc_gtWYakbTGyoIA-P8,16377
 CasambiBt/errors.py,sha256=0JgDjaKlAKDes0poWzA8nrTUYQ8qdNfBb8dfaqqzCRA,1664
 CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-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,,
+casambi_bt_revamped-0.3.7.dev6.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
+casambi_bt_revamped-0.3.7.dev6.dist-info/METADATA,sha256=urbfHAz9maj1P6cTNorhXeSrphA6waC3Hu_jD00CUns,3048
+casambi_bt_revamped-0.3.7.dev6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+casambi_bt_revamped-0.3.7.dev6.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
+casambi_bt_revamped-0.3.7.dev6.dist-info/RECORD,,

CasambiBt/_client_android_parser.py

@@ -1,215 +0,0 @@
-"""
-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