timer updating and font size

Author: cagcoach

custom_components/ipixel_color/api.py

@@ -39,6 +39,7 @@ def __init__(self, hass: HomeAssistant, address: str) -> None:
         self._power_state = False
         self._device_info: dict[str, Any] | None = None
         self._device_response: bytes | None = None
+        self._active_mode: str | None = None  # Last mode sent to display
 
     async def connect(self) -> bool:
         """Connect to the iPIXEL device."""
@@ -343,6 +344,8 @@ async def display_timer_gif(
         text_color: tuple[int, int, int] = (0, 255, 0),
         bg_color: tuple[int, int, int] = (0, 0, 0),
         font_path: str | None = None,
+        static: bool = False,
+        font_size: float | None = None,
     ) -> bool:
         """Generate and display a countdown timer GIF on the device.
 
@@ -351,6 +354,8 @@ async def display_timer_gif(
             text_color: RGB tuple for text color (default: green)
             bg_color: RGB tuple for background color (default: black)
             font_path: Path to TTF font file, or None for default
+            static: If True, display static image instead of animated GIF
+            font_size: Font size in pixels, or None for auto-sizing
 
         Returns:
             True if timer GIF was sent successfully
@@ -365,9 +370,9 @@ async def display_timer_gif(
             width = device_info["width"]
             height = device_info["height"]
 
-            # Determine font size based on display height
-            # Use a font size that fits well in the display
-            font_size = max(8, height - 4)
+            # Determine font size based on display height if not specified
+            if font_size is None or font_size == 0:
+                font_size = height - 4
 
             # Use default font if none specified
             if font_path is None:
@@ -393,6 +398,7 @@ async def display_timer_gif(
                     font_path=font_path,
                     width=width,
                     height=height,
+                    static=static,
                 )
 
                 _LOGGER.debug(

custom_components/ipixel_color/common.py

@@ -122,18 +122,23 @@ async def update_ipixel_display(hass: HomeAssistant, device_name: str, api, text
 
         # Route to appropriate mode handler
         if mode == MODE_TEXT_IMAGE:
-            return await _update_textimage_mode(hass, device_name, api, text)
+            success = await _update_textimage_mode(hass, device_name, api, text)
         elif mode == MODE_TEXT:
-            return await _update_text_mode(hass, device_name, api, text)
+            success = await _update_text_mode(hass, device_name, api, text)
         elif mode == MODE_CLOCK:
-            return await _update_clock_mode(hass, device_name, api)
+            success = await _update_clock_mode(hass, device_name, api)
         elif mode == MODE_TIMER:
-            # Timer mode is triggered by timer entity state changes, not manual updates
-            _LOGGER.debug("Timer mode active - waiting for timer entity to start")
-            return True
+            success = await _update_timer_mode(hass, device_name, api)
         else:
             _LOGGER.warning("Unknown mode: %s, falling back to textimage", mode)
-            return await _update_textimage_mode(hass, device_name, api, text)
+            success = await _update_textimage_mode(hass, device_name, api, text)
+            mode = MODE_TEXT_IMAGE
+
+        # Store the active mode on successful update
+        if success:
+            api._active_mode = mode
+
+        return success
 
     except Exception as err:
         _LOGGER.error("Error during display update: %s", err)
@@ -355,6 +360,127 @@ async def _update_text_mode(hass: HomeAssistant, device_name: str, api, text: st
         return False
 
 
+async def _update_timer_mode(hass: HomeAssistant, device_name: str, api) -> bool:
+    """Update display in timer mode.
+
+    Args:
+        hass: Home Assistant instance
+        device_name: Device name for entity ID lookups
+        api: iPIXEL API instance
+
+    Returns:
+        True if update was successful
+    """
+    from datetime import datetime, timezone
+
+    try:
+        # Get selected timer entity
+        timer_entity_id = get_entity_id_by_unique_id(hass, api._address, "timer_entity_select", "select")
+        timer_select_state = hass.states.get(timer_entity_id) if timer_entity_id else None
+
+        if not timer_select_state or timer_select_state.state == "none":
+            _LOGGER.warning("No timer entity selected - skipping update")
+            return False
+
+        selected_timer = timer_select_state.state
+        timer_state = hass.states.get(selected_timer)
+
+        if not timer_state:
+            _LOGGER.warning("Timer entity %s not found", selected_timer)
+            return False
+
+        # Determine seconds and static flag based on timer state
+        state = timer_state.state
+        attrs = timer_state.attributes
+        seconds = 0
+        static = True  # Default to static
+
+        if state == "active":
+            # Calculate remaining time from finishes_at
+            finishes_at = attrs.get("finishes_at")
+            if finishes_at:
+                try:
+                    finish_time = datetime.fromisoformat(finishes_at.replace("Z", "+00:00"))
+                    now = datetime.now(timezone.utc)
+                    seconds = max(0, int((finish_time - now).total_seconds()))
+                    static = False  # Animated countdown
+                except (ValueError, TypeError) as err:
+                    _LOGGER.error("Failed to parse finishes_at '%s': %s", finishes_at, err)
+        elif state == "paused":
+            # Use remaining attribute
+            remaining = attrs.get("remaining")
+            if remaining:
+                seconds = _parse_timer_duration(remaining)
+            static = True  # Static for paused
+        else:  # idle
+            # Use duration attribute (time it will run when started)
+            duration = attrs.get("duration")
+            if duration:
+                seconds = _parse_timer_duration(duration)
+            static = True  # Static for idle
+
+        if seconds <= 0:
+            _LOGGER.warning("Timer has no valid duration")
+            return False
+
+        # Get font size setting
+        font_size = await _get_entity_setting(hass, device_name, "number", "font_size", float, api._address)
+
+        # Get colors from light entities
+        text_color_hex = get_color_from_light_entity(hass, api._address, "text_color", default="00ff00")
+        bg_color_hex = get_color_from_light_entity(hass, api._address, "background_color", default="000000")
+
+        text_color = (
+            int(text_color_hex[0:2], 16),
+            int(text_color_hex[2:4], 16),
+            int(text_color_hex[4:6], 16),
+        )
+        bg_color = (
+            int(bg_color_hex[0:2], 16),
+            int(bg_color_hex[2:4], 16),
+            int(bg_color_hex[4:6], 16),
+        )
+
+        # Connect if needed
+        if not api.is_connected:
+            _LOGGER.debug("Reconnecting to device for timer mode update")
+            await api.connect()
+
+        # Display timer
+        success = await api.display_timer_gif(
+            duration_seconds=seconds,
+            text_color=text_color,
+            bg_color=bg_color,
+            static=static,
+            font_size=font_size,
+        )
+
+        if success:
+            _LOGGER.info("Timer mode update: %d sec, state=%s, static=%s", seconds, state, static)
+        else:
+            _LOGGER.error("Timer mode update failed")
+
+        return success
+
+    except Exception as err:
+        _LOGGER.error("Error in timer mode update: %s", err)
+        return False
+
+
+def _parse_timer_duration(duration_str: str) -> int:
+    """Parse timer duration string to seconds."""
+    try:
+        parts = duration_str.split(":")
+        if len(parts) == 3:
+            return int(parts[0]) * 3600 + int(parts[1]) * 60 + int(parts[2])
+        elif len(parts) == 2:
+            return int(parts[0]) * 60 + int(parts[1])
+        else:
+            return int(float(duration_str))
+    except (ValueError, IndexError):
+        return 0
+
+
 async def _get_entity_setting(hass: HomeAssistant, device_name: str, platform: str, setting: str, value_type=str, address: str = None):
     """Get setting from Home Assistant entity.
 

