casambi-bt-revamped 0.3.12.dev10__tar.gz → 0.3.12.dev12__tar.gz

{casambi_bt_revamped-0.3.12.dev10/src/casambi_bt_revamped.egg-info → casambi_bt_revamped-0.3.12.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.12.dev10
+Version: 0.3.12.dev12
 Summary: Forked Casambi Bluetooth client library with switch event support, use original if no special need. https://github.com/lkempf/casambi-bt
 Home-page: https://github.com/rankjie/casambi-bt
 Author: rankjie

{casambi_bt_revamped-0.3.12.dev10 → casambi_bt_revamped-0.3.12.dev12}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = casambi-bt-revamped
-version = 0.3.12.dev10
+version = 0.3.12.dev12
 author = rankjie
 author_email = rankjie@gmail.com
 description = Forked Casambi Bluetooth client library with switch event support, use original if no special need. https://github.com/lkempf/casambi-bt

{casambi_bt_revamped-0.3.12.dev10 → casambi_bt_revamped-0.3.12.dev12}/src/CasambiBt/_casambi.py

@@ -169,10 +169,15 @@ class Casambi:
         self._casaClient = cast(CasambiClient, self._casaClient)
         await self._casaClient.connect()
         try:
-            # EVO requires key exchange + authenticate; Classic is ready after `connect()`.
             if self._casaClient.protocolMode == ProtocolMode.EVO:
+                # EVO requires key exchange + authenticate.
                 await self._casaClient.exchangeKey()
                 await self._casaClient.authenticate()
+            elif self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+                # Classic needs an init write to trigger state broadcasts.
+                # In EVO the key exchange/auth handshake implicitly signals the
+                # device; Classic has no such handshake so we send a time-sync.
+                await self._casaClient.classicSendInit()
         except ProtocolError as e:
             await self._casaClient.disconnect()
             raise e

{casambi_bt_revamped-0.3.12.dev10 → casambi_bt_revamped-0.3.12.dev12}/src/CasambiBt/_client.py

@@ -159,6 +159,7 @@ class CasambiClient:
         self._classicRxType9 = 0
         self._classicRxCmdStream = 0
         self._classicRxUnknown = 0
+        self._classicRxClassicStates = 0
         # Per-kind sample counters to ensure we emit at least a few examples for reverse engineering.
         self._classicRxKindSamples: dict[str, int] = {}
         self._classicRxLastStatsTs = time.monotonic()
@@ -437,6 +438,7 @@ class CasambiClient:
                     self._network.classicManagerKey() is not None,
                     getattr(self._network, "isManager", lambda: False)(),
                 )
+                await self._classicEnumerateAndSubscribeGatt(notify_kwargs)
                 _log_probe_summary("CLASSIC", classic_variant="ca52_legacy")
                 # Emit a warning if we never see Classic RX frames; this is a common failure mode.
                 self._classicNoRxTask = asyncio.create_task(self._classic_no_rx_watchdog(30.0))
@@ -592,6 +594,7 @@ class CasambiClient:
                 self._network.classicManagerKey() is not None,
                 getattr(self._network, "isManager", lambda: False)(),
             )
+            await self._classicEnumerateAndSubscribeGatt(notify_kwargs)
             _log_probe_summary("CLASSIC", classic_variant="auth_uuid_conformant")
             self._classicNoRxTask = asyncio.create_task(self._classic_no_rx_watchdog(30.0))
             return
@@ -1222,6 +1225,132 @@ class CasambiClient:
                 len(pkt),
             )
 
