conson-xp 1.18.0__py3-none-any.whl

xp/services/homekit/homekit_dimminglight_service.py

@@ -0,0 +1,148 @@
+"""HomeKit Dimming Light Service.
+
+This module provides service implementation for dimming light accessories.
+"""
+
+import logging
+
+from bubus import EventBus
+
+from xp.models.protocol.conbus_protocol import (
+    DimmingLightGetBrightnessEvent,
+    DimmingLightGetOnEvent,
+    DimmingLightSetBrightnessEvent,
+    DimmingLightSetOnEvent,
+    ReadDatapointEvent,
+    SendWriteConfigEvent,
+)
+from xp.models.telegram.datapoint_type import DataPointType
+
+
+class HomeKitDimmingLightService:
+    """Dimming light service for HomeKit.
+
+    Attributes:
+        event_bus: Event bus for inter-service communication.
+        logger: Logger instance.
+    """
+
+    event_bus: EventBus
+
+    def __init__(self, event_bus: EventBus) -> None:
+        """Initialize the dimming light service.
+
+        Args:
+            event_bus: Event bus instance.
+        """
+        self.logger = logging.getLogger(__name__)
+        self.event_bus = event_bus
+
+        # Register event handlers
+        self.event_bus.on(DimmingLightGetOnEvent, self.handle_dimminglight_get_on)
+        self.event_bus.on(DimmingLightSetOnEvent, self.handle_dimminglight_set_on)
+        self.event_bus.on(
+            DimmingLightSetBrightnessEvent, self.handle_dimminglight_set_brightness
+        )
+        self.event_bus.on(
+            DimmingLightGetBrightnessEvent, self.handle_dimminglight_get_brightness
+        )
+
+    def handle_dimminglight_get_on(self, event: DimmingLightGetOnEvent) -> None:
+        """Handle dimming light get on event.
+
+        Args:
+            event: Dimming light get on event.
+        """
+        self.logger.info(
+            f"Getting dimming light state for serial {event.serial_number}, output {event.output_number}"
+        )
+        self.logger.debug(f"dimminglight_get_on {event}")
+
+        read_datapoint = ReadDatapointEvent(
+            serial_number=event.serial_number,
+            datapoint_type=DataPointType.MODULE_OUTPUT_STATE,
+        )
+        self.logger.debug(f"Dispatching ReadDatapointEvent for {event.serial_number}")
+        self.event_bus.dispatch(read_datapoint)
+        self.logger.debug(f"Dispatched ReadDatapointEvent for {event.serial_number}")
+
+    def handle_dimminglight_set_on(self, event: DimmingLightSetOnEvent) -> None:
+        """Handle dimming light set on event.
+
+        Args:
+            event: Dimming light set on event.
+        """
+        brightness = event.brightness if event.value else 0
+        self.logger.debug(
+            f"Setting on light for "
+            f"serial {event.serial_number}, "
+            f"output {event.output_number}, "
+            f"event_value: {event.value}, "
+            f"state: {'ON' if event.value else 'OFF'}, "
+            f"brightness: {brightness}"
+        )
+        self.logger.debug(f"dimminglight_set_on {event}")
+
+        datapoint_type = DataPointType.MODULE_LIGHT_LEVEL
+        send_action = SendWriteConfigEvent(
+            serial_number=event.serial_number,
+            output_number=event.output_number,
+            datapoint_type=datapoint_type,
+            value=brightness,
+        )
+
+        self.logger.debug(f"Dispatching SendWriteConfigEvent for {event.serial_number}")
+        self.event_bus.dispatch(send_action)
+        self.logger.debug(f"Dispatched SendWriteConfigEvent for {event.serial_number}")
+
+    def handle_dimminglight_set_brightness(
+        self, event: DimmingLightSetBrightnessEvent
+    ) -> None:
+        """Handle dimming light set brightness event.
+
+        Args:
+            event: Dimming light set brightness event.
+        """
+        self.logger.info(
+            f"Setting dimming light brightness"
+            f"serial {event.serial_number}, "
+            f"output {event.output_number} "
+            f"to {event.brightness}"
+        )
+        self.logger.debug(f"dimminglight_set_brightness {event}")
+
+        datapoint_type = DataPointType.MODULE_LIGHT_LEVEL
+        send_action = SendWriteConfigEvent(
+            serial_number=event.serial_number,
+            output_number=event.output_number,
+            datapoint_type=datapoint_type,
+            value=event.brightness,
+        )
+
+        self.logger.debug(f"Dispatching SendWriteConfigEvent for {event.serial_number}")
+        self.event_bus.dispatch(send_action)
+        self.logger.debug(f"Dispatched SendWriteConfigEvent for {event.serial_number}")
+
+    def handle_dimminglight_get_brightness(
+        self, event: DimmingLightGetBrightnessEvent
+    ) -> None:
+        """Handle dimming light get brightness event.
+
+        Args:
+            event: Dimming light get brightness event.
+        """
+        self.logger.info(
+            f"Getting dimming light brightness "
+            f"for serial {event.serial_number}, "
+            f"output {event.output_number}"
+        )
+        self.logger.debug(f"dimminglight_get_brightness {event}")
+
+        datapoint_type = DataPointType.MODULE_LIGHT_LEVEL
+        read_datapoint = ReadDatapointEvent(
+            serial_number=event.serial_number, datapoint_type=datapoint_type
+        )
+
+        self.logger.debug(f"Dispatching ReadDatapointEvent for {event.serial_number}")
+        self.event_bus.dispatch(read_datapoint)
+        self.logger.debug(f"Dispatched ReadDatapointEvent for {event.serial_number}")

