Add SmartThings Cover platform and add cover device classes (#21192)

* Add additional device classes to Cover component; Add SmartThings cover platform; Improve lock test coverage

* Enhance cover platform to support position and battery level reporting.

* Add additional classes

* Removed device class descriptions

* Updates based on review feedback

* Add test case for closed
This commit is contained in:
Andrew Sayre authored and Paulus Schoutsen committed 2019-02-25 10:13:34 -08:00
1 parent 0ccbf61aea
commit d3f1ee4a89
5 files changed
+371 -12

No files matched your search

@@ -25,12 +25,13 @@ SETTINGS_INSTANCE_ID = "hassInstanceId"
STORAGE_KEY = DOMAIN
STORAGE_VERSION = 1
# Ordered 'specific to least-specific platform' in order for capabilities
# to be drawn-down and represented by the appropriate platform.
# to be drawn-down and represented by the most appropriate platform.
SUPPORTED_PLATFORMS = [
'climate',
'fan',
'light',
'lock',
'cover',
'switch',
'binary_sensor',
'sensor'
@@ -0,0 +1,153 @@
"""Support for covers through the SmartThings cloud API."""
from typing import Optional, Sequence
from homeassistant.components.cover import (
ATTR_POSITION, DEVICE_CLASS_DOOR, DEVICE_CLASS_GARAGE, DEVICE_CLASS_SHADE,
DOMAIN as COVER_DOMAIN, STATE_CLOSED, STATE_CLOSING, STATE_OPEN,
STATE_OPENING, SUPPORT_CLOSE, SUPPORT_OPEN, SUPPORT_SET_POSITION,
CoverDevice)
from homeassistant.const import ATTR_BATTERY_LEVEL
from . import SmartThingsEntity
from .const import DATA_BROKERS, DOMAIN
DEPENDENCIES = ['smartthings']
VALUE_TO_STATE = {
'closed': STATE_CLOSED,
'closing': STATE_CLOSING,
'open': STATE_OPEN,
'opening': STATE_OPENING,
'partially open': STATE_OPEN,
'unknown': None
}
async def async_setup_platform(
hass, config, async_add_entities, discovery_info=None):
"""Platform uses config entry setup."""
pass
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Add covers for a config entry."""
broker = hass.data[DOMAIN][DATA_BROKERS][config_entry.entry_id]
async_add_entities(
[SmartThingsCover(device) for device in broker.devices.values()
if broker.any_assigned(device.device_id, COVER_DOMAIN)], True)
def get_capabilities(capabilities: Sequence[str]) -> Optional[Sequence[str]]:
"""Return all capabilities supported if minimum required are present."""
from pysmartthings import Capability
min_required = [
Capability.door_control,
Capability.garage_door_control,
Capability.window_shade
]
# Must have one of the min_required
if any(capability in capabilities
for capability in min_required):
# Return all capabilities supported/consumed
return min_required + [Capability.battery, Capability.switch_level]
return None
class SmartThingsCover(SmartThingsEntity, CoverDevice):
"""Define a SmartThings cover."""
def __init__(self, device):
"""Initialize the cover class."""
from pysmartthings import Capability
super().__init__(device)
self._device_class = None
self._state = None
self._state_attrs = None
self._supported_features = SUPPORT_OPEN | SUPPORT_CLOSE
if Capability.switch_level in device.capabilities:
self._supported_features |= SUPPORT_SET_POSITION
async def async_close_cover(self, **kwargs):
"""Close cover."""
# Same command for all 3 supported capabilities
await self._device.close(set_status=True)
# State is set optimistically in the commands above, therefore update
# the entity state ahead of receiving the confirming push updates
self.async_schedule_update_ha_state(True)
async def async_open_cover(self, **kwargs):
"""Open the cover."""
# Same for all capability types
await self._device.open(set_status=True)
# State is set optimistically in the commands above, therefore update
# the entity state ahead of receiving the confirming push updates
self.async_schedule_update_ha_state(True)
async def async_set_cover_position(self, **kwargs):
"""Move the cover to a specific position."""
if not self._supported_features & SUPPORT_SET_POSITION:
return
# Do not set_status=True as device will report progress.
await self._device.set_level(kwargs[ATTR_POSITION], 0)
async def async_update(self):
"""Update the attrs of the cover."""
from pysmartthings import Attribute, Capability
value = None
if Capability.door_control in self._device.capabilities:
self._device_class = DEVICE_CLASS_DOOR
value = self._device.status.door
elif Capability.window_shade in self._device.capabilities:
self._device_class = DEVICE_CLASS_SHADE
value = self._device.status.window_shade
elif Capability.garage_door_control in self._device.capabilities:
self._device_class = DEVICE_CLASS_GARAGE
value = self._device.status.door
self._state = VALUE_TO_STATE.get(value)
self._state_attrs = {}
battery = self._device.status.attributes[Attribute.battery].value
if battery is not None:
self._state_attrs[ATTR_BATTERY_LEVEL] = battery
@property
def is_opening(self):
"""Return if the cover is opening or not."""
return self._state == STATE_OPENING
@property
def is_closing(self):
"""Return if the cover is closing or not."""
return self._state == STATE_CLOSING
@property
def is_closed(self):
"""Return if the cover is closed or not."""
if self._state == STATE_CLOSED:
return True
return None if self._state is None else False
@property
def current_cover_position(self):
"""Return current position of cover."""
return self._device.status.level
@property
def device_class(self):
"""Define this cover as a garage door."""
return self._device_class
@property
def device_state_attributes(self):
"""Get additional state attributes."""
return self._state_attrs
@property
def supported_features(self):
"""Flag supported features."""
return self._supported_features
@@ -43,8 +43,6 @@ CAPABILITY_TO_SENSORS = {
Map('dishwasherJobState', "Dishwasher Job State", None, None),
Map('completionTime', "Dishwasher Completion Time", None,
DEVICE_CLASS_TIMESTAMP)],
'doorControl': [
Map('door', "Door", None, None)],
'dryerMode': [
Map('dryerMode', "Dryer Mode", None, None)],
'dryerOperatingState': [
@@ -62,8 +60,6 @@ CAPABILITY_TO_SENSORS = {
'Equivalent Carbon Dioxide Measurement', 'ppm', None)],
'formaldehydeMeasurement': [
Map('formaldehydeLevel', 'Formaldehyde Measurement', 'ppm', None)],
'garageDoorControl': [
Map('door', 'Garage Door', None, None)],
'illuminanceMeasurement': [
Map('illuminance', "Illuminance", 'lux', DEVICE_CLASS_ILLUMINANCE)],
'infraredLevel': [
@@ -143,9 +139,7 @@ CAPABILITY_TO_SENSORS = {
Map('machineState', "Washer Machine State", None, None),
Map('washerJobState', "Washer Job State", None, None),
Map('completionTime', "Washer Completion Time", None,
DEVICE_CLASS_TIMESTAMP)],
'windowShade': [
Map('windowShade', 'Window Shade', None, None)]
DEVICE_CLASS_TIMESTAMP)]
}
UNITS = {