Couple NumberEntities and LightEntities

Author: Breina

custom_components/dmx/entity/light.py

@@ -8,6 +8,7 @@
 from homeassistant.components.light import LightEntity, ColorMode
 from homeassistant.core import callback
 from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.restore_state import RestoreEntity
 
 from custom_components.dmx import DOMAIN
 from custom_components.dmx.fixture.channel import Channel
@@ -32,7 +33,7 @@ class AccumulatedLightChannel:
     light_channel: LightChannel
 
 
-class ClaudeLightEntity(LightEntity):
+class ClaudeLightEntity(LightEntity, RestoreEntity):
     """DMX/ArtNet light entity that supports various channel configurations."""
 
     def __init__(
@@ -95,6 +96,7 @@ def __init__(
         self._setup_turn_on_handlers()
 
         # Register channel listeners
+        self._is_updating = False
         self._register_channel_listeners()
 
     def _setup_turn_on_handlers(self):
@@ -159,7 +161,7 @@ def _register_channel_listeners(self):
             for dmx_index in channel_data.dmx_channel_indexes:
                 channel_data.universe.register_channel_listener(
                     dmx_index,
-                    partial(self._handle_channel_update, channel_type, dmx_index)
+                    partial(self._handle_channel_update, channel_type)
                 )
 
     @callback
@@ -331,9 +333,13 @@ async def async_turn_off(self, **kwargs) -> None:
         self._state = False
 
         # Turn off all channels
-        for ch_data in self._channels:
-            for dmx_index in ch_data.dmx_channel_indexes:
-                await ch_data.universe.update_value(dmx_index, 0)
+        self._is_updating = True
+        try:
+            for ch_data in self._channels:
+                for dmx_index in ch_data.dmx_channel_indexes:
+                    await ch_data.universe.update_value(dmx_index, 0)
+        finally:
+            self._is_updating = False
 
         # Update state
         self.async_write_ha_state()

custom_components/dmx/entity/number.py

@@ -57,17 +57,26 @@ def __init__(self, name: str, capability: Capability,
         else:
             self._attr_native_value = 0
 
+        self._is_updating = False
         self.universe.register_channel_listener(dmx_indexes, self.update_value)
 
-    def update_value(self, value: int) -> None:
+    def update_value(self, dmx_index: int, value: int) -> None:
         # TODO maybe update self._attr_attribution from source ArtNet node?
+        if getattr(self, '_is_updating', False):
+            return
+
         self._attr_native_value = self.dynamic_entity.from_dmx(value)
         self.async_schedule_update_ha_state()
 
     async def async_set_native_value(self, value: float) -> None:
         self._attr_native_value = value
         dmx_value = self.dynamic_entity.to_dmx(value)
-        await self.universe.update_value(self.dmx_indexes, dmx_value)
+
+        self._is_updating = True
+        try:
+            await self.universe.update_value(self.dmx_indexes, dmx_value)
+        finally:
+            self._is_updating = False
 
     @property
     def available(self) -> bool:

custom_components/dmx/io/dmx_io.py

@@ -1,15 +1,85 @@
+import asyncio
 from typing import List, Callable
 
 
 class Universe:
     def __init__(self):
-        pass
+        # Dictionary to store channel value: {channel_number: current_value}
+        self._channel_values = {}
+
+        # Dictionary to store callbacks: {channel_number: [callback1, callback2, ...]}
+        self._channel_callbacks = {}
 
     def register_channel_listener(self, channels: int | List[int],
-                                  callback: Callable[[int], None]
-                                  ) -> None:
-        pass
+                                  callback: Callable[[int, int], None]) -> None:
+        """
+        Register a callback to be called when a channel value changes.
+
+        Args:
+            channels: Single channel number or list of channel numbers
+            callback: Function to call with channel number and new value
+        """
+        if isinstance(channels, int):
+            channels = [channels]
+
+        for channel in channels:
+            if channel not in self._channel_callbacks:
+                self._channel_callbacks[channel] = []
+
+            if callback not in self._channel_callbacks[channel]:
+                self._channel_callbacks[channel].append(callback)
+
+    def unregister_channel_listener(self, channels: int | List[int],
+                                    callback: Callable[[int, int], None]) -> None:
+        """Remove a callback from the registry."""
+        if isinstance(channels, int):
+            channels = [channels]
+
+        for channel in channels:
+            if channel in self._channel_callbacks and callback in self._channel_callbacks[channel]:
+                self._channel_callbacks[channel].remove(callback)
 
     async def update_value(self, channel: int | List[int], value: int) -> None:
-        print(f"Updating {channel} to {value}")
-        pass
+        """
+        Update the value of one or more channels and notify all listeners.
+
+        Args:
+            channel: Single channel number or list of channel numbers
+            value: New value for the channel(s)
+        """
+        # Convert to list if single channel
+        if isinstance(channel, int):
+            channels = [channel]
+        else:
+            channels = channel
+
+        # Update all specified channels
+        for ch in channels:
+            # Only process if value has changed or channel is new
+            if ch not in self._channel_values or self._channel_values[ch] != value:
+                # Update stored value
+                self._channel_values[ch] = value
+
+                # Notify all listeners for this channel
+                if ch in self._channel_callbacks:
+                    for callback in self._channel_callbacks[ch]:
+                        try:
+                            # Pass both channel and value to callback
+                            await self._call_callback(callback, ch, value)
+                        except Exception as e:
+                            print(f"Error calling callback for channel {ch}: {e}")
+
+                # Perform actual DMX output
+                print(f"Updating DMX channel {ch} to value {value}")
+                # Actual DMX output code would go here
+
+    async def _call_callback(self, callback, channel, value):
+        """Helper method to call callbacks that might be async or regular functions."""
+        if asyncio.iscoroutinefunction(callback):
+            await callback(channel, value)
+        else:
+            callback(channel, value)
+
+    def get_channel_value(self, channel: int) -> int:
+        """Get the current value of a channel."""
+        return self._channel_values.get(channel, 0)