+    async def _classicEnumerateAndSubscribeGatt(
+        self, notify_kwargs: dict[str, Any]
+    ) -> None:
+        """Enumerate all GATT characteristics and subscribe to any notifiable ones.
+
+        This discovers characteristics beyond the manually-probed CA51/CA52/CA53
+        UUIDs and subscribes to any that support notify or indicate, which may be
+        needed for receiving Classic state/config notifications.
+        """
+        try:
+            total_chars = 0
+            for svc in self._gattClient.services:
+                for char in svc.characteristics:
+                    total_chars += 1
+                    char_uuid = str(char.uuid).lower()
+                    props = char.properties
+                    self._logger.warning(
+                        "[CASAMBI_CLASSIC_GATT_CHAR] uuid=%s props=%s handle=%d",
+                        char_uuid,
+                        props,
+                        char.handle,
+                    )
+                    if char_uuid not in self._classicNotifyCharUuids:
+                        if "notify" in props or "indicate" in props:
+                            try:
+                                await self._gattClient.start_notify(
+                                    char.uuid,
+                                    self._queueCallback,
+                                    **notify_kwargs,
+                                )
+                                self._classicNotifyCharUuids.add(char_uuid)
+                                self._logger.warning(
+                                    "[CASAMBI_CLASSIC_GATT_SUB] subscribed uuid=%s",
+                                    char_uuid,
+                                )
+                            except Exception as e:
+                                self._logger.warning(
+                                    "[CASAMBI_CLASSIC_GATT_SUB] failed uuid=%s err=%s",
+                                    char_uuid,
+                                    type(e).__name__,
+                                )
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_GATT_ENUM] total_chars=%d subscribed_uuids=%s",
+                total_chars,
+                sorted(self._classicNotifyCharUuids),
+            )
+        except Exception as e:
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_GATT_ENUM] services enumeration unavailable: %s",
+                type(e).__name__,
+            )
+
+    async def classicSendInit(self) -> None:
+        """Send Classic post-connection initialization (time-sync).
+
+        Ground truth: casambi-android AbstractC1717h.X() (lines 254-345).
+        The Android app sends this as the first packet after Classic connection.
+        In EVO, the key exchange/auth handshake implicitly signals the device;
+        Classic has no such handshake, so an explicit init write is needed to
+        trigger the device to start broadcasting state notifications.
+
+        The payload is sent raw via _sendClassic (NOT wrapped in buildClassicCommand).
+        """
+        self._checkState(ConnectionState.AUTHENTICATED)
+        if self._protocolMode != ProtocolMode.CLASSIC:
+            return
+
+        import datetime as _dt
+
+        now = _dt.datetime.now()
+
+        # Timezone offset in minutes from UTC.
+        local_tz = _dt.datetime.now(_dt.timezone.utc).astimezone().tzinfo
+        utc_offset_minutes = 0
+        if local_tz is not None:
+            offset = local_tz.utcoffset(now)
+            if offset is not None:
+                utc_offset_minutes = int(offset.total_seconds()) // 60
+
+        # Build the time-sync payload.
+        # Format: [10][year:2BE][month:1][day:1][hour:1][min:1][sec:1]
+        #         [tz_offset:2BE signed][dst_transition:4BE][dst_change:1]
+        #         [timestamp1:3BE][timestamp2:3BE][zero:2][millis:3BE][extra:1]
+        payload = bytearray()
+        payload.append(10)  # Classic time-sync command byte
+        payload.extend(struct.pack(">H", now.year))
+        payload.append(now.month)
+        payload.append(now.day)
+        payload.append(now.hour)
+        payload.append(now.minute)
+        payload.append(now.second)
+        payload.extend(struct.pack(">h", utc_offset_minutes))
+        # DST transition data and change minutes (0 = no DST info).
+        payload.extend(struct.pack(">I", 0))
+        payload.append(0)
+        # Classic extra bytes: timestamps, zero short, millis, trailing byte.
+        # Android AbstractC1717h.X() lines 323-328: j() = 3-byte big-endian write
+        # (Q2.t.java:59-63), NOT 4-byte. Plus trailing writeByte(iK0 >> 24).
+        ts1 = 0  # Q2.r.K0(network.V) — start with 0
+        ts2 = 0  # Q2.r.K0(network.W) — start with 0
+        for ts in (ts1, ts2):
+            payload.append((ts >> 16) & 0xFF)
+            payload.append((ts >> 8) & 0xFF)
+            payload.append(ts & 0xFF)
+        payload.extend(struct.pack(">H", 0))  # writeShort(0)
+        millis_val = now.microsecond // 1000 * 1000
+        payload.append((millis_val >> 16) & 0xFF)
+        payload.append((millis_val >> 8) & 0xFF)
+        payload.append(millis_val & 0xFF)
+        payload.append((ts1 >> 24) & 0xFF)  # writeByte(iK0 >> 24)
+
+        self._logger.warning(
+            "[CASAMBI_CLASSIC_INIT] sending time-sync len=%d hex=%s",
+            len(payload),
+            b2a(bytes(payload)),
+        )
+
+        try:
+            await self._sendClassic(bytes(payload))
+            self._logger.warning("[CASAMBI_CLASSIC_INIT] time-sync sent successfully")
+        except Exception:
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_INIT] time-sync send failed",
+                exc_info=True,
+            )
+
     def _establishedNofityCallback(
         self, handle: BleakGATTCharacteristic, data: bytes
     ) -> None:
