fix: entity state (enable/disable) issues

Author: asruda

custom_components/mi_kettle_pro/button.py

@@ -11,6 +11,7 @@
     AVAIL_EVENT_KEY_ENTRY_ID,
     AVAIL_EVENT_KEY_IS_CONTROL,
     AVAIL_EVENT,
+    AVAIL_EVENT_KEY_AVAIL,
 )
 from .device_config import DEVICE_CONFIGS
 from .utils import gen_entity_id
@@ -71,13 +72,29 @@ async def async_added_to_hass(self) -> None:
                 self._handle_status_update
             )
 
+        # Register availability event listener
+        self._listener = self.hass.bus.async_listen(
+            AVAIL_EVENT,
+            self._handle_availability_changed
+        )
+
     async def async_will_remove_from_hass(self) -> None:
         """Run when entity will be removed from hass."""
         if self._device_manager:
             self._device_manager.device_parser.unregister_status_callback(
                 self._handle_status_update
             )
 
+        # Remove availability event listener
+        if self._listener:
+            self._listener()
+
+    def _handle_availability_changed(self, event) -> None:
+        """Handle availability change events."""
+        if event.data.get(AVAIL_EVENT_KEY_ENTRY_ID) == self._entry.entry_id:
+            self._attr_available = event.data.get(AVAIL_EVENT_KEY_AVAIL, False)
+            self.hass.loop.call_soon_threadsafe(self.async_write_ha_state)
+
     def _handle_status_update(self, status_data: dict) -> None:
         """Handle status updates from Device manager."""
         if status_data:

custom_components/mi_kettle_pro/device/mikettle_pro.py

@@ -42,9 +42,10 @@
     AVAIL_EVENT_KEY_AVAIL,
     AVAIL_EVENT,
     AVAIL_EVENT_KEY_IS_LOGIN,
-    AVAIL_EVENT_KEY_IS_CONTROL,
     WARM_INDEX,
     HEAT_INDEX,
+    CONF_HEAT_TEMPERATURE,
+    CONF_WARM_TEMPERATURE,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -71,8 +72,6 @@ def __init__(
         self.poll_interval = poll_interval
         self.entry_id = entry_id
         self.entry = self.hass.config_entries.async_get_entry(self.entry_id)
-        self.heat_temp_entity_id = gen_entity_id(self.entry, "number", "heat_temperature")
-        self.warm_temp_entity_id = gen_entity_id(self.entry, "number", "warm_temperature")
         self.bt_interface = bt_interface
 
         # connection state
@@ -656,31 +655,12 @@ def _async_disconnect(self, client: BleakClient | None = None) -> None:
 
     async def _async_update_kettle_mode(self):
         """Update kettle configuration, get temperature settings"""
-        def _get_temp_by_entity_id(entity_id):
-            temp_state = self.hass.states.get(entity_id)
-            temperature = None
-            # Parse temperature
-            if temp_state and temp_state.state not in ("unknown", "unavailable"):
-                try:
-                    temperature = int(temp_state.state)
-                    _LOGGER.debug(
-                        "Got temperature setting: temperature: %s, entity_id: %s",
-                        temperature, entity_id
-                    )
-                except ValueError:
-                    _LOGGER.warning(
-                        "Invalid temperature value: %s, entity_id: %s",
-                        temp_state.state, entity_id
-                    )
-                    raise
-            return temperature
-
         try:
             # Get heating temperature
-            heat_temperature = _get_temp_by_entity_id(self.heat_temp_entity_id)
+            heat_temperature = self.entry.options[CONF_HEAT_TEMPERATURE]
 
             # Get warming temperature
-            warm_temperature = _get_temp_by_entity_id(self.warm_temp_entity_id)
+            warm_temperature = self.entry.options[CONF_WARM_TEMPERATURE]
             _LOGGER.debug(
                 "get temperature from entity, heat: %s, warm: %s",
                 heat_temperature, warm_temperature
@@ -704,7 +684,7 @@ def _get_temp_by_entity_id(entity_id):
             )
 
         except Exception as exc:
-            _LOGGER.error("Failed to get temperature settings: %s", exc)
+            _LOGGER.exception("Failed to get temperature settings: %s", exc)
             return None
 
     def replace_mode_segment(self, current_data, mode_index, new_temperature, new_duration=None):
@@ -878,12 +858,12 @@ async def _monitor_for_temperature(self, target_temp, callback: Callable):
     async def heat_safe_check(self):
         mode = self.get_current_mode()
         if not mode  >= 0:
-            _LOGGER.error("turn off heating failed, mode: %s", mode)
+            _LOGGER.error("Turn off heating failed, mode: %s", mode)
             return
         if mode == HEAT_INDEX:
             ret = await self.async_read_mode_config_by_index(mode)
             if not ret:
-                _LOGGER.error("turn off heating failed, ret: %s", ret)
+                _LOGGER.error("Turn off heating failed, ret: %s", ret)
                 return
             target_temp = ret["temperature"]
             _LOGGER.debug("check if mode temperature reached, mode: %s, target_temp: %s", mode, target_temp)

custom_components/mi_kettle_pro/device_helpers.py

@@ -199,7 +199,7 @@ def detection_callback(device, adv_data):
             _LOGGER.error("Advertisement scan failed: %s", exc)
             return None
         except Exception as exc:
-            _LOGGER.error("Advertisement scan failed unexpected: %s", exc)
+            _LOGGER.exception("Advertisement scan failed unexpected: %s", exc)
             return None
         finally:
             await scanner.stop()

custom_components/mi_kettle_pro/manifest.json

@@ -12,5 +12,5 @@
   "requirements": ["bleak-retry-connector>=3.9.0", "bleak>=0.22.3"],
   "ssdp": [],
   "zeroconf": [],
-  "version": "v0.2.0"
+  "version": "v0.2.1"
 }

