root
221 lines
8.4 KiB
Python
221 lines
8.4 KiB
Python
import logging
|
|
from enum import Enum
|
|
from typing import Any, Dict, Union
|
|
|
|
from homeassistant.core import HomeAssistant
|
|
from meross_iot.controller.device import BaseDevice
|
|
from meross_iot.model.enums import RollerShutterState, Namespace
|
|
from meross_iot.controller.mixins.garage import GarageOpenerMixin
|
|
from meross_iot.controller.mixins.roller_shutter import RollerShutterTimerMixin
|
|
from meross_iot.manager import MerossManager
|
|
from meross_iot.model.http.device import HttpDeviceInfo
|
|
|
|
# Conditional Light import with backwards compatibility
|
|
from homeassistant.components.cover import (
|
|
CoverEntity,
|
|
CoverEntityFeature,
|
|
CoverDeviceClass,
|
|
ATTR_POSITION,
|
|
)
|
|
|
|
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
|
|
from . import MerossDevice
|
|
from .common import (DOMAIN, MANAGER, HA_COVER, DEVICE_LIST_COORDINATOR)
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
|
|
class MerossGarageDevice(GarageOpenerMixin, BaseDevice):
|
|
"""
|
|
Type hints helper
|
|
"""
|
|
pass
|
|
|
|
|
|
class CoverTransientStatus(Enum):
|
|
CLOSING = 1,
|
|
OPENING = 2
|
|
|
|
|
|
class GarageOpenerEntityWrapper(MerossDevice, CoverEntity):
|
|
"""Wrapper class to adapt the Meross Garage Opener into the Homeassistant platform"""
|
|
|
|
_device: MerossGarageDevice
|
|
_cover_transient_status: CoverTransientStatus | None = None
|
|
|
|
def __init__(self,
|
|
channel: int,
|
|
device: Union[MerossGarageDevice, GarageOpenerMixin],
|
|
device_list_coordinator: DataUpdateCoordinator[Dict[str, HttpDeviceInfo]]):
|
|
super().__init__(
|
|
device=device,
|
|
channel=channel,
|
|
device_list_coordinator=device_list_coordinator,
|
|
platform=HA_COVER)
|
|
|
|
async def async_close_cover(self, **kwargs):
|
|
await self._device.async_close(channel=self._channel_id, skip_rate_limits=True)
|
|
self._cover_transient_status = CoverTransientStatus.CLOSING
|
|
self.async_schedule_update_ha_state(force_refresh=False)
|
|
|
|
async def async_open_cover(self, **kwargs):
|
|
await self._device.async_open(channel=self._channel_id, skip_rate_limits=True)
|
|
self._cover_transient_status = CoverTransientStatus.OPENING
|
|
self.async_schedule_update_ha_state(force_refresh=False)
|
|
|
|
def open_cover(self, **kwargs: Any) -> None:
|
|
self.hass.async_add_executor_job(self.async_open_cover, **kwargs)
|
|
|
|
def close_cover(self, **kwargs: Any) -> None:
|
|
self.hass.async_add_executor_job(self.async_close_cover, **kwargs)
|
|
|
|
@property
|
|
def device_class(self):
|
|
"""Return the class of this device, from component DEVICE_CLASSES."""
|
|
return CoverDeviceClass.GARAGE
|
|
|
|
@property
|
|
def supported_features(self):
|
|
"""Flag supported features."""
|
|
return CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
|
|
|
|
@property
|
|
def is_closed(self):
|
|
open_status = self._device.get_is_open(channel=self._channel_id)
|
|
return not open_status
|
|
|
|
async def _async_push_notification_received(self, namespace: Namespace, data: dict, device_internal_id: str):
|
|
if namespace == Namespace.GARAGE_DOOR_STATE:
|
|
self._cover_transient_status = None
|
|
await super()._async_push_notification_received(namespace=namespace, data=data, device_internal_id=device_internal_id)
|
|
|
|
@property
|
|
def is_closing(self):
|
|
return self._cover_transient_status is not None and self._cover_transient_status == CoverTransientStatus.CLOSING
|
|
|
|
@property
|
|
def is_opening(self):
|
|
return self._cover_transient_status is not None and self._cover_transient_status == CoverTransientStatus.OPENING
|
|
|
|
|
|
class MerossRollerShutterDevice(RollerShutterTimerMixin, BaseDevice):
|
|
"""
|
|
Type hints helper
|
|
"""
|
|
pass
|
|
|
|
|
|
class RollerShutterEntityWrapper(MerossDevice, CoverEntity):
|
|
"""Wrapper class to adapt the Meross roller shutter into the Homeassistant platform"""
|
|
|
|
_device: MerossRollerShutterDevice
|
|
|
|
def __init__(self,
|
|
channel: int,
|
|
device: Union[MerossRollerShutterDevice, RollerShutterTimerMixin],
|
|
device_list_coordinator: DataUpdateCoordinator[Dict[str, HttpDeviceInfo]]):
|
|
super().__init__(
|
|
device=device,
|
|
channel=channel,
|
|
device_list_coordinator=device_list_coordinator,
|
|
platform=HA_COVER)
|
|
|
|
async def async_close_cover(self, **kwargs):
|
|
await self._device.async_close(channel=self._channel_id, skip_rate_limits=True)
|
|
|
|
async def async_open_cover(self, **kwargs):
|
|
await self._device.async_open(channel=self._channel_id, skip_rate_limits=True)
|
|
|
|
async def async_stop_cover(self, **kwargs):
|
|
await self._device.async_stop(channel=self._channel_id, skip_rate_limits=True)
|
|
|
|
def open_cover(self, **kwargs: Any) -> None:
|
|
self.hass.async_add_executor_job(self.async_open_cover, **kwargs)
|
|
|
|
def close_cover(self, **kwargs: Any) -> None:
|
|
self.hass.async_add_executor_job(self.async_close_cover, **kwargs)
|
|
|
|
def stop_cover(self, **kwargs) -> None:
|
|
self.hass.async_add_executor_job(self.async_stop_cover, **kwargs)
|
|
|
|
@property
|
|
def device_class(self):
|
|
"""Return the class of this device, from component DEVICE_CLASSES."""
|
|
return CoverDeviceClass.SHUTTER
|
|
|
|
@property
|
|
def supported_features(self):
|
|
"""Flag supported features."""
|
|
# So far, the Roller Shutter RST100 supports position, but it looks like it is fake and not reliable.
|
|
# So we don't support that on HA neither.
|
|
return CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE | CoverEntityFeature.STOP | CoverEntityFeature.SET_POSITION
|
|
|
|
@property
|
|
def current_cover_position(self):
|
|
return self._device.get_position(channel=self._channel_id)
|
|
|
|
@property
|
|
def is_closed(self):
|
|
return self._device.get_position(channel=self._channel_id) == 0
|
|
|
|
@property
|
|
def is_closing(self):
|
|
status = self._device.get_status(channel=self._channel_id)
|
|
return status == RollerShutterState.CLOSING
|
|
|
|
@property
|
|
def is_opening(self):
|
|
status = self._device.get_status(channel=self._channel_id)
|
|
return status == RollerShutterState.OPENING
|
|
|
|
async def async_set_cover_position(self, position: int):
|
|
await self._device.async_set_position(position=position, channel=self._channel_id)
|
|
|
|
def set_cover_position(self, **kwargs):
|
|
position = round(kwargs.get(ATTR_POSITION) or 0)
|
|
self.hass.async_add_executor_job(self.async_set_cover_position, int(position))
|
|
|
|
|
|
async def async_setup_entry(hass: HomeAssistant, config_entry, async_add_entities):
|
|
def entity_adder_callback():
|
|
"""Discover and adds new Meross entities"""
|
|
manager: MerossManager = hass.data[DOMAIN][MANAGER]
|
|
coordinator = hass.data[DOMAIN][DEVICE_LIST_COORDINATOR]
|
|
devices = manager.find_devices(device_class=[GarageOpenerMixin, RollerShutterTimerMixin])
|
|
new_entities = []
|
|
for d in devices:
|
|
# For multi-channel garage doors opener (like MSG200), the main channel is not operable and
|
|
# does not provide meaningful states. For this reason, we will ignore the "main channel"
|
|
# of any cover device which has more than 1 channels. Of course, we will keep working with channel
|
|
# 0 when dealing with dingle-door openers.
|
|
if len(d.channels) > 1:
|
|
channels = [c.index for c in d.channels if c.index > 0]
|
|
else:
|
|
channels = [0]
|
|
for channel_index in channels:
|
|
if isinstance(d, GarageOpenerMixin):
|
|
w = GarageOpenerEntityWrapper(device=d, channel=channel_index, device_list_coordinator=coordinator)
|
|
elif isinstance(d, RollerShutterTimerMixin):
|
|
w = RollerShutterEntityWrapper(device=d, channel=channel_index, device_list_coordinator=coordinator)
|
|
else:
|
|
_LOGGER.warn("Invalid/Unsupported device class for cover platform.")
|
|
continue
|
|
if w.unique_id not in hass.data[DOMAIN]["ADDED_ENTITIES_IDS"]:
|
|
new_entities.append(w)
|
|
|
|
async_add_entities(new_entities, True)
|
|
|
|
coordinator = hass.data[DOMAIN][DEVICE_LIST_COORDINATOR]
|
|
coordinator.async_add_listener(entity_adder_callback)
|
|
# Run the entity adder a first time during setup
|
|
entity_adder_callback()
|
|
|
|
|
|
# TODO: Implement entry unload
|
|
# TODO: Unload entry
|
|
# TODO: Remove entry
|
|
|
|
|
|
def setup_platform(hass, config, async_add_entities, discovery_info=None):
|
|
pass
|