xp/services/homekit/homekit_hap_service.py

@@ -0,0 +1,342 @@
+"""HomeKit HAP Service for Apple HomeKit integration.
+
+This module provides the main HAP (HomeKit Accessory Protocol) service.
+"""
+
+import logging
+import signal
+import threading
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from bubus import EventBus
+from pyhap.accessory import Bridge
+from pyhap.accessory_driver import AccessoryDriver
+from typing_extensions import Union
+
+import xp
+from xp.models.homekit.homekit_accessory import TemperatureSensor
+from xp.models.homekit.homekit_config import (
+    HomekitAccessoryConfig,
+    HomekitConfig,
+    RoomConfig,
+)
+from xp.models.protocol.conbus_protocol import (
+    LightLevelReceivedEvent,
+    ModuleStateChangedEvent,
+    OutputStateReceivedEvent,
+    ReadDatapointEvent,
+)
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.services.homekit.homekit_dimminglight import DimmingLight
+from xp.services.homekit.homekit_lightbulb import LightBulb
+from xp.services.homekit.homekit_module_service import HomekitModuleService
+from xp.services.homekit.homekit_outlet import Outlet
+
+
+class HomekitHapService:
+    """HomeKit HAP service.
+
+    Manages HAP accessory protocol, handles bridge and accessory setup,
+    and processes HomeKit events for device state synchronization.
+
+    Attributes:
+        event_bus: Event bus for inter-service communication.
+        last_activity: Timestamp of last service activity.
+        logger: Logger instance.
+        config: HomeKit configuration.
+        accessory_registry: Registry of accessories by identifier.
+        module_registry: Registry of accessories by module key.
+        modules: Module service for module lookup.
+        driver: HAP accessory driver.
+    """
+
+    event_bus: EventBus
+
+    def __init__(
+        self,
+        homekit_config: HomekitConfig,
+        module_service: HomekitModuleService,
+        event_bus: EventBus,
+    ):
+        """Initialize the HomeKit HAP service.
+
+        Args:
+            homekit_config: HomeKit configuration.
+            module_service: Module service for dependency injection.
+            event_bus: Event bus for dependency injection.
+        """
+        self.last_activity: Optional[datetime] = None
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+        # Load configuration
+        self.config = homekit_config
+        self.accessory_registry: Dict[str, Union[LightBulb, Outlet, DimmingLight]] = {}
+        self.module_registry: Dict[
+            tuple[int, int], List[Union[LightBulb, Outlet, DimmingLight]]
+        ] = {}
+
+        # Service dependencies
+        self.modules = module_service
+        self.event_bus = event_bus
+
+        # Subscribe to events
+        self.event_bus.on(ModuleStateChangedEvent, self.handle_module_state_changed)
+        self.event_bus.on(OutputStateReceivedEvent, self.handle_output_state_received)
+        self.event_bus.on(LightLevelReceivedEvent, self.handle_light_level_received)
+
+        # We want SIGTERM (terminate) to be handled by the driver itself,
+        # so that it can gracefully stop the accessory, server and advertising.
+        driver = AccessoryDriver(
+            port=self.config.homekit.port,
+        )
+        signal.signal(signal.SIGTERM, driver.signal_handler)
+        self.driver: AccessoryDriver = driver
+
+    async def async_start(self) -> None:
+        """Start the HAP service asynchronously."""
+        self.logger.info("Loading accessories.")
+        self.build_bridge()
+        self.logger.info("Accessories loaded successfully")
+
+        # Start HAP-python in a separate thread to avoid event loop conflicts
+        self.logger.info("Starting HAP-python driver in separate thread.")
+        hap_thread = threading.Thread(
+            target=self._run_driver_in_thread, daemon=True, name="HAP-Python"
+        )
+        hap_thread.start()
+        self.logger.info("HAP-python driver thread started")
+
+    def _run_driver_in_thread(self) -> None:
+        """Run the HAP-python driver in a separate thread with its own event loop."""
+        try:
+            self.logger.info("HAP-python thread starting, creating new event loop.")
+            # Create a new event loop for this thread
+
+            self.logger.info("Starting HAP-python driver.")
+            self.driver.start()
+            self.logger.info("HAP-python driver started successfully")
+        except Exception as e:
+            self.logger.error(f"HAP-python driver error: {e}", exc_info=True)
+
+    def handle_output_state_received(self, event: OutputStateReceivedEvent) -> str:
+        """Handle output state received event.
+
+        Args:
+            event: Output state received event.
+
+        Returns:
+            Data value from the event.
+        """
+        self.logger.debug(f"Received OutputStateReceivedEvent {event}")
+        output_number = 0
+        for output in event.data_value[::-1]:
+            if output == "x":
+                break
+            identifier = f"{event.serial_number}.{output_number:02X}"
+            accessory = self.accessory_registry.get(identifier)
+
+            if not accessory:
+                self.logger.warning(f"Invalid accessory: {identifier} (not found)")
+            else:
+                accessory.is_on = True if output == "1" else False
+            output_number += 1
+
+        self.logger.debug(
+            f"handle_output_state_received "
+            f"serial_number: {event.serial_number}, "
+            f"data_vale: {event.data_value}"
+        )
+        return event.data_value
+
+    def handle_light_level_received(self, event: LightLevelReceivedEvent) -> str:
+        """Handle light level received event.
+
+        Args:
+            event: Light level received event.
+
+        Returns:
+            Data value from the event.
+        """
+        # Parse response format like "00:050,01:025,02:100"
+        self.logger.debug("Received LightLevelReceivedEvent", extra={"event": event})
+        output_number = 0
+        for output_data in event.data_value.split(","):
+            if ":" in output_data:
+                output_str, level_str = output_data.split(":")
+                level_str = level_str.replace("[%]", "")
+                output_number = int(output_str)
+                brightness = int(level_str)
+                identifier = f"{event.serial_number}.{output_number:02X}"
+                accessory = self.accessory_registry.get(identifier)
+
+                if not accessory:
+                    self.logger.warning(
+                        f"Invalid accessory: {event.serial_number} (not found)"
+                    )
+                elif not isinstance(accessory, DimmingLight):
+                    self.logger.warning(
+                        f"Invalid accessory: {event.serial_number} (not dimming light)"
+                    )
+                else:
+                    accessory.brightness = brightness
+
+            output_number += 1
+
+        self.logger.debug(
+            f"handle_light_level_received "
+            f"serial_number: {event.serial_number}, "
+            f"data_vale: {event.data_value}"
+        )
+        return event.data_value
+
+    def build_bridge(self) -> None:
+        """Build the HomeKit bridge with all configured accessories."""
+        bridge_config = self.config.bridge
+        bridge = Bridge(self.driver, bridge_config.name)
+        bridge.set_info_service(
+            xp.__version__, xp.__manufacturer__, xp.__model__, xp.__serial__
+        )
+
+        for room in bridge_config.rooms:
+            self.add_room(bridge, room)
+
+        self.driver.add_accessory(accessory=bridge)
+
+    def add_room(self, bridge: Bridge, room: RoomConfig) -> None:
+        """Add a room with its accessories to the bridge.
+
+        Args:
+            bridge: HAP bridge instance.
+            room: Room configuration.
+        """
+        temperature = TemperatureSensor(self.driver, room.name)
+        bridge.add_accessory(temperature)
+
+        for accessory_name in room.accessories:
+            homekit_accessory = self.get_accessory_by_name(accessory_name)
+            if homekit_accessory is None:
+                self.logger.warning("Accessory '{}' not found".format(accessory_name))
+                continue
+
+            accessory = self.get_accessory(homekit_accessory)
+            if accessory:
+                bridge.add_accessory(accessory)
+                # Add to accessory_registry
+                self.accessory_registry[accessory.identifier] = accessory
+
+                # Add to module_registry for event-driven lookup
+                module_key = (
+                    accessory.module.module_type_code,
+                    accessory.module.link_number,
+                )
+                if module_key not in self.module_registry:
+                    self.module_registry[module_key] = []
+                self.module_registry[module_key].append(accessory)
+
+    def get_accessory(
+        self, homekit_accessory: HomekitAccessoryConfig
+    ) -> Union[LightBulb, Outlet, DimmingLight, None]:
+        """Get an accessory instance from configuration.
+
+        Args:
+            homekit_accessory: HomeKit accessory configuration.
+
+        Returns:
+            Accessory instance or None if not found or invalid service type.
+        """
+        module_config = self.modules.get_module_by_serial(
+            homekit_accessory.serial_number
+        )
+        if module_config is None:
+            self.logger.warning(f"Accessory '{homekit_accessory.name}' not found")
+            return None
+
+        if homekit_accessory.service == "lightbulb":
+            return LightBulb(
+                driver=self.driver,
+                module=module_config,
+                accessory=homekit_accessory,
+                event_bus=self.event_bus,
+            )
+
+        if homekit_accessory.service == "outlet":
+            return Outlet(
+                driver=self.driver,
+                module=module_config,
+                accessory=homekit_accessory,
+                event_bus=self.event_bus,
+            )
+
+        if homekit_accessory.service == "dimminglight":
+            return DimmingLight(
+                driver=self.driver,
+                module=module_config,
+                accessory=homekit_accessory,
+                event_bus=self.event_bus,
+            )
+
+        self.logger.warning(f"Accessory '{homekit_accessory.name}' not found")
+        return None
+
+    def get_accessory_by_name(self, name: str) -> Optional[HomekitAccessoryConfig]:
+        """Get an accessory configuration by name.
+
+        Args:
+            name: Name of the accessory to find.
+
+        Returns:
+            Accessory configuration if found, None otherwise.
+        """
+        return next(
+            (module for module in self.config.accessories if module.name == name), None
+        )
+
+    def handle_module_state_changed(self, event: ModuleStateChangedEvent) -> None:
+        """Handle module state change by refreshing affected accessories.
+
+        Args:
+            event: Module state changed event.
+        """
+        self.logger.debug(
+            f"Module state changed: module_type={event.module_type_code}, "
+            f"link={event.link_number}, input={event.input_number}"
+        )
+
+        # O(1) lookup using module_registry
+        module_key = (event.module_type_code, event.link_number)
+        affected_accessories = self.module_registry.get(module_key, [])
+
+        if not affected_accessories:
+            self.logger.debug(
+                f"No accessories found for module_type={event.module_type_code}, "
+                f"link={event.link_number}"
+            )
+            return
+
+        # Request cache refresh for each affected accessory
+        for accessory in affected_accessories:
+            self.logger.info(
+                f"Requesting cache refresh for accessory: {accessory.identifier}"
+            )
+
+            # Request OUTPUT_STATE refresh
+            self.event_bus.dispatch(
+                ReadDatapointEvent(
+                    serial_number=accessory.module.serial_number,
+                    datapoint_type=DataPointType.MODULE_OUTPUT_STATE,
+                    refresh_cache=True,
+                )
+            )
+
+            # If dimming light, also refresh LIGHT_LEVEL
+            if isinstance(accessory, DimmingLight):
+                self.event_bus.dispatch(
+                    ReadDatapointEvent(
+                        serial_number=accessory.module.serial_number,
+                        datapoint_type=DataPointType.MODULE_LIGHT_LEVEL,
+                        refresh_cache=True,
+                    )
+                )

