Merge c1a6c7e6d2 into e09676661c

custom_components/xiaomi_home/device_tracker.py

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (C) 2024 Xiaomi Corporation.
+
+The ownership and intellectual property rights of Xiaomi Home Assistant
+Integration and related Xiaomi cloud service API interface provided under this
+license, including source code and object code (collectively, "Licensed Work"),
+are owned by Xiaomi. Subject to the terms and conditions of this License, Xiaomi
+hereby grants you a personal, limited, non-exclusive, non-transferable,
+non-sublicensable, and royalty-free license to reproduce, use, modify, and
+distribute the Licensed Work only for your use of Home Assistant for
+non-commercial purposes. For the avoidance of doubt, Xiaomi does not authorize
+you to use the Licensed Work for any other purpose, including but not limited
+to use Licensed Work to develop applications (APP), Web services, and other
+forms of software.
+
+You may reproduce and distribute copies of the Licensed Work, with or without
+modifications, whether in source or object form, provided that you must give
+any other recipients of the Licensed Work a copy of this License and retain all
+copyright and disclaimers.
+
+Xiaomi provides the Licensed Work on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied, including, without
+limitation, any warranties, undertakes, or conditions of TITLE, NO ERROR OR
+OMISSION, CONTINUITY, RELIABILITY, NON-INFRINGEMENT, MERCHANTABILITY, or
+FITNESS FOR A PARTICULAR PURPOSE. In any event, you are solely responsible
+for any direct, indirect, special, incidental, or consequential damages or
+losses arising from the use or inability to use the Licensed Work.
+
+Xiaomi reserves all rights not expressly granted to you in this License.
+Except for the rights expressly granted by Xiaomi under this License, Xiaomi
+does not authorize you in any form to use the trademarks, copyrights, or other
+forms of intellectual property rights of Xiaomi and its affiliates, including,
+without limitation, without obtaining other written permission from Xiaomi, you
+shall not use "Xiaomi", "Mijia" and other words related to Xiaomi or words that
+may make the public associate with Xiaomi in any form to publicize or promote
+the software or hardware devices that use the Licensed Work.
+
+Xiaomi has the right to immediately terminate all your authorization under this
+License in the event:
+1. You assert patent invalidation, litigation, or other claims against patents
+or other intellectual property rights of Xiaomi or its affiliates; or,
+2. You make, have made, manufacture, sell, or offer to sell products that knock
+off Xiaomi or its affiliates' products.
+
+Device tracker entities for Xiaomi Home.
+"""
+from __future__ import annotations
+from typing import Optional
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.components.device_tracker import TrackerEntity
+
+from .miot.const import DOMAIN
+from .miot.miot_device import MIoTDevice, MIoTServiceEntity, MIoTEntityData
+from .miot.miot_spec import MIoTSpecProperty
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    device_list: list[MIoTDevice] = hass.data[DOMAIN]['devices'][
+        config_entry.entry_id]
+    new_entities = []
+    for miot_device in device_list:
+        for data in miot_device.entity_list.get('device_tracker', []):
+            new_entities.append(
+                DeviceTracker(miot_device=miot_device, entity_data=data))
+    if new_entities:
+        async_add_entities(new_entities)
+
+
+class DeviceTracker(MIoTServiceEntity, TrackerEntity):
+    """Tracker entities for Xiaomi Home."""
+    _prop_battery_level: Optional[MIoTSpecProperty]
+    _prop_latitude: Optional[MIoTSpecProperty]
+    _prop_longitude: Optional[MIoTSpecProperty]
+    _prop_area_id: Optional[MIoTSpecProperty]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        self._prop_battery_level = None
+        self._prop_latitude = None
+        self._prop_longitude = None
+        self._prop_area_id = None
+
+        # properties
+        for prop in entity_data.props:
+            if prop.name == 'battery-level':
+                self._prop_battery_level = prop
+            elif prop.name == 'latitude':
+                self._prop_latitude = prop
+            elif prop.name == 'longitude':
+                self._prop_longitude = prop
+            elif prop.name == 'area-id':
+                self._prop_area_id = prop
+
+    @property
+    def battery_level(self) -> Optional[int]:
+        """The battery level of the device."""
+        return None if (self._prop_battery_level
+                        is None) else self.get_prop_value(
+                            prop=self._prop_battery_level)
+
+    @property
+    def latitude(self) -> Optional[float]:
+        """The latitude coordinate of the device."""
+        return None if self._prop_latitude is None else self.get_prop_value(
+            prop=self._prop_latitude)
+
+    @property
+    def longitude(self) -> Optional[float]:
+        """The longitude coordinate of the device."""
+        return None if self._prop_longitude is None else self.get_prop_value(
+            prop=self._prop_longitude)
+
+    @property
+    def location_name(self) -> Optional[str]:
+        """The location name of the device."""
+        return None if self._prop_area_id is None else self.get_prop_value(
+            prop=self._prop_area_id)

custom_components/xiaomi_home/fan.py

@@ -221,7 +221,7 @@ class Fan(MIoTServiceEntity, FanEntity):
         # preset_mode
         if preset_mode:
             await self.set_property_async(
-                self._prop_mode,
+                prop=self._prop_mode,
                 value=self.get_map_key(
                     map_=self._mode_map, value=preset_mode))
 
@@ -258,7 +258,7 @@ class Fan(MIoTServiceEntity, FanEntity):
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set the preset mode."""
         await self.set_property_async(
-            self._prop_mode,
+            prop=self._prop_mode,
             value=self.get_map_key(
                 map_=self._mode_map, value=preset_mode))
 

