fix: Preserve pre-scene color across API polls so "None" restores it (#18)

Two bugs caused selecting "None" in the scene dropdown to set the light
to black instead of restoring the previous color:

1. last_color/last_color_temp_kelvin were lost during API poll cycles
   because _fetch_device_state() didn't preserve them from existing state.

2. async_clear_scene() fell back to None instead of last_color when
   rejecting RGBColor(0,0,0) returned by the API during scenes.

Also preserves last_scene_id/last_scene_name needed by music mode disable.

Author: Tom Lasswell

custom_components/govee/coordinator.py

@@ -477,6 +477,17 @@ async def _fetch_device_state(
                 # DIY scenes also persist across power cycles
                 if existing_state.active_diy_scene:
                     state.active_diy_scene = existing_state.active_diy_scene
+                # Preserve restore-target fields across API polls.
+                # These are "memory" fields — always preserved regardless of power state.
+                if existing_state.last_color is not None:
+                    state.last_color = existing_state.last_color
+                if existing_state.last_color_temp_kelvin is not None:
+                    state.last_color_temp_kelvin = existing_state.last_color_temp_kelvin
+                if existing_state.last_scene_id is not None:
+                    state.last_scene_id = existing_state.last_scene_id
+                if existing_state.last_scene_name is not None:
+                    state.last_scene_name = existing_state.last_scene_name
+
                 self._preserve_optimistic_field(
                     existing_state, state, device_id, "dreamview_enabled", "DreamView"
                 )
@@ -961,7 +972,11 @@ async def async_clear_scene(self, device_id: str) -> None:
             self.clear_diy_scene(device_id)
             return
 
+        # Resolve the color to restore. Skip RGBColor(0,0,0) — the API returns
+        # colorRgb=0 when a scene is running, which is not a meaningful restore target.
         color = state.color or state.last_color
+        if color and color.as_packed_int == 0:
+            color = state.last_color
         color_temp = state.color_temp_kelvin or state.last_color_temp_kelvin
 
         success = False

custom_components/govee/manifest.json

@@ -16,6 +16,6 @@
     "cryptography>=41.0.0"
   ],
   "ssdp": [],
-  "version": "2026.3.2",
+  "version": "2026.3.4",
   "zeroconf": []
 }

custom_components/govee/models/state.py