xp/services/homekit/homekit_lightbulb.py

@@ -0,0 +1,120 @@
+"""HomeKit Light Bulb Accessory.
+
+This module provides a light bulb accessory for HomeKit integration.
+"""
+
+import logging
+
+from bubus import EventBus
+from pyhap.accessory import Accessory
+from pyhap.accessory_driver import AccessoryDriver
+from pyhap.const import CATEGORY_LIGHTBULB
+
+from xp.models.homekit.homekit_config import HomekitAccessoryConfig
+from xp.models.homekit.homekit_conson_config import ConsonModuleConfig
+from xp.models.protocol.conbus_protocol import (
+    LightBulbGetOnEvent,
+    LightBulbSetOnEvent,
+)
+
+
+class LightBulb(Accessory):
+    """HomeKit light bulb accessory.
+
+    Attributes:
+        category: HomeKit category (CATEGORY_LIGHTBULB).
+        event_bus: Event bus for inter-service communication.
+        logger: Logger instance.
+        identifier: Unique identifier for the accessory.
+        accessory: Accessory configuration.
+        module: Module configuration.
+        is_on: Current on/off state.
+        char_on: On characteristic.
+    """
+
+    category = CATEGORY_LIGHTBULB
+    event_bus: EventBus
+
+    def __init__(
+        self,
+        driver: AccessoryDriver,
+        module: ConsonModuleConfig,
+        accessory: HomekitAccessoryConfig,
+        event_bus: EventBus,
+    ):
+        """Initialize the light bulb accessory.
+
+        Args:
+            driver: HAP accessory driver.
+            module: Module configuration.
+            accessory: Accessory configuration.
+            event_bus: Event bus for inter-service communication.
+        """
+        super().__init__(driver, accessory.description)
+
+        self.logger = logging.getLogger(__name__)
+
+        identifier = f"{module.serial_number}.{accessory.output_number:02d}"
+        version = accessory.id
+        manufacturer = "Conson"
+        model = ("XP24_lightbulb",)
+
+        self.identifier = identifier
+        self.accessory = accessory
+        self.module = module
+        self.event_bus = event_bus
+        self.is_on = False
+
+        self.logger.info(
+            "Creating Lightbulb { serial_number : %s, output_number: %s }",
+            module.serial_number,
+            accessory.output_number,
+        )
+
+        serv_light = self.add_preload_service("Lightbulb")
+
+        self.set_info_service(version, manufacturer, model, identifier)
+
+        self.char_on = serv_light.configure_char(
+            "On", getter_callback=self.get_on, setter_callback=self.set_on
+        )
+
+    def set_on(self, value: bool) -> None:
+        """Set the on/off state of the light bulb.
+
+        Args:
+            value: True to turn on, False to turn off.
+        """
+        # Emit set event
+        self.logger.debug(f"set_on {value}")
+        if self.is_on != value:
+            self.is_on = value
+            self.event_bus.dispatch(
+                LightBulbSetOnEvent(
+                    serial_number=self.accessory.serial_number,
+                    output_number=self.accessory.output_number,
+                    module=self.module,
+                    accessory=self.accessory,
+                    value=value,
+                )
+            )
+
+    def get_on(self) -> bool:
+        """Get the on/off state of the light bulb.
+
+        Returns:
+            True if on, False if off.
+        """
+        # Emit event and get response
+        self.logger.debug("get_on")
+        self.event_bus.dispatch(
+            LightBulbGetOnEvent(
+                serial_number=self.accessory.serial_number,
+                output_number=self.accessory.output_number,
+                module=self.module,
+                accessory=self.accessory,
+            )
+        )
+        self.logger.debug(f"get_on from dispatch: {self.is_on}")
+
+        return self.is_on