@@ -1579,7 +1708,7 @@ class CasambiClient:
             self._classicRxLastStatsTs = now
             self._logger.warning(
                 "[CASAMBI_CLASSIC_RX_STATS] frames=%d verified=%d unverifiable=%d parse_fail=%d header=%s "
-                "type6=%d type7=%d type9=%d cmdstream=%d unknown=%d",
+                "type6=%d type7=%d type9=%d cmdstream=%d unknown=%d classic_states=%d",
                 self._classicRxFrames,
                 self._classicRxVerified,
                 self._classicRxUnverifiable,
@@ -1590,8 +1719,17 @@ class CasambiClient:
                 self._classicRxType9,
                 self._classicRxCmdStream,
                 self._classicRxUnknown,
+                self._classicRxClassicStates,
             )
 
+        # Classic payloads use a completely different format from EVO.
+        # Classic: byte 0 is a type indicator (0=netconfig, 255=log, else=unit_id).
+        # EVO: byte 0 is a packet type (6=UnitState, 7=Switch, 9=NetConfig).
+        # Dispatch Classic through its own parser to avoid misinterpretation.
+        if self._protocolMode == ProtocolMode.CLASSIC:
+            self._dispatchClassicPayload(payload)
+            return
+
         # If the payload starts with a known EVO packet type, reuse existing parsers.
         packet_type = payload[0]
         if packet_type in (IncommingPacketType.UnitState, IncommingPacketType.SwitchEvent, IncommingPacketType.NetworkConfig):
@@ -1702,6 +1840,146 @@ class CasambiClient:
                 b2a(payload[pos:]),
             )
 