custom_components/mi_kettle_pro/number.py

@@ -20,7 +20,9 @@
     MAX_WARM_TEMPERATURE,
     DEFAULT_HEAT_TEMPERATURE,
     DEFAULT_WARM_TEMPERATURE,
-    AVAIL_EVENT_KEY_IS_CONTROL,
+    AVAIL_EVENT,
+    AVAIL_EVENT_KEY_ENTRY_ID,
+    AVAIL_EVENT_KEY_AVAIL,
 )
 from .utils import gen_entity_id
 from .device_config import DEVICE_CONFIGS
@@ -68,10 +70,10 @@ def __init__(self, entry: ConfigEntry) -> None:
             "manufacturer": "Xiaomi",
             "model": "Mi Kettle Pro",
         }
-
+        self._listener = None
         # Debounce related attributes
         self._debounce_timer = None
-        self._debounce_delay = 0.5
+        self._debounce_delay = 0.8
         self._pending_value = None
 
         # value
@@ -84,22 +86,16 @@ async def async_added_to_hass(self) -> None:
         device_manager_key = f"{self._entry.entry_id}_device_manager"
         self._device_manager = self.hass.data[DOMAIN].get(device_manager_key)
 
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        device_manager_key = f"{self._entry.entry_id}_device_manager"
-        self._device_manager = self.hass.data[DOMAIN].get(device_manager_key)
-
-        if self._device_manager:
-            self._device_manager.device_parser.register_status_callback(
-                self._handle_status_update
-            )
+        # Register availability event listener
+        self._listener = self.hass.bus.async_listen(
+            AVAIL_EVENT,
+            self._handle_availability_changed
+        )
 
     async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        if self._device_manager:
-            self._device_manager.device_parser.unregister_status_callback(
-                self._handle_status_update
-            )
+        # Remove availability event listener
+        if self._listener:
+            self._listener()
 
     async def _async_debounced_set_value(self, value: int) -> None:
         """Actual set value method after debounce"""
@@ -133,13 +129,11 @@ async def _async_apply_value(self, value: int) -> None:
             options=new_options
         )
 
-    def _handle_status_update(self, status_data: dict) -> None:
-        """Handle status updates from Device manager."""
-        if status_data:
-            self._attr_available = status_data.get(
-                AVAIL_EVENT_KEY_IS_CONTROL, False
-            )
-            self.hass.loop.call_soon_threadsafe(self.async_write_ha_state)        
+    def _handle_availability_changed(self, event) -> None:
+        """Handle availability change events."""
+        if event.data.get(AVAIL_EVENT_KEY_ENTRY_ID) == self._entry.entry_id:
+            self._attr_available = event.data.get(AVAIL_EVENT_KEY_AVAIL, False)
+            self.hass.loop.call_soon_threadsafe(self.async_write_ha_state)            
 
 class MiKettleProHeatTemperatureNumber(MiKettleProBaseNumber):
     """Representation of a Mi Kettle Pro heat temperature number entity."""

custom_components/mi_kettle_pro/sensor.py

@@ -174,6 +174,5 @@ def _handle_status_update(self, status_data: dict) -> None:
         """Handle status updates from Bluetooth manager."""
         if status_data:
             action = status_data.get(self._status_key, "unknown")
-            if action != "idle":
-                self._attr_native_value = True
+            self._attr_native_value = True if action != "idle" else False
             self.hass.loop.call_soon_threadsafe(self.async_write_ha_state)