custom_components/ipixel_color/giftimer/gif_builder.py

@@ -9,8 +9,23 @@
 
 
 def build_timer_gif(duration_seconds, output_path, font_size=72, bg=DEFAULT_BG, fg=DEFAULT_FG,
-                    font_path=None, width=None, height=None):
-    """Build a countdown timer GIF."""
+                    font_path=None, width=None, height=None, static=False):
+    """Build a countdown timer GIF or static image.
+
+    Args:
+        duration_seconds: Time to display/countdown from in seconds
+        output_path: Path to save the output file
+        font_size: Font size in pixels
+        bg: Background color as RGB tuple
+        fg: Foreground/text color as RGB tuple
+        font_path: Path to TTF font file, or None for default
+        width: Image width, or None for auto
+        height: Image height, or None for auto
+        static: If True, generate a single-frame static image instead of animated GIF
+
+    Returns:
+        Number of frames (1 for static, duration_seconds+1 for animated)
+    """
     font = get_font(font_size, font_path)
     palette = create_palette(bg, fg)
     padding = 20
@@ -26,6 +41,20 @@ def build_timer_gif(duration_seconds, output_path, font_size=72, bg=DEFAULT_BG,
     if height is None:
         height = text_h + 2 * padding
 
+    if static:
+        # Generate single static frame showing the duration
+        time_text = format_time(duration_seconds)
+        frame, _, _ = create_frame(time_text, width, height, font, palette)
+
+        # Save as single-frame GIF (or PNG based on extension)
+        if output_path.lower().endswith('.png'):
+            frame.convert("RGB").save(output_path, format="PNG")
+        else:
+            frame.save(output_path, format="GIF")
+
+        return 1
+
+    # Generate animated countdown GIF
     frames = []
     durations = []
     prev_frame = None

custom_components/ipixel_color/select.py

@@ -399,99 +399,25 @@ def async_timer_state_changed(event: Event[EventStateChangedData]) -> None:
                 new_state.state
             )
 
