lifx-emulator 1.0.0__py3-none-any.whl

lifx_emulator/handlers/multizone_handlers.py

@@ -0,0 +1,249 @@
+"""MultiZone packet handlers."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from lifx_emulator.handlers.base import PacketHandler
+from lifx_emulator.protocol.packets import MultiZone
+from lifx_emulator.protocol.protocol_types import (
+    LightHsbk,
+    MultiZoneEffectParameter,
+    MultiZoneEffectSettings,
+    MultiZoneEffectType,
+)
+
+if TYPE_CHECKING:
+    from lifx_emulator.device import DeviceState
+
+logger = logging.getLogger(__name__)
+
+
+class GetColorZonesHandler(PacketHandler):
+    """Handle MultiZoneGetColorZones (502) -> StateMultiZone (506) packets."""
+
+    PKT_TYPE = MultiZone.GetColorZones.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: MultiZone.GetColorZones | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if not device_state.has_multizone:
+            return []
+
+        start_index = packet.start_index if packet else 0
+        end_index = packet.end_index if packet else 0
+
+        # Return multiple StateMultiZone packets, each containing up to 8 zones
+        responses = []
+
+        # Send packets of up to 8 zones each (StateMultiZone format)
+        index = start_index
+        while index <= end_index and index < device_state.zone_count:
+            # Collect up to 8 zones for this packet
+            colors = []
+            for i in range(8):
+                zone_index = index + i
+                if zone_index < device_state.zone_count and zone_index <= end_index:
+                    zone_color = (
+                        device_state.zone_colors[zone_index]
+                        if zone_index < len(device_state.zone_colors)
+                        else LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+                    )
+                    colors.append(zone_color)
+                else:
+                    # Pad remaining slots with black
+                    colors.append(
+                        LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+                    )
+
+            # Pad to exactly 8 colors
+            while len(colors) < 8:
+                colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
+
+            packet_obj = MultiZone.StateMultiZone(
+                count=device_state.zone_count, index=index, colors=colors
+            )
+            responses.append(packet_obj)
+
+            index += 8
+
+        return responses
+
+
+class SetColorZonesHandler(PacketHandler):
+    """Handle MultiZoneSetColorZones (501)."""
+
+    PKT_TYPE = MultiZone.SetColorZones.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: MultiZone.SetColorZones | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if not device_state.has_multizone:
+            return []
+
+        if packet:
+            start_index = packet.start_index
+            end_index = packet.end_index
+
+            # Update zone colors
+            for i in range(start_index, min(end_index + 1, device_state.zone_count)):
+                if i < len(device_state.zone_colors):
+                    device_state.zone_colors[i] = packet.color
+
+            logger.info(
+                f"MultiZone set zones {start_index}-{end_index} to color, "
+                f"duration={packet.duration}ms"
+            )
+
+        if res_required and packet:
+            # Create a GetColorZones packet to reuse the get handler
+            get_packet = MultiZone.GetColorZones(
+                start_index=packet.start_index, end_index=packet.end_index
+            )
+            # Reuse GetColorZonesHandler
+            handler = GetColorZonesHandler()
+            return handler.handle(device_state, get_packet, res_required)
+        return []
+
+
+class ExtendedGetColorZonesHandler(PacketHandler):
+    """Handle MultiZoneExtendedGetColorZones (511) -> ExtendedStateMultiZone (512)."""
+
+    PKT_TYPE = MultiZone.ExtendedGetColorZones.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_multizone:
+            return []
+
+        colors_count = min(82, len(device_state.zone_colors))
+        colors = []
+        for i in range(colors_count):
+            colors.append(device_state.zone_colors[i])
+        # Pad to 82 colors
+        while len(colors) < 82:
+            colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
+
+        return [
+            MultiZone.ExtendedStateMultiZone(
+                count=device_state.zone_count,
+                index=0,
+                colors_count=colors_count,
+                colors=colors,
+            )
+        ]
+
+
+class ExtendedSetColorZonesHandler(PacketHandler):
+    """Handle MultiZoneExtendedSetColorZones (510)."""
+
+    PKT_TYPE = MultiZone.ExtendedSetColorZones.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: MultiZone.ExtendedSetColorZones | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if not device_state.has_multizone:
+            return []
+
+        if packet:
+            # Update zone colors from packet
+            for i, color in enumerate(packet.colors[: packet.colors_count]):
+                zone_index = packet.index + i
+                if zone_index < len(device_state.zone_colors):
+                    device_state.zone_colors[zone_index] = color
+
+            logger.info(
+                f"MultiZone extended set {packet.colors_count} zones "
+                f"from index {packet.index}, duration={packet.duration}ms"
+            )
+
+        if res_required:
+            handler = ExtendedGetColorZonesHandler()
+            return handler.handle(device_state, None, res_required)
+        return []
+
+
+class GetEffectHandler(PacketHandler):
+    """Handle MultiZoneGetEffect (507) -> StateEffect (509)."""
+
+    PKT_TYPE = MultiZone.GetEffect.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_multizone:
+            return []
+
+        # Create effect settings
+        parameter = MultiZoneEffectParameter(
+            parameter0=0,
+            parameter1=0,
+            parameter2=0,
+            parameter3=0,
+            parameter4=0,
+            parameter5=0,
+            parameter6=0,
+            parameter7=0,
+        )
+        settings = MultiZoneEffectSettings(
+            instanceid=0,
+            type=MultiZoneEffectType(device_state.multizone_effect_type),
+            speed=device_state.multizone_effect_speed * 1000,  # convert to milliseconds
+            duration=0,  # infinite
+            parameter=parameter,
+        )
+
+        return [MultiZone.StateEffect(settings=settings)]
+
+
+class SetEffectHandler(PacketHandler):
+    """Handle MultiZoneSetEffect (508) -> StateEffect (509)."""
+
+    PKT_TYPE = MultiZone.SetEffect.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: MultiZone.SetEffect | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if not device_state.has_multizone:
+            return []
+
+        if packet:
+            device_state.multizone_effect_type = int(packet.settings.type)
+            device_state.multizone_effect_speed = (
+                packet.settings.speed // 1000
+            )  # convert to seconds
+
+            logger.info(
+                f"MultiZone effect set: type={packet.settings.type}, "
+                f"speed={packet.settings.speed}ms"
+            )
+
+        if res_required:
+            handler = GetEffectHandler()
+            return handler.handle(device_state, None, res_required)
+        return []
+
+
+# List of all multizone handlers for easy registration
+ALL_MULTIZONE_HANDLERS = [
+    GetColorZonesHandler(),
+    SetColorZonesHandler(),
+    ExtendedGetColorZonesHandler(),
+    ExtendedSetColorZonesHandler(),
+    GetEffectHandler(),
+    SetEffectHandler(),
+]

lifx_emulator/handlers/registry.py

@@ -0,0 +1,110 @@
+"""Handler registry for managing packet handlers."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lifx_emulator.handlers.base import PacketHandler
+
+logger = logging.getLogger(__name__)
+
+
+class HandlerRegistry:
+    """Registry for packet handlers using Strategy pattern.
+
+    The registry maps packet type numbers to handler instances.
+    Handlers can be registered individually or in bulk.
+
+    Example:
+        >>> registry = HandlerRegistry()
+        >>> registry.register(GetServiceHandler())
+        >>> handler = registry.get_handler(2)  # Device.GetService
+        >>> response = handler.handle(device_state, None, True)
+    """
+
+    def __init__(self):
+        """Initialize an empty handler registry."""
+        self._handlers: dict[int, PacketHandler] = {}
+
+    def register(self, handler: PacketHandler) -> None:
+        """Register a packet handler.
+
+        Args:
+            handler: Handler instance to register
+
+        Raises:
+            ValueError: If handler doesn't have PKT_TYPE attribute
+
+        Note:
+            If a handler for this packet type already exists, it will be replaced.
+        """
+        if not hasattr(handler, "PKT_TYPE"):
+            raise ValueError(
+                f"Handler {handler.__class__.__name__} missing PKT_TYPE attribute"
+            )
+
+        pkt_type = handler.PKT_TYPE
+
+        # Warn if replacing existing handler
+        if pkt_type in self._handlers:
+            old_handler = self._handlers[pkt_type]
+            logger.warning(
+                f"Replacing handler for packet type {pkt_type}: "
+                f"{old_handler.__class__.__name__} -> {handler.__class__.__name__}"
+            )
+
+        self._handlers[pkt_type] = handler
+        logger.debug(
+            f"Registered {handler.__class__.__name__} for packet type {pkt_type}"
+        )
+
+    def register_all(self, handlers: list[PacketHandler]) -> None:
+        """Register multiple handlers at once.
+
+        Args:
+            handlers: List of handler instances to register
+        """
+        for handler in handlers:
+            self.register(handler)
+
+    def get_handler(self, pkt_type: int) -> PacketHandler | None:
+        """Get handler for a packet type.
+
+        Args:
+            pkt_type: Packet type number
+
+        Returns:
+            Handler instance if registered, None otherwise
+        """
+        return self._handlers.get(pkt_type)
+
+    def has_handler(self, pkt_type: int) -> bool:
+        """Check if a handler is registered for a packet type.
+
+        Args:
+            pkt_type: Packet type number
+
+        Returns:
+            True if handler is registered, False otherwise
+        """
+        return pkt_type in self._handlers
+
+    def list_handlers(self) -> list[tuple[int, str]]:
+        """List all registered handlers.
+
+        Returns:
+            List of (packet_type, handler_class_name) tuples
+        """
+        return [
+            (pkt_type, handler.__class__.__name__)
+            for pkt_type, handler in sorted(self._handlers.items())
+        ]
+
+    def __len__(self) -> int:
+        """Return number of registered handlers."""
+        return len(self._handlers)
+
+    def __repr__(self) -> str:
+        return f"HandlerRegistry({len(self)} handlers)"