xp/services/homekit/homekit_lightbulb_service.py

@@ -0,0 +1,86 @@
+"""HomeKit Light Bulb Service.
+
+This module provides service implementation for light bulb accessories.
+"""
+
+import logging
+
+from bubus import EventBus
+
+from xp.models.protocol.conbus_protocol import (
+    LightBulbGetOnEvent,
+    LightBulbSetOnEvent,
+    ReadDatapointEvent,
+    SendActionEvent,
+)
+from xp.models.telegram.datapoint_type import DataPointType
+
+
+class HomeKitLightbulbService:
+    """Lightbulb service for HomeKit.
+
+    Attributes:
+        event_bus: Event bus for inter-service communication.
+        logger: Logger instance.
+    """
+
+    event_bus: EventBus
+
+    def __init__(self, event_bus: EventBus):
+        """Initialize the lightbulb service.
+
+        Args:
+            event_bus: Event bus instance.
+        """
+        self.event_bus = event_bus
+        self.logger = logging.getLogger(__name__)
+
+        # Register event handlers
+        self.event_bus.on(LightBulbGetOnEvent, self.handle_lightbulb_get_on)
+        self.event_bus.on(LightBulbSetOnEvent, self.handle_lightbulb_set_on)
+
+    def handle_lightbulb_get_on(self, event: LightBulbGetOnEvent) -> None:
+        """Handle lightbulb get on event.
+
+        Args:
+            event: Lightbulb get on event.
+        """
+        self.logger.info(
+            f"Getting lightbulb state for serial {event.serial_number}, output {event.output_number}"
+        )
+        self.logger.debug(f"lightbulb_get_on {event}")
+
+        datapoint_type = DataPointType.MODULE_OUTPUT_STATE
+        read_datapoint = ReadDatapointEvent(
+            serial_number=event.serial_number, datapoint_type=datapoint_type
+        )
+
+        self.logger.debug(f"Dispatching ReadDatapointEvent for {event.serial_number}")
+        self.event_bus.dispatch(read_datapoint)
+        self.logger.debug(f"Dispatched ReadDatapointEvent for {event.serial_number}")
+
+    def handle_lightbulb_set_on(self, event: LightBulbSetOnEvent) -> None:
+        """Handle lightbulb set on event.
+
+        Args:
+            event: Lightbulb set on event.
+        """
+        self.logger.info(
+            f"Setting lightbulb "
+            f"for serial {event.serial_number}, "
+            f"output {event.output_number} "
+            f"to {'ON' if event.value else 'OFF'}"
+        )
+        self.logger.debug(f"lightbulb_set_on {event}")
+
+        send_action = SendActionEvent(
+            serial_number=event.serial_number,
+            output_number=event.output_number,
+            value=event.value,
+            on_action=event.accessory.on_action,
+            off_action=event.accessory.off_action,
+        )
+
+        self.logger.debug(f"Dispatching SendActionEvent for {event.serial_number}")
+        self.event_bus.dispatch(send_action)
+        self.logger.debug(f"Dispatched SendActionEvent for {event.serial_number}")