@@ -248,7 +248,9 @@ def apply_optimistic_scene(
         self.source = "optimistic"
         # Save current color/color_temp before clearing so we can restore on scene clear.
         # Only save when a value exists so scene A → scene B → clear restores pre-A color.
-        if self.color is not None:
+        # Skip RGBColor(0,0,0) — the API returns colorRgb=0 when a scene is running,
+        # which is not a meaningful color to restore.
+        if self.color is not None and self.color.as_packed_int != 0:
             self.last_color = self.color
             self.last_color_temp_kelvin = None
         elif self.color_temp_kelvin is not None:
@@ -273,7 +275,7 @@ def apply_optimistic_diy_scene(self, scene_id: str) -> None:
         self.active_diy_scene = scene_id
         self.source = "optimistic"
         # Save current color/color_temp before clearing (same logic as regular scenes)
-        if self.color is not None:
+        if self.color is not None and self.color.as_packed_int != 0:
             self.last_color = self.color
             self.last_color_temp_kelvin = None
         elif self.color_temp_kelvin is not None:

tests/test_coordinator.py

@@ -1010,3 +1010,88 @@ def test_clear_scene_clears_both_scene_types(self):
         assert state.active_scene is None
         assert state.active_scene_name is None
         assert state.active_diy_scene is None
+
+
+class TestStatePreservationAcrossApiPoll:
+    """Test that restore-target fields survive API poll cycles."""
+
+    def test_last_color_preserved_across_api_poll(self):
+        """Test last_color is preserved when API returns a fresh state."""
+        existing = GoveeDeviceState.create_empty("test_id")
+        existing.color = RGBColor(255, 0, 0)
+        existing.apply_optimistic_scene("scene_1", "Sunset")
+        assert existing.last_color == RGBColor(255, 0, 0)
+
+        # Simulate API poll returning a fresh state (no last_color)
+        new_state = GoveeDeviceState.create_empty("test_id")
+        new_state.power_state = True
+
+        # Mimic coordinator preservation logic
+        if existing.last_color is not None:
+            new_state.last_color = existing.last_color
+
+        assert new_state.last_color == RGBColor(255, 0, 0)
+
+    def test_last_color_temp_preserved_across_api_poll(self):
+        """Test last_color_temp_kelvin is preserved when API returns a fresh state."""
+        existing = GoveeDeviceState.create_empty("test_id")
+        existing.color_temp_kelvin = 4500
+        existing.apply_optimistic_scene("scene_1", "Sunset")
+        assert existing.last_color_temp_kelvin == 4500
+
+        new_state = GoveeDeviceState.create_empty("test_id")
+        new_state.power_state = True
+
+        if existing.last_color_temp_kelvin is not None:
+            new_state.last_color_temp_kelvin = existing.last_color_temp_kelvin
+
+        assert new_state.last_color_temp_kelvin == 4500
+
+    def test_last_scene_preserved_across_api_poll(self):
+        """Test last_scene_id and last_scene_name survive API poll."""
+        existing = GoveeDeviceState.create_empty("test_id")
+        existing.apply_optimistic_scene("scene_42", "Aurora")
+        assert existing.last_scene_id == "scene_42"
+        assert existing.last_scene_name == "Aurora"
+
+        new_state = GoveeDeviceState.create_empty("test_id")
+
+        if existing.last_scene_id is not None:
+            new_state.last_scene_id = existing.last_scene_id
+        if existing.last_scene_name is not None:
+            new_state.last_scene_name = existing.last_scene_name
+
+        assert new_state.last_scene_id == "scene_42"
+        assert new_state.last_scene_name == "Aurora"
+
+    def test_full_flow_color_scene_poll_clear(self):
+        """End-to-end: set red → scene → API poll (colorRgb=0) → clear → red resolved."""
+        # Step 1: User sets red
+        state = GoveeDeviceState.create_empty("test_id")
+        state.color = RGBColor(255, 0, 0)
+        state.power_state = True
+
+        # Step 2: User activates scene — saves red as last_color
+        state.apply_optimistic_scene("scene_1", "Party")
+        assert state.last_color == RGBColor(255, 0, 0)
+        assert state.color is None
+
+        # Step 3: API poll returns fresh state with colorRgb=0 (scene running)
+        api_state = GoveeDeviceState.create_empty("test_id")
+        api_state.power_state = True
+        api_state.color = RGBColor(0, 0, 0)  # API returns black during scene
+
+        # Coordinator preserves memory fields
+        if state.active_scene:
+            api_state.active_scene = state.active_scene
+        if state.active_scene_name:
+            api_state.active_scene_name = state.active_scene_name
+        if state.last_color is not None:
+            api_state.last_color = state.last_color
+
+        # Step 4: Resolve color for clear_scene — reject black, fall back to last_color
+        color = api_state.color or api_state.last_color
+        if color and color.as_packed_int == 0:
+            color = api_state.last_color
+
+        assert color == RGBColor(255, 0, 0)

tests/test_models.py

@@ -780,6 +780,24 @@ def test_diy_scene_chain_preserves_first_color(self):
         state.apply_optimistic_diy_scene("2")
         assert state.last_color == RGBColor(128, 128, 0)
 
+    def test_scene_does_not_save_black(self):
+        """Test that RGBColor(0,0,0) is not saved as last_color.
+
+        The API returns colorRgb=0 when a scene is running, which is not a
+        meaningful color to restore.
+        """
+        state = GoveeDeviceState.create_empty("test_id")
+        state.color = RGBColor(0, 0, 0)
+        state.apply_optimistic_scene("123", "Sunrise")
+        assert state.last_color is None
+
+    def test_diy_scene_does_not_save_black(self):
+        """Test that RGBColor(0,0,0) is not saved as last_color for DIY scenes."""
+        state = GoveeDeviceState.create_empty("test_id")
+        state.color = RGBColor(0, 0, 0)
+        state.apply_optimistic_diy_scene("456")
+        assert state.last_color is None
+
 
 # ==============================================================================
 # Command Tests