custom_components/xiaomi_home/light.py

@@ -48,7 +48,6 @@ Light entities for Xiaomi Home.
 
 from __future__ import annotations
 import logging
-from tkinter import N
 from typing import Any, Optional, List, Dict
 
 from homeassistant.config_entries import ConfigEntry

custom_components/xiaomi_home/media_player.py

@@ -0,0 +1,470 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (C) 2024 Xiaomi Corporation.
+
+The ownership and intellectual property rights of Xiaomi Home Assistant
+Integration and related Xiaomi cloud service API interface provided under this
+license, including source code and object code (collectively, "Licensed Work"),
+are owned by Xiaomi. Subject to the terms and conditions of this License, Xiaomi
+hereby grants you a personal, limited, non-exclusive, non-transferable,
+non-sublicensable, and royalty-free license to reproduce, use, modify, and
+distribute the Licensed Work only for your use of Home Assistant for
+non-commercial purposes. For the avoidance of doubt, Xiaomi does not authorize
+you to use the Licensed Work for any other purpose, including but not limited
+to use Licensed Work to develop applications (APP), Web services, and other
+forms of software.
+
+You may reproduce and distribute copies of the Licensed Work, with or without
+modifications, whether in source or object form, provided that you must give
+any other recipients of the Licensed Work a copy of this License and retain all
+copyright and disclaimers.
+
+Xiaomi provides the Licensed Work on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied, including, without
+limitation, any warranties, undertakes, or conditions of TITLE, NO ERROR OR
+OMISSION, CONTINUITY, RELIABILITY, NON-INFRINGEMENT, MERCHANTABILITY, or
+FITNESS FOR A PARTICULAR PURPOSE. In any event, you are solely responsible
+for any direct, indirect, special, incidental, or consequential damages or
+losses arising from the use or inability to use the Licensed Work.
+
+Xiaomi reserves all rights not expressly granted to you in this License.
+Except for the rights expressly granted by Xiaomi under this License, Xiaomi
+does not authorize you in any form to use the trademarks, copyrights, or other
+forms of intellectual property rights of Xiaomi and its affiliates, including,
+without limitation, without obtaining other written permission from Xiaomi, you
+shall not use "Xiaomi", "Mijia" and other words related to Xiaomi or words that
+may make the public associate with Xiaomi in any form to publicize or promote
+the software or hardware devices that use the Licensed Work.
+
+Xiaomi has the right to immediately terminate all your authorization under this
+License in the event:
+1. You assert patent invalidation, litigation, or other claims against patents
+or other intellectual property rights of Xiaomi or its affiliates; or,
+2. You make, have made, manufacture, sell, or offer to sell products that knock
+off Xiaomi or its affiliates' products.
+
+Media player entities for Xiaomi Home.
+"""
+from __future__ import annotations
+import logging
+from typing import Optional
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.components.media_player import (MediaPlayerEntity,
+                                                   MediaPlayerEntityFeature,
+                                                   MediaPlayerDeviceClass,
+                                                   MediaPlayerState, MediaType)
+
+from .miot.const import DOMAIN
+from .miot.miot_device import MIoTDevice, MIoTServiceEntity, MIoTEntityData
+from .miot.miot_spec import MIoTSpecProperty, MIoTSpecAction
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry,
+                            async_add_entities: AddEntitiesCallback) -> None:
+    """Set up a config entry."""
+    device_list: list[MIoTDevice] = hass.data[DOMAIN]['devices'][
+        config_entry.entry_id]
+
+    new_entities = []
+    for miot_device in device_list:
+        for data in miot_device.entity_list.get('wifi-speaker', []):
+            new_entities.append(
+                WifiSpeaker(miot_device=miot_device, entity_data=data))
+        for data in miot_device.entity_list.get('television', []):
+            new_entities.append(
+                Television(miot_device=miot_device, entity_data=data))
+
+    if new_entities:
+        async_add_entities(new_entities)
+
+
+class FeatureVolumeMute(MIoTServiceEntity, MediaPlayerEntity):
+    """VOLUME_MUTE feature of the media player entity."""
+    _prop_mute: Optional[MIoTSpecProperty]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._prop_mute = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # properties
+        for prop in entity_data.props:
+            if prop.name == 'mute':
+                self._attr_supported_features |= (
+                    MediaPlayerEntityFeature.VOLUME_MUTE)
+                self._prop_mute = prop
+
+    @property
+    def is_volume_muted(self) -> Optional[bool]:
+        """True if volume is currently muted."""
+        return self.get_prop_value(
+            prop=self._prop_mute) if self._prop_mute else None
+
+    async def async_mute_volume(self, mute: bool) -> None:
+        """Mute the volume."""
+        await self.set_property_async(prop=self._prop_mute, value=mute)
+
+
+class FeatureVolumeSet(MIoTServiceEntity, MediaPlayerEntity):
+    """VOLUME_SET feature of the media player entity."""
+    _prop_volume: Optional[MIoTSpecProperty]
+    _volume_value_min: Optional[float]
+    _volume_value_max: Optional[float]
+    _volume_value_range: Optional[float]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._prop_volume = None
+        self._volume_value_min = None
+        self._volume_value_max = None
+        self._volume_value_range = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # properties
+        for prop in entity_data.props:
+            if prop.name == 'volume':
+                if not prop.value_range:
+                    _LOGGER.error('invalid volume value_range format, %s',
+                                  self.entity_id)
+                    continue
+                self._volume_value_min = prop.value_range.min_
+                self._volume_value_max = prop.value_range.max_
+                self._volume_value_range = (prop.value_range.max_ -
+                                            prop.value_range.min_)
+                self._attr_volume_step = (prop.value_range.step /
+                                          self._volume_value_range)
+                self._attr_supported_features |= (
+                    MediaPlayerEntityFeature.VOLUME_SET |
+                    MediaPlayerEntityFeature.VOLUME_STEP)
+                self._prop_volume = prop
+
+    async def async_set_volume_level(self, volume: float) -> None:
+        """Set volume level."""
+        value = volume * self._volume_value_range + self._volume_value_min
+        if value > self._volume_value_max:
+            value = self._volume_value_max
+        elif value < self._volume_value_min:
+            value = self._volume_value_min
+        await self.set_property_async(prop=self._prop_volume, value=value)
+
+    @property
+    def volume_level(self) -> Optional[float]:
+        """The current volume level, range [0, 1]."""
+        value = self.get_prop_value(
+            prop=self._prop_volume) if self._prop_volume else None
+        if value is None:
+            return None
+        return (value - self._volume_value_min) / self._volume_value_range
+
+
+class FeaturePlay(MIoTServiceEntity, MediaPlayerEntity):
+    """PLAY feature of the media player entity."""
+    _action_play: Optional[MIoTSpecAction]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._action_play = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # actions
+        for act in entity_data.actions:
+            if act.name == 'play':
+                self._attr_supported_features |= (MediaPlayerEntityFeature.PLAY)
+                self._action_play = act
+
+    async def async_media_play(self) -> None:
+        """Send play command."""
+        await self.action_async(action=self._action_play)
+
+
+class FeaturePause(MIoTServiceEntity, MediaPlayerEntity):
+    """PAUSE feature of the media player entity."""
+    _action_pause: Optional[MIoTSpecAction]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._action_pause = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # actions
+        for act in entity_data.actions:
+            if act.name == 'pause':
+                self._attr_supported_features |= (
+                    MediaPlayerEntityFeature.PAUSE)
+                self._action_pause = act
+
+    async def async_media_pause(self) -> None:
+        """Send pause command."""
+        await self.action_async(action=self._action_pause)
+
+
+class FeatureStop(MIoTServiceEntity, MediaPlayerEntity):
+    """STOP feature of the media player entity."""
+    _action_stop: Optional[MIoTSpecAction]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._action_stop = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # actions
+        for act in entity_data.actions:
+            if act.name == 'stop':
+                self._attr_supported_features |= (MediaPlayerEntityFeature.STOP)
+                self._action_stop = act
+
+    async def async_media_stop(self) -> None:
+        """Send stop command."""
+        await self.action_async(action=self._action_stop)
+
+
+class FeatureNextTrack(MIoTServiceEntity, MediaPlayerEntity):
+    """NEXT_TRACK feature of the media player entity."""
+    _action_next: Optional[MIoTSpecAction]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._action_next = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # actions
+        for act in entity_data.actions:
+            if act.name == 'next':
+                self._attr_supported_features |= (
+                    MediaPlayerEntityFeature.NEXT_TRACK)
+                self._action_next = act
+
+    async def async_media_next_track(self) -> None:
+        """Send next track command."""
+        await self.action_async(action=self._action_next)
+
+
+class FeaturePreviousTrack(MIoTServiceEntity, MediaPlayerEntity):
+    """PREVIOUS_TRACK feature of the media player entity."""
+    _action_previous: Optional[MIoTSpecAction]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._action_previous = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # actions
+        for act in entity_data.actions:
+            if act.name == 'previous':
+                self._attr_supported_features |= (
+                    MediaPlayerEntityFeature.PREVIOUS_TRACK)
+                self._action_previous = act
+
+    async def async_media_previous_track(self) -> None:
+        """Send previous track command."""
+        await self.action_async(action=self._action_previous)
+
+
+class FeatureSoundMode(MIoTServiceEntity, MediaPlayerEntity):
+    """SELECT_SOUND_MODE feature of the media player entity."""
+    _prop_play_loop_mode: Optional[MIoTSpecProperty]
+    _sound_mode_map: Optional[dict[int, str]]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._prop_play_loop_mode = None
+        self._sound_mode_map = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # properties
+        for prop in entity_data.props:
+            if prop.name == 'play-loop-mode':
+                if not prop.value_list:
+                    _LOGGER.error('invalid play-loop-mode value_list, %s',
+                                  self.entity_id)
+                    continue
+                self._sound_mode_map = prop.value_list.to_map()
+                self._attr_sound_mode_list = list(self._sound_mode_map.values())
+                self._attr_supported_features |= (
+                    MediaPlayerEntityFeature.SELECT_SOUND_MODE)
+                self._prop_play_loop_mode = prop
+
+    async def async_select_sound_mode(self, sound_mode: str):
+        """Switch the sound mode of the entity."""
+        await self.set_property_async(prop=self._prop_play_loop_mode,
+                                      value=self.get_map_key(
+                                          map_=self._sound_mode_map,
+                                          value=sound_mode))
+
+    @property
+    def sound_mode(self) -> Optional[str]:
+        """The current sound mode."""
+        return (self.get_map_value(map_=self._sound_mode_map,
+                                   key=self.get_prop_value(
+                                       prop=self._prop_play_loop_mode))
+                if self._prop_play_loop_mode else None)
+
+
+class FeatureTurnOn(MIoTServiceEntity, MediaPlayerEntity):
+    """TURN_ON feature of the media player entity."""
+    _action_turn_on: Optional[MIoTSpecAction]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._action_turn_on = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # actions
+        for act in entity_data.actions:
+            if act.name == 'turn-on':
+                self._attr_supported_features |= (
+                    MediaPlayerEntityFeature.TURN_ON)
+                self._action_turn_on = act
+
+    async def async_turn_on(self) -> None:
+        """Turn the media player on."""
+        await self.action_async(action=self._action_turn_on)
+
+
+class FeatureTurnOff(MIoTServiceEntity, MediaPlayerEntity):
+    """TURN_OFF feature of the media player entity."""
+    _action_turn_off: Optional[MIoTSpecAction]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._action_turn_off = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # actions
+        for act in entity_data.actions:
+            if act.name == 'turn-off':
+                self._attr_supported_features |= (
+                    MediaPlayerEntityFeature.TURN_OFF)
+                self._action_turn_off = act
+
+    async def async_turn_off(self) -> None:
+        """Turn the media player off."""
+        await self.action_async(action=self._action_turn_off)
+
+
+class FeatureSource(MIoTServiceEntity, MediaPlayerEntity):
+    """SELECT_SOURCE feature of the media player entity."""
+    _prop_input_control: Optional[MIoTSpecProperty]
+    _input_source_map: Optional[dict[int, str]]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._prop_input_control = None
+        self._input_source_map = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # properties
+        for prop in entity_data.props:
+            if prop.name == 'input-control':
+                if not prop.value_list:
+                    _LOGGER.error('invalid input-control value_list, %s',
+                                  self.entity_id)
+                    continue
+                self._input_source_map = prop.value_list.to_map()
+                self._attr_source_list = list(self._input_source_map.values())
+                self._attr_supported_features |= (
+                    MediaPlayerEntityFeature.SELECT_SOURCE)
+                self._prop_input_control = prop
+
+    async def async_select_source(self, source: str) -> None:
+        """Select input source."""
+        await self.set_property_async(prop=self._prop_input_control,
+                                      value=self.get_map_key(
+                                          map_=self._input_source_map,
+                                          value=source))
+
+    @property
+    def source(self) -> Optional[str]:
+        """The current input source."""
+        return (self.get_map_value(map_=self._input_source_map,
+                                   key=self.get_prop_value(
+                                       prop=self._prop_input_control))
+                if self._prop_input_control else None)
+
+
+class FeatureState(MIoTServiceEntity, MediaPlayerEntity):
+    """States feature of the media player entity."""
+    _prop_playing_state: Optional[MIoTSpecProperty]
+    _playing_state_map: Optional[dict[int, str]]
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the feature class."""
+        self._prop_playing_state = None
+        self._playing_state_map = None
+
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+        # properties
+        for prop in entity_data.props:
+            if prop.name == 'playing-state':
+                if not prop.value_list:
+                    _LOGGER.error('invalid mode value_list, %s', self.entity_id)
+                    continue
+                self._playing_state_map = {}
+                for item in prop.value_list.items:
+                    if item.name in {'off'}:
+                        self._playing_state_map[
+                            item.value] = MediaPlayerState.OFF
+                    elif item.name in {'idle', 'stop', 'stopped'}:
+                        self._playing_state_map[
+                            item.value] = MediaPlayerState.IDLE
+                    elif item.name in {'playing'}:
+                        self._playing_state_map[
+                            item.value] = MediaPlayerState.PLAYING
+                    elif item.name in {'pause', 'paused'}:
+                        self._playing_state_map[
+                            item.value] = MediaPlayerState.PAUSED
+                    self._prop_playing_state = prop
+
+    @property
+    def state(self) -> Optional[MediaPlayerState]:
+        """The current state."""
+        return (self.get_map_value(map_=self._playing_state_map,
+                                   key=self.get_prop_value(
+                                       prop=self._prop_playing_state))
+                if self._prop_playing_state else MediaPlayerState.ON)
+
+
+class WifiSpeaker(FeatureVolumeSet, FeatureVolumeMute, FeaturePlay,
+                  FeaturePause, FeatureStop, FeatureNextTrack,
+                  FeaturePreviousTrack, FeatureSoundMode, FeatureState):
+    """WiFi speaker, aka XiaoAI sound speaker."""
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the device."""
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+
+        self._attr_device_class = MediaPlayerDeviceClass.SPEAKER
+        self._attr_media_content_type = MediaType.MUSIC
+
+
+class Television(FeatureVolumeSet, FeatureVolumeMute, FeaturePlay, FeaturePause,
+                 FeatureStop, FeatureNextTrack, FeaturePreviousTrack,
+                 FeatureSoundMode, FeatureState, FeatureSource, FeatureTurnOn,
+                 FeatureTurnOff):
+    """Television"""
+
+    def __init__(self, miot_device: MIoTDevice,
+                 entity_data: MIoTEntityData) -> None:
+        """Initialize the device."""
+        super().__init__(miot_device=miot_device, entity_data=entity_data)
+
+        self._attr_device_class = MediaPlayerDeviceClass.TV
+        self._attr_media_content_type = MediaType.VIDEO

custom_components/xiaomi_home/miot/const.py

@@ -71,10 +71,12 @@ SUPPORTED_PLATFORMS: list = [
     'button',
     'climate',
     'cover',
+    'device_tracker',
     'event',
     'fan',
     'humidifier',
     'light',
+    'media_player',
     'notify',
     'number',
     'select',

custom_components/xiaomi_home/miot/miot_client.py

@@ -636,79 +636,79 @@ class MIoTClient:
                           traceback.format_exc())
         return False
 
-    async def set_prop_async(self, did: str, siid: int, piid: int,
-                             value: Any) -> bool:
-        if did not in self._device_list_cache:
-            raise MIoTClientError(f"did not exist, {did}")
-        # Priority local control
-        if self._ctrl_mode == CtrlMode.AUTO:
-            # Gateway control
-            device_gw = self._device_list_gateway.get(did, None)
-            if (device_gw and device_gw.get("online", False) and
-                    device_gw.get("specv2_access", False) and
-                    "group_id" in device_gw):
-                mips = self._mips_local.get(device_gw["group_id"], None)
-                if mips is None:
-                    _LOGGER.error(
-                        'no gateway route, %s, try control through cloud',
-                        device_gw)
-                else:
-                    result = await mips.set_prop_async(did=did,
-                                                       siid=siid,
-                                                       piid=piid,
-                                                       value=value)
-                    _LOGGER.debug('gateway set prop, %s.%d.%d, %s -> %s', did,
-                                  siid, piid, value, result)
-                    rc = (result or
-                          {}).get('code',
-                                  MIoTErrorCode.CODE_MIPS_INVALID_RESULT.value)
-                    if rc in [0, 1]:
-                        return True
-                    raise MIoTClientError(self.__get_exec_error_with_rc(rc=rc))
-            # Lan control
-            device_lan = self._device_list_lan.get(did, None)
-            if device_lan and device_lan.get("online", False):
-                result = await self._miot_lan.set_prop_async(did=did,
-                                                             siid=siid,
-                                                             piid=piid,
-                                                             value=value)
-                _LOGGER.debug("lan set prop, %s.%d.%d, %s -> %s", did, siid,
-                              piid, value, result)
-                rc = (result or
-                      {}).get("code",
-                              MIoTErrorCode.CODE_MIPS_INVALID_RESULT.value)
-                if rc in [0, 1]:
-                    return True
-                raise MIoTClientError(self.__get_exec_error_with_rc(rc=rc))
+    # async def set_prop_async(self, did: str, siid: int, piid: int,
+    #                          value: Any) -> bool:
+    #     if did not in self._device_list_cache:
+    #         raise MIoTClientError(f"did not exist, {did}")
+    #     # Priority local control
+    #     if self._ctrl_mode == CtrlMode.AUTO:
+    #         # Gateway control
+    #         device_gw = self._device_list_gateway.get(did, None)
+    #         if (device_gw and device_gw.get("online", False) and
+    #                 device_gw.get("specv2_access", False) and
+    #                 "group_id" in device_gw):
+    #             mips = self._mips_local.get(device_gw["group_id"], None)
+    #             if mips is None:
+    #                 _LOGGER.error(
+    #                     'no gateway route, %s, try control through cloud',
+    #                     device_gw)
+    #             else:
+    #                 result = await mips.set_prop_async(did=did,
+    #                                                    siid=siid,
+    #                                                    piid=piid,
+    #                                                    value=value)
+    #                 _LOGGER.debug('gateway set prop, %s.%d.%d, %s -> %s', did,
+    #                               siid, piid, value, result)
+    #                 rc = (result or
+    #                       {}).get('code',
+    #                               MIoTErrorCode.CODE_MIPS_INVALID_RESULT.value)
+    #                 if rc in [0, 1]:
+    #                     return True
+    #                 raise MIoTClientError(self.__get_exec_error_with_rc(rc=rc))
+    #         # Lan control
+    #         device_lan = self._device_list_lan.get(did, None)
+    #         if device_lan and device_lan.get("online", False):
+    #             result = await self._miot_lan.set_prop_async(did=did,
+    #                                                          siid=siid,
+    #                                                          piid=piid,
+    #                                                          value=value)
+    #             _LOGGER.debug("lan set prop, %s.%d.%d, %s -> %s", did, siid,
+    #                           piid, value, result)
+    #             rc = (result or
+    #                   {}).get("code",
+    #                           MIoTErrorCode.CODE_MIPS_INVALID_RESULT.value)
+    #             if rc in [0, 1]:
+    #                 return True
+    #             raise MIoTClientError(self.__get_exec_error_with_rc(rc=rc))
 
-        # Cloud control
-        device_cloud = self._device_list_cloud.get(did, None)
-        if device_cloud and device_cloud.get("online", False):
-            result = await self._http.set_prop_async(params=[{
-                "did": did,
-                "siid": siid,
-                "piid": piid,
-                "value": value
-            }])
-            _LOGGER.debug('cloud set prop, %s.%d.%d, %s -> %s', did, siid, piid,
-                          value, result)
-            if result and len(result) == 1:
-                rc = result[0].get("code",
-                                   MIoTErrorCode.CODE_MIPS_INVALID_RESULT.value)
-                if rc in [0, 1]:
-                    return True
-                if rc in [-704010000, -704042011]:
-                    # Device remove or offline
-                    _LOGGER.error("device may be removed or offline, %s", did)
-                    self._main_loop.create_task(
-                        await
-                        self.__refresh_cloud_device_with_dids_async(dids=[did]))
-                raise MIoTClientError(self.__get_exec_error_with_rc(rc=rc))
+    #     # Cloud control
+    #     device_cloud = self._device_list_cloud.get(did, None)
+    #     if device_cloud and device_cloud.get("online", False):
+    #         result = await self._http.set_prop_async(params=[{
+    #             "did": did,
+    #             "siid": siid,
+    #             "piid": piid,
+    #             "value": value
+    #         }])
+    #         _LOGGER.debug('cloud set prop, %s.%d.%d, %s -> %s', did, siid, piid,
+    #                       value, result)
+    #         if result and len(result) == 1:
+    #             rc = result[0].get("code",
+    #                                MIoTErrorCode.CODE_MIPS_INVALID_RESULT.value)
+    #             if rc in [0, 1]:
+    #                 return True
+    #             if rc in [-704010000, -704042011]:
+    #                 # Device remove or offline
+    #                 _LOGGER.error("device may be removed or offline, %s", did)
+    #                 self._main_loop.create_task(
+    #                     await
+    #                     self.__refresh_cloud_device_with_dids_async(dids=[did]))
+    #             raise MIoTClientError(self.__get_exec_error_with_rc(rc=rc))
 
-        # Show error message
-        raise MIoTClientError(
-            f"{self._i18n.translate('miot.client.device_exec_error')}, "
-            f"{self._i18n.translate('error.common.-10007')}")
+    #     # Show error message
+    #     raise MIoTClientError(
+    #         f"{self._i18n.translate('miot.client.device_exec_error')}, "
+    #         f"{self._i18n.translate('error.common.-10007')}")
 
     async def set_props_async(
         self,

custom_components/xiaomi_home/miot/miot_device.py

@@ -1027,32 +1027,35 @@ class MIoTServiceEntity(Entity):
         update_value: bool = True,
         write_ha_state: bool = True,
     ) -> bool:
-        if not prop:
-            raise RuntimeError(
-                f"set property failed, property is None, {self.entity_id}, {self.name}"
-            )
-        value = prop.value_format(value)
-        if prop not in self.entity_data.props:
-            raise RuntimeError(f"set property failed, unknown property, "
-                               f"{self.entity_id}, {self.name}, {prop.name}")
-        if not prop.writable:
-            raise RuntimeError(f"set property failed, not writable, "
-                               f"{self.entity_id}, {self.name}, {prop.name}")
-        try:
-            await self.miot_device.miot_client.set_prop_async(
-                did=self.miot_device.did,
-                siid=prop.service.iid,
-                piid=prop.iid,
-                value=value,
-            )
-        except MIoTClientError as e:
-            raise RuntimeError(
-                f"{e}, {self.entity_id}, {self.name}, {prop.name}") from e
-        if update_value:
-            self._prop_value_map[prop] = value
-        if write_ha_state:
-            self.async_write_ha_state()
-        return True
+        set_properties_list = [{"prop": prop, "value": value}]
+        return await self.set_properties_async(set_properties_list,
+                                               update_value, write_ha_state)
+        # if not prop:
+        #     raise RuntimeError(
+        #         f"set property failed, property is None, {self.entity_id}, {self.name}"
+        #     )
+        # value = prop.value_format(value)
+        # if prop not in self.entity_data.props:
+        #     raise RuntimeError(f"set property failed, unknown property, "
+        #                        f"{self.entity_id}, {self.name}, {prop.name}")
+        # if not prop.writable:
+        #     raise RuntimeError(f"set property failed, not writable, "
+        #                        f"{self.entity_id}, {self.name}, {prop.name}")
+        # try:
+        #     await self.miot_device.miot_client.set_prop_async(
+        #         did=self.miot_device.did,
+        #         siid=prop.service.iid,
+        #         piid=prop.iid,
+        #         value=value,
+        #     )
+        # except MIoTClientError as e:
+        #     raise RuntimeError(
+        #         f"{e}, {self.entity_id}, {self.name}, {prop.name}") from e
+        # if update_value:
+        #     self._prop_value_map[prop] = value
+        # if write_ha_state:
+        #     self.async_write_ha_state()
+        # return True
 
     async def set_properties_async(
         self,
@@ -1301,12 +1304,19 @@ class MIoTPropertyEntity(Entity):
             )
         value = self.spec.value_format(value)
         try:
-            await self.miot_device.miot_client.set_prop_async(
-                did=self.miot_device.did,
-                siid=self.spec.service.iid,
-                piid=self.spec.iid,
-                value=value,
-            )
+            await self.miot_device.miot_client.set_props_async([{
+                "did": self.miot_device.did,
+                "siid": self.spec.service.iid,
+                "piid": self.spec.iid,
+                "value": value,
+            }])
+            # await self.miot_device.miot_client.set_prop_async(
+            #     did=self.miot_device.did,
+            #     siid=self.spec.service.iid,
+            #     piid=self.spec.iid,
+            #     value=value,
+            # )
+
         except MIoTClientError as e:
             raise RuntimeError(f"{e}, {self.entity_id}, {self.name}") from e
         self._value = value

custom_components/xiaomi_home/miot/specs/specv2entity.py

@@ -50,18 +50,11 @@ from homeassistant.components.sensor import SensorStateClass
 from homeassistant.components.event import EventDeviceClass
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 
-from homeassistant.const import (
-    CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-    EntityCategory,
-    LIGHT_LUX,
-    UnitOfEnergy,
-    UnitOfPower,
-    UnitOfElectricCurrent,
-    UnitOfElectricPotential,
-    UnitOfTemperature,
-    UnitOfPressure,
-    PERCENTAGE
-)
+from homeassistant.const import (CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+                                 EntityCategory, LIGHT_LUX, UnitOfEnergy,
+                                 UnitOfPower, UnitOfElectricCurrent,
+                                 UnitOfElectricPotential, UnitOfTemperature,
+                                 UnitOfPressure, PERCENTAGE)
 
 # pylint: disable=pointless-string-statement
 """SPEC_DEVICE_TRANS_MAP