lifx_emulator/handlers/tile_handlers.py

@@ -0,0 +1,309 @@
+"""Tile packet handlers."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from lifx_emulator.handlers.base import PacketHandler
+from lifx_emulator.protocol.packets import Tile
+from lifx_emulator.protocol.protocol_types import (
+    DeviceStateHostFirmware,
+    DeviceStateVersion,
+    LightHsbk,
+    TileAccelMeas,
+    TileEffectParameter,
+    TileEffectSettings,
+    TileEffectType,
+    TileStateDevice,
+)
+
+if TYPE_CHECKING:
+    from lifx_emulator.device import DeviceState
+
+logger = logging.getLogger(__name__)
+
+
+class GetDeviceChainHandler(PacketHandler):
+    """Handle TileGetDeviceChain (701) -> StateDeviceChain (702)."""
+
+    PKT_TYPE = Tile.GetDeviceChain.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_matrix:
+            return []
+
+        # Build tile device list (max 16 tiles in protocol)
+        tile_devices = []
+        for tile in device_state.tile_devices[:16]:
+            accel_meas = TileAccelMeas(
+                x=tile["accel_meas_x"], y=tile["accel_meas_y"], z=tile["accel_meas_z"]
+            )
+            device_version = DeviceStateVersion(
+                vendor=tile["device_version_vendor"],
+                product=tile["device_version_product"],
+            )
+            firmware = DeviceStateHostFirmware(
+                build=tile["firmware_build"],
+                version_minor=tile["firmware_version_minor"],
+                version_major=tile["firmware_version_major"],
+            )
+            tile_device = TileStateDevice(
+                accel_meas=accel_meas,
+                user_x=tile["user_x"],
+                user_y=tile["user_y"],
+                width=tile["width"],
+                height=tile["height"],
+                device_version=device_version,
+                firmware=firmware,
+            )
+            tile_devices.append(tile_device)
+
+        # Pad to 16 tiles
+        while len(tile_devices) < 16:
+            dummy_accel = TileAccelMeas(x=0, y=0, z=0)
+            dummy_version = DeviceStateVersion(vendor=0, product=0)
+            dummy_firmware = DeviceStateHostFirmware(
+                build=0, version_minor=0, version_major=0
+            )
+            dummy_tile = TileStateDevice(
+                accel_meas=dummy_accel,
+                user_x=0.0,
+                user_y=0.0,
+                width=0,
+                height=0,
+                device_version=dummy_version,
+                firmware=dummy_firmware,
+            )
+            tile_devices.append(dummy_tile)
+
+        return [
+            Tile.StateDeviceChain(
+                start_index=0,
+                tile_devices=tile_devices,
+                tile_devices_count=len(device_state.tile_devices),
+            )
+        ]
+
+
+class SetUserPositionHandler(PacketHandler):
+    """Handle TileSetUserPosition (703) - update tile position metadata."""
+
+    PKT_TYPE = Tile.SetUserPosition.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Tile.SetUserPosition | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if not device_state.has_matrix or not packet:
+            return []
+
+        logger.info(
+            f"Tile user position set: tile_index={packet.tile_index}, "
+            f"user_x={packet.user_x}, user_y={packet.user_y}"
+        )
+
+        # Update tile position if we have that tile
+        if packet.tile_index < len(device_state.tile_devices):
+            device_state.tile_devices[packet.tile_index]["user_x"] = packet.user_x
+            device_state.tile_devices[packet.tile_index]["user_y"] = packet.user_y
+
+        # No response packet defined for this in protocol
+        return []
+
+
+class Get64Handler(PacketHandler):
+    """Handle TileGet64 (707) -> State64 (711)."""
+
+    PKT_TYPE = Tile.Get64.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Tile.Get64 | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_matrix or not packet:
+            return []
+
+        tile_index = packet.tile_index
+        rect = packet.rect
+
+        if tile_index >= len(device_state.tile_devices):
+            return []
+
+        tile = device_state.tile_devices[tile_index]
+        tile_width = tile["width"]
+        tile_height = tile["height"]
+
+        # Calculate how many rows fit in 64 pixels
+        rows_to_return = 64 // rect.width if rect.width > 0 else 1
+        rows_to_return = min(rows_to_return, tile_height - rect.y)
+
+        # Extract colors from the requested rectangle
+        colors = []
+        pixels_extracted = 0
+
+        for row in range(rows_to_return):
+            y = rect.y + row
+            if y >= tile_height:
+                break
+
+            for col in range(rect.width):
+                x = rect.x + col
+                if x >= tile_width or pixels_extracted >= 64:
+                    colors.append(
+                        LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+                    )
+                    pixels_extracted += 1
+                    continue
+
+                # Calculate pixel index in flat color array
+                pixel_idx = y * tile_width + x
+                if pixel_idx < len(tile["colors"]):
+                    colors.append(tile["colors"][pixel_idx])
+                else:
+                    colors.append(
+                        LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+                    )
+                pixels_extracted += 1
+
+        # Pad to exactly 64 colors
+        while len(colors) < 64:
+            colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
+
+        return [Tile.State64(tile_index=tile_index, rect=rect, colors=colors)]
+
+
+class Set64Handler(PacketHandler):
+    """Handle TileSet64 (715)."""
+
+    PKT_TYPE = Tile.Set64.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Tile.Set64 | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_matrix or not packet:
+            return []
+
+        tile_index = packet.tile_index
+
+        if tile_index < len(device_state.tile_devices):
+            # Update colors from packet
+            for i, color in enumerate(packet.colors[:64]):
+                if i < len(device_state.tile_devices[tile_index]["colors"]):
+                    device_state.tile_devices[tile_index]["colors"][i] = color
+
+            logger.info(
+                f"Tile {tile_index} set 64 colors, duration={packet.duration}ms"
+            )
+
+        # Tiles never return a response to Set64 regardless of res_required
+        # https://lan.developer.lifx.com/docs/changing-a-device#set64---packet-715
+        return []
+
+
+class CopyFrameBufferHandler(PacketHandler):
+    """Handle TileCopyFrameBuffer (716) - copy frame buffer (no-op in emulator)."""
+
+    PKT_TYPE = Tile.CopyFrameBuffer.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_matrix:
+            return []
+
+        logger.debug("Tile copy frame buffer command received (no-op in emulator)")
+        # In a real device, this would copy the frame buffer to display
+        # In emulator, we don't need to do anything special
+        return []
+
+
+class GetEffectHandler(PacketHandler):
+    """Handle TileGetEffect (718) -> StateTileEffect (720)."""
+
+    PKT_TYPE = Tile.GetEffect.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_matrix:
+            return []
+
+        # Build palette (up to 16 colors)
+        palette = list(device_state.tile_effect_palette[:16])
+        while len(palette) < 16:
+            palette.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
+
+        # Create effect settings
+        parameter = TileEffectParameter(
+            parameter0=0,
+            parameter1=0,
+            parameter2=0,
+            parameter3=0,
+            parameter4=0,
+            parameter5=0,
+            parameter6=0,
+            parameter7=0,
+        )
+        settings = TileEffectSettings(
+            instanceid=0,
+            type=TileEffectType(device_state.tile_effect_type),
+            speed=device_state.tile_effect_speed * 1000,  # convert to milliseconds
+            duration=0,  # infinite
+            parameter=parameter,
+            palette_count=min(len(device_state.tile_effect_palette), 16),
+            palette=palette,
+        )
+
+        return [Tile.StateEffect(settings=settings)]
+
+
+class SetEffectHandler(PacketHandler):
+    """Handle TileSetEffect (719) -> StateTileEffect (720)."""
+
+    PKT_TYPE = Tile.SetEffect.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Tile.SetEffect | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if not device_state.has_matrix:
+            return []
+
+        if packet:
+            device_state.tile_effect_type = int(packet.settings.type)
+            device_state.tile_effect_speed = (
+                packet.settings.speed // 1000
+            )  # convert to seconds
+            device_state.tile_effect_palette = list(
+                packet.settings.palette[: packet.settings.palette_count]
+            )
+            device_state.tile_effect_palette_count = packet.settings.palette_count
+
+            logger.info(
+                f"Tile effect set: type={packet.settings.type}, "
+                f"speed={packet.settings.speed}ms, "
+                f"palette_count={packet.settings.palette_count}"
+            )
+
+        if res_required:
+            handler = GetEffectHandler()
+            return handler.handle(device_state, None, res_required)
+        return []
+
+
+# List of all tile handlers for easy registration
+ALL_TILE_HANDLERS = [
+    GetDeviceChainHandler(),
+    SetUserPositionHandler(),
+    Get64Handler(),
+    Set64Handler(),
+    CopyFrameBufferHandler(),
+    GetEffectHandler(),
+    SetEffectHandler(),
+]