+    def _dispatchClassicPayload(self, payload: bytes) -> None:
+        """Dispatch a verified Classic payload based on its type indicator.
+
+        Classic payloads (from C1751c.V()) use a different format from EVO:
+        - byte 0 == 0: network config data
+        - byte 0 == 255: log message
+        - otherwise: unit state stream (byte 0 is the first unit_id)
+        """
+        if not payload:
+            return
+
+        first_byte = payload[0]
+
+        # Log full payload for the first 10 Classic payloads regardless of type.
+        if self._classicRxClassicStates < 10:
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_DISPATCH] #%d type_byte=%d len=%d hex=%s",
+                self._classicRxClassicStates,
+                first_byte,
+                len(payload),
+                b2a(payload[: min(len(payload), 64)]).decode("ascii")
+                + ("..." if len(payload) > 64 else ""),
+            )
+
+        if first_byte == 0:
+            self._logger.debug("[CASAMBI_CLASSIC_NETCONFIG] len=%d", len(payload))
+            return
+
+        if first_byte == 255:
+            self._logger.debug("[CASAMBI_CLASSIC_LOG] len=%d", len(payload))
+            return
+
+        # Unit state stream: entire payload is passed (first byte is the first unit_id).
+        self._classicRxClassicStates += 1
+        self._parseClassicUnitStates(payload)
+
+    def _parseClassicUnitStates(self, data: bytes) -> None:
+        """Parse Classic unit state records.
+
+        Ground truth: casambi-android C1751c.V() (line 301+).
+        Format is completely different from EVO _parseUnitStates:
+        - flags lower nibble = state_len (EVO uses a separate byte)
+        - flags bit 5 = extra1 present, bit 6 = extra2 present, bit 7 = offline
+        - unit_id 0xF0 = command response (skip)
+        """
+        self._logger.debug("Parsing Classic unit states...")
+        if self._logger.isEnabledFor(logging.DEBUG):
+            self._logger.debug("[CASAMBI_CLASSIC_STATES_RAW] len=%d hex=%s", len(data), b2a(data))
+
+        pos = 0
+        old_pos = 0
+        records_parsed = 0
+        try:
+            while pos + 2 <= len(data):
+                unit_id = data[pos]
+                flags = data[pos + 1]
+                pos += 2
+
+                state_len = flags & 0x0F
+                has_extra1 = (flags & 0x20) != 0
+                has_extra2 = (flags & 0x40) != 0
+                is_offline = (flags & 0x80) != 0
+
+                # 0xF0 = command response record, skip state_len bytes.
+                if unit_id == 0xF0:
+                    pos += state_len
+                    continue
+
+                extra1 = 0
+                if has_extra1:
+                    if pos >= len(data):
+                        break
+                    extra1 = data[pos]
+                    pos += 1
+
+                extra2 = 0
+                if has_extra2:
+                    if pos >= len(data):
+                        break
+                    extra2 = data[pos]
+                    pos += 1
+
+                if pos + state_len > len(data):
+                    break
+
+                state = data[pos : pos + state_len]
+                pos += state_len
+                records_parsed += 1
+
+                # Log the first few parsed records at WARNING level for tester visibility.
+                if records_parsed <= 10 or self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.warning(
+                        "[CASAMBI_CLASSIC_STATE_PARSED] unit=%d flags=0x%02x state_len=%d "
+                        "offline=%s extra1=%d extra2=%d state=%s",
+                        unit_id,
+                        flags,
+                        state_len,
+                        is_offline,
+                        extra1,
+                        extra2,
+                        b2a(state),
+                    )
+
+                online = not is_offline
+                # Let Unit.is_on derive actual on/off from state bytes (dimmer, onoff).
+                on = True
+
+                self._dataCallback(
+                    IncommingPacketType.UnitState,
+                    {
+                        "id": unit_id,
+                        "online": online,
+                        "on": on,
+                        "state": state,
+                        "flags": flags,
+                        "prio": 0,
+                        "state_len": state_len,
+                        "padding_len": 0,
+                        "con": None,
+                        "sid": None,
+                        "extra_byte": extra1,
+                        "extra_float": extra1 / 255.0 if extra1 else 0.0,
+                    },
+                )
+
+                old_pos = pos
+        except IndexError:
+            self._logger.error(
+                "Ran out of data while parsing Classic unit state! Remaining data %s in %s.",
+                b2a(data[old_pos:]),
+                b2a(data),
+            )
+
+        if records_parsed > 0:
+            self._logger.debug(
+                "[CASAMBI_CLASSIC_STATES_DONE] records=%d remaining=%d",
+                records_parsed,
+                len(data) - pos,
+            )
+
     def _parseUnitStates(self, data: bytes) -> None:
         # Ground truth: casambi-android `v1.C1775b.V(Q2.h)` parses decrypted packet type=6
         # as a stream of unit state records. Records have optional bytes depending on flags.

{casambi_bt_revamped-0.3.12.dev10 → casambi_bt_revamped-0.3.12.dev12}/src/CasambiBt/_version.py

@@ -7,4 +7,4 @@ Avoid using importlib.metadata in hot paths by providing a static version string
 __all__ = ["__version__"]
 
 # NOTE: Must match `casambi-bt/setup.cfg` [metadata] version.
-__version__ = "0.3.12.dev10"
+__version__ = "0.3.12.dev12"

{casambi_bt_revamped-0.3.12.dev10 → casambi_bt_revamped-0.3.12.dev12/src/casambi_bt_revamped.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.12.dev10
+Version: 0.3.12.dev12
 Summary: Forked Casambi Bluetooth client library with switch event support, use original if no special need. https://github.com/lkempf/casambi-bt
 Home-page: https://github.com/rankjie/casambi-bt
 Author: rankjie