@@ -107,7 +100,7 @@ SPEC_DEVICE_TRANS_MAP: dict = {
     'humidifier': {
         'required': {
             'humidifier': {
-                'required':  {
+                'required': {
                     'properties': {
                         'on': {'read', 'write'}
                     }
@@ -119,7 +112,7 @@ SPEC_DEVICE_TRANS_MAP: dict = {
         },
         'optional': {
             'environment': {
-                'required':  {
+                'required': {
                     'properties': {
                         'relative-humidity': {'read'}
                     }
@@ -131,7 +124,7 @@ SPEC_DEVICE_TRANS_MAP: dict = {
     'dehumidifier': {
         'required': {
             'dehumidifier': {
-                'required':  {
+                'required': {
                     'properties': {
                         'on': {'read', 'write'}
                     }
@@ -143,7 +136,7 @@ SPEC_DEVICE_TRANS_MAP: dict = {
         },
         'optional': {
             'environment': {
-                'required':  {
+                'required': {
                     'properties': {
                         'relative-humidity': {'read'}
                     }
@@ -155,15 +148,13 @@ SPEC_DEVICE_TRANS_MAP: dict = {
     'vacuum': {
         'required': {
             'vacuum': {
-                'required':  {
+                'required': {
                     'actions': {'start-sweep', 'stop-sweeping'},
                 },
                 'optional': {
                     'properties': {'status', 'fan-level'},
                     'actions': {
-                        'pause-sweeping',
-                        'continue-sweep',
-                        'stop-and-gocharge'
+                        'pause-sweeping', 'continue-sweep', 'stop-and-gocharge'
                     }
                 }
             }
@@ -171,7 +162,7 @@ SPEC_DEVICE_TRANS_MAP: dict = {
         'optional': {
             'identify': {
                 'required': {
-                    'actions':  {'identify'}
+                    'actions': {'identify'}
                 }
             },
             'battery': {
@@ -204,10 +195,9 @@ SPEC_DEVICE_TRANS_MAP: dict = {
                 'required': {},
                 'optional': {
                     'properties': {
-                        'on',
-                        'fan-level',
-                        'horizontal-swing',
-                        'vertical-swing'}}
+                        'on', 'fan-level', 'horizontal-swing', 'vertical-swing'
+                    }
+                }
             },
             'environment': {
                 'required': {},
@@ -235,8 +225,8 @@ SPEC_DEVICE_TRANS_MAP: dict = {
                 },
                 'optional': {
                     'properties': {
-                        'target-temperature', 'mode', 'fan-level',
-                        'temperature'}
+                        'target-temperature', 'mode', 'fan-level', 'temperature'
+                    }
                 }
             }
         },
@@ -278,7 +268,7 @@ SPEC_DEVICE_TRANS_MAP: dict = {
             'ptc-bath-heater': {
                 'required': {
                     'properties': {
-                        'mode':{'read', 'write'}
+                        'mode': {'read', 'write'}
                     }
                 },
                 'optional': {
@@ -321,6 +311,89 @@ SPEC_DEVICE_TRANS_MAP: dict = {
         'optional': {},
         'entity': 'electric-blanket'
     },
+    'speaker': {
+        'required': {
+            'speaker': {
+                'required': {
+                    'properties': {
+                        'volume': {'read', 'write'}
+                    }
+                },
+                'optional': {
+                    'properties': {'mute'}
+                }
+            },
+            'play-control': {
+                'required': {
+                    'actions': {'play'}
+                },
+                'optional': {
+                    'properties': {'playing-state'},
+                    'actions': {'pause', 'stop', 'next', 'previous'}
+                }
+            }
+        },
+        'optional': {},
+        'entity': 'wifi-speaker'
+    },
+    'television': {
+        'required': {
+            'speaker': {
+                'required': {
+                    'properties': {
+                        'volume': {'read', 'write'}
+                    }
+                },
+                'optional': {
+                    'properties': {'mute'}
+                }
+            },
+            'television': {
+                'required': {
+                    'actions': {'turn-off'}
+                },
+                'optional': {
+                    'properties': {'input-control'},
+                    'actions': {'turn-on'}
+                }
+            }
+        },
+        'optional': {
+            'play-control': {
+                'required': {},
+                'optional': {
+                    'properties': {'playing-state'},
+                    'actions': {'play', 'pause', 'stop', 'next', 'previous'}
+                }
+            }
+        },
+        'entity': 'television'
+    },
+    'watch': {
+        'required': {
+            'watch': {
+                'required': {
+                    'properties': {
+                        'longitude': {'read'},
+                        'latitude': {'read'}
+                    }
+                },
+                'optional': {
+                    'properties': {'area-id'}
+                }
+            }
+        },
+        'optional': {
+            'battery': {
+                'required': {
+                    'properties': {
+                        'battery-level': {'read'}
+                    }
+                }
+            }
+        },
+        'entity': 'device_tracker'
+    }
 }
 
 """SPEC_SERVICE_TRANS_MAP
@@ -351,9 +424,7 @@ SPEC_SERVICE_TRANS_MAP: dict = {
             }
         },
         'optional': {
-            'properties': {
-                'mode', 'brightness', 'color', 'color-temperature'
-            }
+            'properties': {'mode', 'brightness', 'color', 'color-temperature'}
         },
         'entity': 'light'
     },
@@ -368,7 +439,8 @@ SPEC_SERVICE_TRANS_MAP: dict = {
         },
         'optional': {
             'properties': {
-                'mode', 'brightness',
+                'mode',
+                'brightness',
             }
         },
         'entity': 'light',
@@ -401,16 +473,14 @@ SPEC_SERVICE_TRANS_MAP: dict = {
         },
         'entity': 'water_heater'
     },
-    'curtain':  {
+    'curtain': {
         'required': {
             'properties': {
                 'motor-control': {'write'}
             }
         },
         'optional': {
-            'properties': {
-                'status', 'current-position', 'target-position'
-            }
+            'properties': {'status', 'current-position', 'target-position'}
         },
         'entity': 'cover'
     },
@@ -600,6 +670,4 @@ SPEC_EVENT_TRANS_MAP: dict[str, str] = {
     'doorbell-ring': EventDeviceClass.DOORBELL
 }
 
-SPEC_ACTION_TRANS_MAP = {
-
-}
+SPEC_ACTION_TRANS_MAP = {}

custom_components/xiaomi_home/select.py

@@ -125,7 +125,9 @@ class LightCommandSendMode(SelectEntity, RestoreEntity):
         self.hass = hass
         self._device_id = device_id
         self._attr_name = "Command Send Mode"
-        self._attr_unique_id = f"{DOMAIN}.light_{device_id}_command_send_mode"
+        self.entity_id = f"select.light_{device_id}_command_send_mode"
+        self._attr_unique_id = self.entity_id
+
         self._attr_options = [
             "Send One by One", "Send Turn On First", "Send Together"
         ]