-            # Only trigger when timer becomes active (started)
-            if new_state.state == "active":
-                # Check if we're in timer mode
-                mode_entity_id = get_entity_id_by_unique_id(
-                    self.hass, self._address, "mode_select", "select"
+            # Check if timer mode is active on the display
+            if self._api._active_mode == MODE_TIMER:
+                _LOGGER.debug("Timer state changed, updating timer display")
+                self.hass.async_create_task(
+                    self._update_timer_on_callback()
                 )
-                mode_state = self.hass.states.get(mode_entity_id) if mode_entity_id else None
-
-                if mode_state and mode_state.state == MODE_TIMER:
-                    # Get the remaining duration from the timer
-                    duration = new_state.attributes.get("duration", "0:00:00")
-                    # Parse duration string (H:MM:SS or M:SS format)
-                    duration_seconds = self._parse_duration(duration)
-
-                    if duration_seconds > 0:
-                        _LOGGER.info(
-                            "Timer started! Displaying %d second countdown",
-                            duration_seconds
-                        )
-                        # Schedule the timer GIF display
-                        self.hass.async_create_task(
-                            self._display_timer(duration_seconds)
-                        )
 
         self._unsub_state_change = async_track_state_change_event(
             self.hass, timer_entity_id, async_timer_state_changed
         )
         _LOGGER.debug("Set up state listener for timer: %s", timer_entity_id)
 
-    def _parse_duration(self, duration_str: str) -> int:
-        """Parse duration string to seconds.
-
-        Accepts formats: H:MM:SS, MM:SS, or seconds as string
-        """
-        try:
-            parts = duration_str.split(":")
-            if len(parts) == 3:
-                # H:MM:SS
-                return int(parts[0]) * 3600 + int(parts[1]) * 60 + int(parts[2])
-            elif len(parts) == 2:
-                # MM:SS or M:SS
-                return int(parts[0]) * 60 + int(parts[1])
-            else:
-                # Just seconds
-                return int(float(duration_str))
-        except (ValueError, IndexError) as err:
-            _LOGGER.error("Failed to parse duration '%s': %s", duration_str, err)
-            return 0
-
-    async def _display_timer(self, duration_seconds: int) -> None:
-        """Display the timer countdown GIF on the device."""
+    async def _update_timer_on_callback(self) -> None:
+        """Update timer display on callback without changing active mode."""
+        from .common import _update_timer_mode
         try:
-            # Get colors from light entities
-            from .common import get_color_from_light_entity
-
-            text_color_hex = get_color_from_light_entity(
-                self.hass, self._address, "text_color", default="00ff00"
-            )
-            bg_color_hex = get_color_from_light_entity(
-                self.hass, self._address, "background_color", default="000000"
-            )
-
-            # Convert hex to RGB tuples
-            text_color = (
-                int(text_color_hex[0:2], 16),
-                int(text_color_hex[2:4], 16),
-                int(text_color_hex[4:6], 16),
-            )
-            bg_color = (
-                int(bg_color_hex[0:2], 16),
-                int(bg_color_hex[2:4], 16),
-                int(bg_color_hex[4:6], 16),
-            )
-
-            # Connect if needed
-            if not self._api.is_connected:
-                _LOGGER.debug("Reconnecting to device for timer display")
-                await self._api.connect()
-
-            # Display the timer GIF
-            success = await self._api.display_timer_gif(
-                duration_seconds=duration_seconds,
-                text_color=text_color,
-                bg_color=bg_color,
-            )
-
-            if success:
-                _LOGGER.info("Timer countdown displayed successfully")
-            else:
-                _LOGGER.error("Failed to display timer countdown")
-
+            await _update_timer_mode(self.hass, self._name, self._api)
         except Exception as err:
-            _LOGGER.error("Error displaying timer: %s", err)
+            _LOGGER.error("Error updating timer on callback: %s", err)
 
     @property
     def available(self) -> bool: