Merge 506bd9f52e into e5165f34da

custom_components/xiaomi_home/__init__.py

@@ -349,3 +349,101 @@ async def async_remove_config_entry_device(
     _LOGGER.info(
         'remove device, %s, %s', identifiers[1], device_entry.id)
     return True
+
+
+async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry):
+    """Migrate old entry."""
+    _LOGGER.debug(
+        'Migrating configuration from version %s.%s',
+        config_entry.version,
+        config_entry.minor_version,
+    )
+
+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
+    if config_entry.version == 1:
+        await _migrate_v1_to_v2(hass, config_entry)
+
+    _LOGGER.debug(
+        'Migration to configuration version %s.%s successful',
+        config_entry.version,
+        config_entry.minor_version,
+    )
+
+    return True
+
+
+async def _migrate_v1_to_v2(hass: HomeAssistant, config_entry: ConfigEntry):
+    def ha_persistent_notify(
+        notify_id: str, title: Optional[str] = None,
+        message: Optional[str] = None
+    ) -> None:
+        """Send messages in Notifications dialog box."""
+        if title:
+            persistent_notification.async_create(
+                hass=hass,  message=message or '',
+                title=title, notification_id=notify_id)
+        else:
+            persistent_notification.async_dismiss(
+                hass=hass, notification_id=notify_id)
+
+    entry_id = config_entry.entry_id
+    entry_data = dict(config_entry.data)
+
+    ha_persistent_notify(
+        notify_id=f'{entry_id}.oauth_error', title=None, message=None)
+
+    miot_client: MIoTClient = await get_miot_instance_async(
+        hass=hass, entry_id=entry_id,
+        entry_data=entry_data,
+        persistent_notify=ha_persistent_notify)
+    # Spec parser
+    spec_parser = MIoTSpecParser(
+        lang=entry_data.get(
+            'integration_language', DEFAULT_INTEGRATION_LANGUAGE),
+        storage=miot_client.miot_storage,
+        loop=miot_client.main_loop
+    )
+    await spec_parser.init_async()
+    # Manufacturer
+    manufacturer: DeviceManufacturer = DeviceManufacturer(
+        storage=miot_client.miot_storage,
+        loop=miot_client.main_loop)
+    await manufacturer.init_async()
+    er = entity_registry.async_get(hass)
+    for _, info in miot_client.device_list.items():
+        spec_instance = await spec_parser.parse(urn=info['urn'])
+        if not isinstance(spec_instance, MIoTSpecInstance):
+            continue
+        device: MIoTDevice = MIoTDevice(
+            miot_client=miot_client,
+            device_info={
+                **info, 'manufacturer': manufacturer.get_name(
+                    info.get('manufacturer', ''))},
+            spec_instance=spec_instance)
+        device.spec_transform()
+
+        # Update unique_id
+        for platform, entities in device.entity_list.items():
+            for entity in entities:
+                if not isinstance(entity.spec, MIoTSpecService):
+                    continue
+                old_unique_id = device.gen_service_entity_id_v1(
+                    ha_domain=DOMAIN,
+                    siid=entity.spec.iid,
+                )
+                entity_id = er.async_get_entity_id(
+                    platform, DOMAIN, old_unique_id
+                )
+                if entity_id is None:
+                    continue
+                new_unique_id = device.gen_service_entity_id(
+                    ha_domain=DOMAIN,
+                    siid=entity.spec.iid,
+                    description=entity.spec.description,
+                )
+                er.async_update_entity(entity_id, new_unique_id=new_unique_id)
+
+    hass.config_entries.async_update_entry(config_entry, version=2)

custom_components/xiaomi_home/config_flow.py

@@ -105,7 +105,7 @@ _LOGGER = logging.getLogger(__name__)
 class XiaomiMihomeConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Xiaomi Home config flow."""
     # pylint: disable=unused-argument, inconsistent-quotes
-    VERSION = 1
+    VERSION = 2
     MINOR_VERSION = 1
     DEFAULT_AREA_NAME_RULE = 'room'
     _main_loop: asyncio.AbstractEventLoop

custom_components/xiaomi_home/miot/miot_device.py

@@ -345,6 +345,11 @@ class MIoTDevice:
             f'{ha_domain}.{self._model_strs[0][:9]}_{self.did_tag}_'
             f'{self._model_strs[-1][:20]}')
 
+    def gen_service_entity_id_v1(self, ha_domain: str, siid: int) -> str:
+        return (
+            f'{ha_domain}.{self._model_strs[0][:9]}_{self.did_tag}_'
+            f'{self._model_strs[-1][:20]}_s_{siid}')
+
     def gen_service_entity_id(self, ha_domain: str, siid: int,
                               description: str) -> str:
         return (

custom_components/xiaomi_home/translations/it.json

@@ -113,7 +113,7 @@
             },
             "config_options": {
                 "title": "Opzioni di Configurazione",
-                "description": "### Ciao, {nick_name}\r\n\r\nID Xiaomi: {uid}\r\nRegione di Login Corrente: {cloud_server}\r\n\r\nSeleziona le opzioni che desideri configurare, poi clicca AVANTI.",
+                "description": "### Ciao, {nick_name}\r\n\r\nID Xiaomi: {uid}\r\nRegione di Login Corrente: {cloud_server}\r\nID istanza di integrazione: {instance_id}\r\n\r\nSeleziona le opzioni che desideri configurare, poi clicca AVANTI.",
                 "data": {
                     "integration_language": "Lingua dell'Integrazione",
                     "update_user_info": "Aggiorna le informazioni dell'utente",

custom_components/xiaomi_home/vacuum.py

@@ -47,29 +47,26 @@ Vacuum entities for Xiaomi Home.
 """
 from __future__ import annotations
 from typing import Any, Optional
+import re
 import logging
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.components.vacuum import (
-    StateVacuumEntity,
-    VacuumEntityFeature
-)
+from homeassistant.components.vacuum import (StateVacuumEntity,
+                                             VacuumEntityFeature)
 
 from .miot.const import DOMAIN
 from .miot.miot_device import MIoTDevice, MIoTServiceEntity, MIoTEntityData
-from .miot.miot_spec import (
-    MIoTSpecAction,
-    MIoTSpecProperty)
+from .miot.miot_spec import (MIoTSpecAction, MIoTSpecProperty)
 
 _LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_entry(
-        hass: HomeAssistant,
-        config_entry: ConfigEntry,
-        async_add_entities: AddEntitiesCallback,
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
 ) -> None:
     device_list: list[MIoTDevice] = hass.data[DOMAIN]['devices'][
         config_entry.entry_id]
@@ -99,10 +96,12 @@ class Vacuum(MIoTServiceEntity, StateVacuumEntity):
     _status_map: Optional[dict[int, str]]
     _fan_level_map: Optional[dict[int, str]]
 
-    def __init__(
-        self, miot_device: MIoTDevice, entity_data: MIoTEntityData
-    ) -> None:
+    _device_name: str
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
         super().__init__(miot_device=miot_device, entity_data=entity_data)
+        self._device_name = miot_device.name
         self._attr_supported_features = VacuumEntityFeature(0)
 
         self._prop_status = None
@@ -121,21 +120,21 @@ class Vacuum(MIoTServiceEntity, StateVacuumEntity):
         for prop in entity_data.props:
             if prop.name == 'status':
                 if not prop.value_list:
-                    _LOGGER.error(
-                        'invalid status value_list, %s', self.entity_id)
+                    _LOGGER.error('invalid status value_list, %s',
+                                  self.entity_id)
                     continue
                 self._status_map = prop.value_list.to_map()
+                self._attr_supported_features |= VacuumEntityFeature.STATE
                 self._prop_status = prop
             elif prop.name == 'fan-level':
                 if not prop.value_list:
-                    _LOGGER.error(
-                        'invalid fan-level value_list, %s', self.entity_id)
+                    _LOGGER.error('invalid fan-level value_list, %s',
+                                  self.entity_id)
                     continue
                 self._fan_level_map = prop.value_list.to_map()
                 self._attr_fan_speed_list = list(self._fan_level_map.values())
                 self._attr_supported_features |= VacuumEntityFeature.FAN_SPEED
                 self._prop_fan_level = prop
-
             elif prop.name == 'battery-level':
                 self._attr_supported_features |= VacuumEntityFeature.BATTERY
                 self._prop_battery_level = prop
@@ -155,16 +154,24 @@ class Vacuum(MIoTServiceEntity, StateVacuumEntity):
             elif action.name == 'stop-and-gocharge':
                 self._attr_supported_features |= VacuumEntityFeature.RETURN_HOME
                 self._action_stop_and_gocharge = action
-
             elif action.name == 'identify':
                 self._attr_supported_features |= VacuumEntityFeature.LOCATE
                 self._action_identify = action
 
     async def async_start(self) -> None:
         """Start or resume the cleaning task."""
-        if self.state.lower() in ['paused', '暂停中']:
-            await self.action_async(action=self._action_continue_sweep)
-            return
+        try:  # VacuumActivity is introduced in HA core 2025.1.0
+            # pylint: disable=import-outside-toplevel
+            from homeassistant.components.vacuum import VacuumActivity
+            if (self.activity
+                    == VacuumActivity.PAUSED) and self._action_continue_sweep:
+                await self.action_async(action=self._action_continue_sweep)
+                return
+        except ImportError:
+            if self.state and (self.state in {'paused', 'pause'
+                                             }) and self._action_continue_sweep:
+                await self.action_async(action=self._action_continue_sweep)
+                return
         await self.action_async(action=self._action_start_sweep)
 
     async def async_stop(self, **kwargs: Any) -> None:
@@ -179,31 +186,92 @@ class Vacuum(MIoTServiceEntity, StateVacuumEntity):
         """Set the vacuum cleaner to return to the dock."""
         await self.action_async(action=self._action_stop_and_gocharge)
 
-    async def async_clean_spot(self, **kwargs: Any) -> None:
-        """Perform a spot clean-up."""
-
     async def async_locate(self, **kwargs: Any) -> None:
         """Locate the vacuum cleaner."""
         await self.action_async(action=self._action_identify)
 
     async def async_set_fan_speed(self, fan_speed: str, **kwargs: Any) -> None:
         """Set fan speed."""
+        fan_level_value = self.get_map_key(map_=self._fan_level_map,
+                                           value=fan_speed)
+        await self.set_property_async(prop=self._prop_fan_level,
+                                      value=fan_level_value)
+
+    @property
+    def name(self) -> Optional[str]:
+        """Name of the vacuum entity."""
+        return self._device_name
 
     @property
     def state(self) -> Optional[str]:
-        """Return the current state of the vacuum cleaner."""
-        return self.get_map_value(
-            map_=self._status_map,
-            key=self.get_prop_value(prop=self._prop_status))
+        """Return the current state of the vacuum cleaner.
+
+        To fix the HA warning below:
+            Detected that custom integration 'xiaomi_home' is setting state
+            directly.Entity XXX(<class 'custom_components.xiaomi_home.vacuum
+            .Vacuum'>)should implement the 'activity' property and return
+            its state using the VacuumActivity enum.This will stop working in
+            Home Assistant 2026.1.
+
+        Refer to
+        https://developers.home-assistant.io/blog/2024/12/08/new-vacuum-state-property
+
+        There are only 6 states in VacuumActivity enum. To be compatible with
+        more constants, try get matching VacuumActivity enum first, return state
+        string as before if there is no match. In Home Assistant 2026.1, every
+        state should map to a VacuumActivity enum.
+        """
+        return self.activity
+
+    @property
+    def activity(self) -> Optional[str]:
+        """The current vacuum activity."""
+        status = self.get_prop_value(prop=self._prop_status)
+        if status is None:
+            return None
+        status_value = self.get_map_value(map_=self._status_map, key=status)
+        if status_value is None:
+            return None
+        try:
+            # pylint: disable=import-outside-toplevel
+            from homeassistant.components.vacuum import VacuumActivity
+            status_value = status_value.lower()
+            status_str = re.sub(r'[^a-z]', '', status_value)
+            if status_str in {
+                    'charging', 'charged', 'chargingcompleted', 'fullcharge',
+                    'fullpower', 'findchargerpause', 'drying', 'washing',
+                    'wash', 'inthewash', 'inthedry', 'stationworking',
+                    'dustcollecting', 'upgrade', 'upgrading', 'updating'
+            }:
+                return VacuumActivity.DOCKED
+            if status_str in {'paused', 'pause'}:
+                return VacuumActivity.PAUSED
+            if status_str in {
+                    'gocharging', 'cleancompletegocharging', 'findchargewash',
+                    'backtowashmop', 'gowash', 'gowashing', 'summon'
+            }:
+                return VacuumActivity.RETURNING
+            if (status_str.find('sweeping')
+                    != -1) or (status_str.find('mopping')
+                               != -1) or (status_str in {
+                                   'cleaning', 'remoteclean', 'continuesweep',
+                                   'busy', 'building', 'buildingmap', 'mapping'
+                               }):
+                return VacuumActivity.CLEANING
+            if status_str in {'error', 'breakcharging', 'gochargebreak'}:
+                return VacuumActivity.ERROR
+            return VacuumActivity.IDLE
+        except ImportError:
+            return status_value
 
     @property
     def battery_level(self) -> Optional[int]:
-        """Return the current battery level of the vacuum cleaner."""
+        """The current battery level of the vacuum cleaner."""
         return self.get_prop_value(prop=self._prop_battery_level)
 
     @property
     def fan_speed(self) -> Optional[str]:
-        """Return the current fan speed of the vacuum cleaner."""
+        """The current fan speed of the vacuum cleaner."""
         return self.get_map_value(
             map_=self._fan_level_map,
             key=self.get_prop_value(prop=self._prop_fan_level))