jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-25 22:27:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reconfigure MQTT light component if discovery info is changed (#18176)

Browse Source
This commit is contained in:
emontnemery 2018-12-02 16:16:36 +01:00 committed by Paulus Schoutsen
parent bb13829e13
commit afa99915e3
6 changed files with 426 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
homeassistant/components/light/mqtt/schema_basic.py
View File

@ -21,7 +21,7 @@ from homeassistant.const import (
from homeassistant.components.mqtt import ( from homeassistant.components.mqtt import (
CONF_AVAILABILITY_TOPIC, CONF_COMMAND_TOPIC, CONF_PAYLOAD_AVAILABLE, CONF_AVAILABILITY_TOPIC, CONF_COMMAND_TOPIC, CONF_PAYLOAD_AVAILABLE,
CONF_PAYLOAD_NOT_AVAILABLE, CONF_QOS, CONF_RETAIN, CONF_STATE_TOPIC, CONF_PAYLOAD_NOT_AVAILABLE, CONF_QOS, CONF_RETAIN, CONF_STATE_TOPIC,
MqttAvailability, MqttDiscoveryUpdate) MqttAvailability, MqttDiscoveryUpdate, subscription)
from homeassistant.helpers.restore_state import RestoreEntity from homeassistant.helpers.restore_state import RestoreEntity
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
import homeassistant.util.color as color_util import homeassistant.util.color as color_util
@ -114,11 +114,73 @@ async def async_setup_entity_basic(hass, config, async_add_entities,
config.setdefault( config.setdefault(
CONF_STATE_VALUE_TEMPLATE, config.get(CONF_VALUE_TEMPLATE)) CONF_STATE_VALUE_TEMPLATE, config.get(CONF_VALUE_TEMPLATE))
async_add_entities([MqttLight( async_add_entities([MqttLight(config, discovery_hash)])
config.get(CONF_NAME),
config.get(CONF_UNIQUE_ID),
config.get(CONF_EFFECT_LIST), class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
{ """Representation of a MQTT light."""
def __init__(self, config, discovery_hash):
"""Initialize MQTT light."""
self._state = False
self._sub_state = None
self._brightness = None
self._hs = None
self._color_temp = None
self._effect = None
self._white_value = None
self._supported_features = 0
self._name = None
self._effect_list = None
self._topic = None
self._qos = None
self._retain = None
self._payload = None
self._templates = None
self._optimistic = False
self._optimistic_rgb = False
self._optimistic_brightness = False
self._optimistic_color_temp = False
self._optimistic_effect = False
self._optimistic_hs = False
self._optimistic_white_value = False
self._optimistic_xy = False
self._brightness_scale = None
self._white_value_scale = None
self._on_command_type = None
self._unique_id = config.get(CONF_UNIQUE_ID)
# Load config
self._setup_from_config(config)
availability_topic = config.get(CONF_AVAILABILITY_TOPIC)
payload_available = config.get(CONF_PAYLOAD_AVAILABLE)
payload_not_available = config.get(CONF_PAYLOAD_NOT_AVAILABLE)
MqttAvailability.__init__(self, availability_topic, self._qos,
payload_available, payload_not_available)
MqttDiscoveryUpdate.__init__(self, discovery_hash,
self.discovery_update)
async def async_added_to_hass(self):
"""Subscribe to MQTT events."""
await super().async_added_to_hass()
await self._subscribe_topics()
async def discovery_update(self, discovery_payload):
"""Handle updated discovery message."""
config = PLATFORM_SCHEMA_BASIC(discovery_payload)
self._setup_from_config(config)
await self.availability_discovery_update(config)
await self._subscribe_topics()
self.async_schedule_update_ha_state()
def _setup_from_config(self, config):
"""(Re)Setup the entity."""
self._name = config.get(CONF_NAME)
self._effect_list = config.get(CONF_EFFECT_LIST)
topic = {
key: config.get(key) for key in ( key: config.get(key) for key in (
CONF_BRIGHTNESS_COMMAND_TOPIC, CONF_BRIGHTNESS_COMMAND_TOPIC,
CONF_BRIGHTNESS_STATE_TOPIC, CONF_BRIGHTNESS_STATE_TOPIC,
@ -137,8 +199,15 @@ async def async_setup_entity_basic(hass, config, async_add_entities,
CONF_XY_COMMAND_TOPIC, CONF_XY_COMMAND_TOPIC,
CONF_XY_STATE_TOPIC, CONF_XY_STATE_TOPIC,
) )
}, }
{ self._topic = topic
self._qos = config.get(CONF_QOS)
self._retain = config.get(CONF_RETAIN)
self._payload = {
'on': config.get(CONF_PAYLOAD_ON),
'off': config.get(CONF_PAYLOAD_OFF),
}
self._templates = {
CONF_BRIGHTNESS: config.get(CONF_BRIGHTNESS_VALUE_TEMPLATE), CONF_BRIGHTNESS: config.get(CONF_BRIGHTNESS_VALUE_TEMPLATE),
CONF_COLOR_TEMP: config.get(CONF_COLOR_TEMP_VALUE_TEMPLATE), CONF_COLOR_TEMP: config.get(CONF_COLOR_TEMP_VALUE_TEMPLATE),
CONF_EFFECT: config.get(CONF_EFFECT_VALUE_TEMPLATE), CONF_EFFECT: config.get(CONF_EFFECT_VALUE_TEMPLATE),
@ -148,43 +217,9 @@ async def async_setup_entity_basic(hass, config, async_add_entities,
CONF_STATE: config.get(CONF_STATE_VALUE_TEMPLATE), CONF_STATE: config.get(CONF_STATE_VALUE_TEMPLATE),
CONF_WHITE_VALUE: config.get(CONF_WHITE_VALUE_TEMPLATE), CONF_WHITE_VALUE: config.get(CONF_WHITE_VALUE_TEMPLATE),
CONF_XY: config.get(CONF_XY_VALUE_TEMPLATE), CONF_XY: config.get(CONF_XY_VALUE_TEMPLATE),
}, }
config.get(CONF_QOS),
config.get(CONF_RETAIN),
{
'on': config.get(CONF_PAYLOAD_ON),
'off': config.get(CONF_PAYLOAD_OFF),
},
config.get(CONF_OPTIMISTIC),
config.get(CONF_BRIGHTNESS_SCALE),
config.get(CONF_WHITE_VALUE_SCALE),
config.get(CONF_ON_COMMAND_TYPE),
config.get(CONF_AVAILABILITY_TOPIC),
config.get(CONF_PAYLOAD_AVAILABLE),
config.get(CONF_PAYLOAD_NOT_AVAILABLE),
discovery_hash,
)])
optimistic = config.get(CONF_OPTIMISTIC)
class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
"""Representation of a MQTT light."""
def __init__(self, name, unique_id, effect_list, topic, templates,
qos, retain, payload, optimistic, brightness_scale,
white_value_scale, on_command_type, availability_topic,
payload_available, payload_not_available, discovery_hash):
"""Initialize MQTT light."""
MqttAvailability.__init__(self, availability_topic, qos,
payload_available, payload_not_available)
MqttDiscoveryUpdate.__init__(self, discovery_hash)
self._name = name
self._unique_id = unique_id
self._effect_list = effect_list
self._topic = topic
self._qos = qos
self._retain = retain
self._payload = payload
self._templates = templates
self._optimistic = optimistic or topic[CONF_STATE_TOPIC] is None self._optimistic = optimistic or topic[CONF_STATE_TOPIC] is None
self._optimistic_rgb = \ self._optimistic_rgb = \
optimistic or topic[CONF_RGB_STATE_TOPIC] is None optimistic or topic[CONF_RGB_STATE_TOPIC] is None
@ -204,15 +239,11 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
optimistic or topic[CONF_WHITE_VALUE_STATE_TOPIC] is None) optimistic or topic[CONF_WHITE_VALUE_STATE_TOPIC] is None)
self._optimistic_xy = \ self._optimistic_xy = \
optimistic or topic[CONF_XY_STATE_TOPIC] is None optimistic or topic[CONF_XY_STATE_TOPIC] is None
self._brightness_scale = brightness_scale
self._white_value_scale = white_value_scale self._brightness_scale = config.get(CONF_BRIGHTNESS_SCALE)
self._on_command_type = on_command_type self._white_value_scale = config.get(CONF_WHITE_VALUE_SCALE)
self._state = False self._on_command_type = config.get(CONF_ON_COMMAND_TYPE)
self._brightness = None
self._hs = None
self._color_temp = None
self._effect = None
self._white_value = None
self._supported_features = 0 self._supported_features = 0
self._supported_features |= ( self._supported_features |= (
topic[CONF_RGB_COMMAND_TOPIC] is not None and topic[CONF_RGB_COMMAND_TOPIC] is not None and
@ -233,12 +264,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
SUPPORT_WHITE_VALUE) SUPPORT_WHITE_VALUE)
self._supported_features |= ( self._supported_features |= (
topic[CONF_XY_COMMAND_TOPIC] is not None and SUPPORT_COLOR) topic[CONF_XY_COMMAND_TOPIC] is not None and SUPPORT_COLOR)
self._discovery_hash = discovery_hash
async def async_added_to_hass(self):
"""Subscribe to MQTT events."""
await super().async_added_to_hass()
async def _subscribe_topics(self):
"""(Re)Subscribe to topics."""
topics = {}
templates = {} templates = {}
for key, tpl in list(self._templates.items()): for key, tpl in list(self._templates.items()):
if tpl is None: if tpl is None:
@ -264,9 +293,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state() self.async_schedule_update_ha_state()
if self._topic[CONF_STATE_TOPIC] is not None: if self._topic[CONF_STATE_TOPIC] is not None:
await mqtt.async_subscribe( topics[CONF_STATE_TOPIC] = {
self.hass, self._topic[CONF_STATE_TOPIC], state_received, 'topic': self._topic[CONF_STATE_TOPIC],
self._qos) 'msg_callback': state_received,
'qos': self._qos}
elif self._optimistic and last_state: elif self._optimistic and last_state:
self._state = last_state.state == STATE_ON self._state = last_state.state == STATE_ON
@ -285,9 +315,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state() self.async_schedule_update_ha_state()
if self._topic[CONF_BRIGHTNESS_STATE_TOPIC] is not None: if self._topic[CONF_BRIGHTNESS_STATE_TOPIC] is not None:
await mqtt.async_subscribe( topics[CONF_BRIGHTNESS_STATE_TOPIC] = {
self.hass, self._topic[CONF_BRIGHTNESS_STATE_TOPIC], 'topic': self._topic[CONF_BRIGHTNESS_STATE_TOPIC],
brightness_received, self._qos) 'msg_callback': brightness_received,
'qos': self._qos}
self._brightness = 255 self._brightness = 255
elif self._optimistic_brightness and last_state\ elif self._optimistic_brightness and last_state\
and last_state.attributes.get(ATTR_BRIGHTNESS): and last_state.attributes.get(ATTR_BRIGHTNESS):
@ -314,9 +345,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state() self.async_schedule_update_ha_state()
if self._topic[CONF_RGB_STATE_TOPIC] is not None: if self._topic[CONF_RGB_STATE_TOPIC] is not None:
await mqtt.async_subscribe( topics[CONF_RGB_STATE_TOPIC] = {
self.hass, self._topic[CONF_RGB_STATE_TOPIC], rgb_received, 'topic': self._topic[CONF_RGB_STATE_TOPIC],
self._qos) 'msg_callback': rgb_received,
'qos': self._qos}
self._hs = (0, 0) self._hs = (0, 0)
if self._optimistic_rgb and last_state\ if self._optimistic_rgb and last_state\
and last_state.attributes.get(ATTR_HS_COLOR): and last_state.attributes.get(ATTR_HS_COLOR):
@ -337,9 +369,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state() self.async_schedule_update_ha_state()
if self._topic[CONF_COLOR_TEMP_STATE_TOPIC] is not None: if self._topic[CONF_COLOR_TEMP_STATE_TOPIC] is not None:
await mqtt.async_subscribe( topics[CONF_COLOR_TEMP_STATE_TOPIC] = {
self.hass, self._topic[CONF_COLOR_TEMP_STATE_TOPIC], 'topic': self._topic[CONF_COLOR_TEMP_STATE_TOPIC],
color_temp_received, self._qos) 'msg_callback': color_temp_received,
'qos': self._qos}
self._color_temp = 150 self._color_temp = 150
if self._optimistic_color_temp and last_state\ if self._optimistic_color_temp and last_state\
and last_state.attributes.get(ATTR_COLOR_TEMP): and last_state.attributes.get(ATTR_COLOR_TEMP):
@ -361,9 +394,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state() self.async_schedule_update_ha_state()
if self._topic[CONF_EFFECT_STATE_TOPIC] is not None: if self._topic[CONF_EFFECT_STATE_TOPIC] is not None:
await mqtt.async_subscribe( topics[CONF_EFFECT_STATE_TOPIC] = {
self.hass, self._topic[CONF_EFFECT_STATE_TOPIC], 'topic': self._topic[CONF_EFFECT_STATE_TOPIC],
effect_received, self._qos) 'msg_callback': effect_received,
'qos': self._qos}
self._effect = 'none' self._effect = 'none'
if self._optimistic_effect and last_state\ if self._optimistic_effect and last_state\
and last_state.attributes.get(ATTR_EFFECT): and last_state.attributes.get(ATTR_EFFECT):
@ -390,9 +424,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
payload) payload)
if self._topic[CONF_HS_STATE_TOPIC] is not None: if self._topic[CONF_HS_STATE_TOPIC] is not None:
await mqtt.async_subscribe( topics[CONF_HS_STATE_TOPIC] = {
self.hass, self._topic[CONF_HS_STATE_TOPIC], hs_received, 'topic': self._topic[CONF_HS_STATE_TOPIC],
self._qos) 'msg_callback': hs_received,
'qos': self._qos}
self._hs = (0, 0) self._hs = (0, 0)
if self._optimistic_hs and last_state\ if self._optimistic_hs and last_state\
and last_state.attributes.get(ATTR_HS_COLOR): and last_state.attributes.get(ATTR_HS_COLOR):
@ -415,9 +450,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state() self.async_schedule_update_ha_state()
if self._topic[CONF_WHITE_VALUE_STATE_TOPIC] is not None: if self._topic[CONF_WHITE_VALUE_STATE_TOPIC] is not None:
await mqtt.async_subscribe( topics[CONF_WHITE_VALUE_STATE_TOPIC] = {
self.hass, self._topic[CONF_WHITE_VALUE_STATE_TOPIC], 'topic': self._topic[CONF_WHITE_VALUE_STATE_TOPIC],
white_value_received, self._qos) 'msg_callback': white_value_received,
'qos': self._qos}
self._white_value = 255 self._white_value = 255
elif self._optimistic_white_value and last_state\ elif self._optimistic_white_value and last_state\
and last_state.attributes.get(ATTR_WHITE_VALUE): and last_state.attributes.get(ATTR_WHITE_VALUE):
@ -441,9 +477,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state() self.async_schedule_update_ha_state()
if self._topic[CONF_XY_STATE_TOPIC] is not None: if self._topic[CONF_XY_STATE_TOPIC] is not None:
await mqtt.async_subscribe( topics[CONF_XY_STATE_TOPIC] = {
self.hass, self._topic[CONF_XY_STATE_TOPIC], xy_received, 'topic': self._topic[CONF_XY_STATE_TOPIC],
self._qos) 'msg_callback': xy_received,
'qos': self._qos}
self._hs = (0, 0) self._hs = (0, 0)
if self._optimistic_xy and last_state\ if self._optimistic_xy and last_state\
and last_state.attributes.get(ATTR_HS_COLOR): and last_state.attributes.get(ATTR_HS_COLOR):
@ -451,6 +488,15 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
elif self._topic[CONF_XY_COMMAND_TOPIC] is not None: elif self._topic[CONF_XY_COMMAND_TOPIC] is not None:
self._hs = (0, 0) self._hs = (0, 0)
self._sub_state = await subscription.async_subscribe_topics(
self.hass, self._sub_state,
topics)
async def async_will_remove_from_hass(self):
"""Unsubscribe when removed."""
await subscription.async_unsubscribe_topics(self.hass, self._sub_state)
await MqttAvailability.async_will_remove_from_hass(self)
@property @property
def brightness(self): def brightness(self):
"""Return the brightness of this light between 0..255.""" """Return the brightness of this light between 0..255."""

168
homeassistant/components/light/mqtt/schema_json.py
View File

@ -6,7 +6,6 @@ https://home-assistant.io/components/light.mqtt_json/
""" """
import json import json
import logging import logging
from typing import Optional
import voluptuous as vol import voluptuous as vol
@ -19,7 +18,7 @@ from homeassistant.components.light import (
from homeassistant.components.mqtt import ( from homeassistant.components.mqtt import (
CONF_AVAILABILITY_TOPIC, CONF_COMMAND_TOPIC, CONF_PAYLOAD_AVAILABLE, CONF_AVAILABILITY_TOPIC, CONF_COMMAND_TOPIC, CONF_PAYLOAD_AVAILABLE,
CONF_PAYLOAD_NOT_AVAILABLE, CONF_QOS, CONF_RETAIN, CONF_STATE_TOPIC, CONF_PAYLOAD_NOT_AVAILABLE, CONF_QOS, CONF_RETAIN, CONF_STATE_TOPIC,
MqttAvailability, MqttDiscoveryUpdate) MqttAvailability, MqttDiscoveryUpdate, subscription)
from homeassistant.const import ( from homeassistant.const import (
CONF_BRIGHTNESS, CONF_COLOR_TEMP, CONF_EFFECT, CONF_NAME, CONF_OPTIMISTIC, CONF_BRIGHTNESS, CONF_COLOR_TEMP, CONF_EFFECT, CONF_NAME, CONF_OPTIMISTIC,
CONF_RGB, CONF_WHITE_VALUE, CONF_XY, STATE_ON) CONF_RGB, CONF_WHITE_VALUE, CONF_XY, STATE_ON)
@ -87,105 +86,129 @@ PLATFORM_SCHEMA_JSON = mqtt.MQTT_RW_PLATFORM_SCHEMA.extend({
async def async_setup_entity_json(hass: HomeAssistantType, config: ConfigType, async def async_setup_entity_json(hass: HomeAssistantType, config: ConfigType,
async_add_entities, discovery_hash): async_add_entities, discovery_hash):
"""Set up a MQTT JSON Light.""" """Set up a MQTT JSON Light."""
async_add_entities([MqttLightJson( async_add_entities([MqttLightJson(config, discovery_hash)])
config.get(CONF_NAME),
config.get(CONF_UNIQUE_ID),
config.get(CONF_EFFECT_LIST),
{
key: config.get(key) for key in (
CONF_STATE_TOPIC,
CONF_COMMAND_TOPIC
)
},
config.get(CONF_QOS),
config.get(CONF_RETAIN),
config.get(CONF_OPTIMISTIC),
config.get(CONF_BRIGHTNESS),
config.get(CONF_COLOR_TEMP),
config.get(CONF_EFFECT),
config.get(CONF_RGB),
config.get(CONF_WHITE_VALUE),
config.get(CONF_XY),
config.get(CONF_HS),
{
key: config.get(key) for key in (
CONF_FLASH_TIME_SHORT,
CONF_FLASH_TIME_LONG
)
},
config.get(CONF_AVAILABILITY_TOPIC),
config.get(CONF_PAYLOAD_AVAILABLE),
config.get(CONF_PAYLOAD_NOT_AVAILABLE),
config.get(CONF_BRIGHTNESS_SCALE),
discovery_hash,
)])
class MqttLightJson(MqttAvailability, MqttDiscoveryUpdate, Light, class MqttLightJson(MqttAvailability, MqttDiscoveryUpdate, Light,
RestoreEntity): RestoreEntity):
"""Representation of a MQTT JSON light.""" """Representation of a MQTT JSON light."""
def __init__(self, name, unique_id, effect_list, topic, qos, retain, def __init__(self, config, discovery_hash):
optimistic, brightness, color_temp, effect, rgb, white_value,
xy, hs, flash_times, availability_topic, payload_available,
payload_not_available, brightness_scale,
discovery_hash: Optional[str]):
"""Initialize MQTT JSON light.""" """Initialize MQTT JSON light."""
MqttAvailability.__init__(self, availability_topic, qos,
payload_available, payload_not_available)
MqttDiscoveryUpdate.__init__(self, discovery_hash)
self._name = name
self._unique_id = unique_id
self._effect_list = effect_list
self._topic = topic
self._qos = qos
self._retain = retain
self._optimistic = optimistic or topic[CONF_STATE_TOPIC] is None
self._state = False self._state = False
self._rgb = rgb self._sub_state = None
self._xy = xy self._supported_features = 0
self._hs_support = hs
self._name = None
self._effect_list = None
self._topic = None
self._qos = None
self._retain = None
self._optimistic = False
self._rgb = False
self._xy = False
self._hs_support = False
self._brightness = None
self._color_temp = None
self._effect = None
self._hs = None
self._white_value = None
self._flash_times = None
self._brightness_scale = None
self._unique_id = config.get(CONF_UNIQUE_ID)
# Load config
self._setup_from_config(config)
availability_topic = config.get(CONF_AVAILABILITY_TOPIC)
payload_available = config.get(CONF_PAYLOAD_AVAILABLE)
payload_not_available = config.get(CONF_PAYLOAD_NOT_AVAILABLE)
MqttAvailability.__init__(self, availability_topic, self._qos,
payload_available, payload_not_available)
MqttDiscoveryUpdate.__init__(self, discovery_hash,
self.discovery_update)
async def async_added_to_hass(self):
"""Subscribe to MQTT events."""
await super().async_added_to_hass()
await self._subscribe_topics()
async def discovery_update(self, discovery_payload):
"""Handle updated discovery message."""
config = PLATFORM_SCHEMA_JSON(discovery_payload)
self._setup_from_config(config)
await self.availability_discovery_update(config)
await self._subscribe_topics()
self.async_schedule_update_ha_state()
def _setup_from_config(self, config):
"""(Re)Setup the entity."""
self._name = config.get(CONF_NAME)
self._effect_list = config.get(CONF_EFFECT_LIST)
self._topic = {
key: config.get(key) for key in (
CONF_STATE_TOPIC,
CONF_COMMAND_TOPIC
)
}
self._qos = config.get(CONF_QOS)
self._retain = config.get(CONF_RETAIN)
optimistic = config.get(CONF_OPTIMISTIC)
self._optimistic = optimistic or self._topic[CONF_STATE_TOPIC] is None
brightness = config.get(CONF_BRIGHTNESS)
if brightness: if brightness:
self._brightness = 255 self._brightness = 255
else: else:
self._brightness = None self._brightness = None
color_temp = config.get(CONF_COLOR_TEMP)
if color_temp: if color_temp:
self._color_temp = 150 self._color_temp = 150
else: else:
self._color_temp = None self._color_temp = None
effect = config.get(CONF_EFFECT)
if effect: if effect:
self._effect = 'none' self._effect = 'none'
else: else:
self._effect = None self._effect = None
if hs or rgb or xy: white_value = config.get(CONF_WHITE_VALUE)
self._hs = [0, 0]
else:
self._hs = None
if white_value: if white_value:
self._white_value = 255 self._white_value = 255
else: else:
self._white_value = None self._white_value = None
self._flash_times = flash_times self._rgb = config.get(CONF_RGB)
self._brightness_scale = brightness_scale self._xy = config.get(CONF_XY)
self._hs_support = config.get(CONF_HS)
if self._hs_support or self._rgb or self._xy:
self._hs = [0, 0]
else:
self._hs = None
self._flash_times = {
key: config.get(key) for key in (
CONF_FLASH_TIME_SHORT,
CONF_FLASH_TIME_LONG
)
}
self._brightness_scale = config.get(CONF_BRIGHTNESS_SCALE)
self._supported_features = (SUPPORT_TRANSITION | SUPPORT_FLASH) self._supported_features = (SUPPORT_TRANSITION | SUPPORT_FLASH)
self._supported_features |= (rgb and SUPPORT_COLOR) self._supported_features |= (self._rgb and SUPPORT_COLOR)
self._supported_features |= (brightness and SUPPORT_BRIGHTNESS) self._supported_features |= (brightness and SUPPORT_BRIGHTNESS)
self._supported_features |= (color_temp and SUPPORT_COLOR_TEMP) self._supported_features |= (color_temp and SUPPORT_COLOR_TEMP)
self._supported_features |= (effect and SUPPORT_EFFECT) self._supported_features |= (effect and SUPPORT_EFFECT)
self._supported_features |= (white_value and SUPPORT_WHITE_VALUE) self._supported_features |= (white_value and SUPPORT_WHITE_VALUE)
self._supported_features |= (xy and SUPPORT_COLOR) self._supported_features |= (self._xy and SUPPORT_COLOR)
self._supported_features |= (hs and SUPPORT_COLOR) self._supported_features |= (self._hs_support and SUPPORT_COLOR)
async def async_added_to_hass(self):
"""Subscribe to MQTT events."""
await super().async_added_to_hass()
async def _subscribe_topics(self):
"""(Re)Subscribe to topics."""
last_state = await self.async_get_last_state() last_state = await self.async_get_last_state()
@callback @callback
@ -267,9 +290,11 @@ class MqttLightJson(MqttAvailability, MqttDiscoveryUpdate, Light,
self.async_schedule_update_ha_state() self.async_schedule_update_ha_state()
if self._topic[CONF_STATE_TOPIC] is not None: if self._topic[CONF_STATE_TOPIC] is not None:
await mqtt.async_subscribe( self._sub_state = await subscription.async_subscribe_topics(
self.hass, self._topic[CONF_STATE_TOPIC], state_received, self.hass, self._sub_state,
self._qos) {'state_topic': {'topic': self._topic[CONF_STATE_TOPIC],
'msg_callback': state_received,
'qos': self._qos}})
if self._optimistic and last_state: if self._optimistic and last_state:
self._state = last_state.state == STATE_ON self._state = last_state.state == STATE_ON
@ -284,6 +309,11 @@ class MqttLightJson(MqttAvailability, MqttDiscoveryUpdate, Light,
if last_state.attributes.get(ATTR_WHITE_VALUE): if last_state.attributes.get(ATTR_WHITE_VALUE):
self._white_value = last_state.attributes.get(ATTR_WHITE_VALUE) self._white_value = last_state.attributes.get(ATTR_WHITE_VALUE)
async def async_will_remove_from_hass(self):
"""Unsubscribe when removed."""
await subscription.async_unsubscribe_topics(self.hass, self._sub_state)
await MqttAvailability.async_will_remove_from_hass(self)
@property @property
def brightness(self): def brightness(self):
"""Return the brightness of this light between 0..255.""" """Return the brightness of this light between 0..255."""

124
homeassistant/components/light/mqtt/schema_template.py
View File

@ -18,7 +18,7 @@ from homeassistant.const import CONF_NAME, CONF_OPTIMISTIC, STATE_ON, STATE_OFF
from homeassistant.components.mqtt import ( from homeassistant.components.mqtt import (
CONF_AVAILABILITY_TOPIC, CONF_STATE_TOPIC, CONF_COMMAND_TOPIC, CONF_AVAILABILITY_TOPIC, CONF_STATE_TOPIC, CONF_COMMAND_TOPIC,
CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_QOS, CONF_RETAIN, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_QOS, CONF_RETAIN,
MqttAvailability) MqttAvailability, MqttDiscoveryUpdate, subscription)
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
import homeassistant.util.color as color_util import homeassistant.util.color as color_util
from homeassistant.helpers.restore_state import RestoreEntity from homeassistant.helpers.restore_state import RestoreEntity
@ -69,17 +69,69 @@ PLATFORM_SCHEMA_TEMPLATE = mqtt.MQTT_RW_PLATFORM_SCHEMA.extend({
async def async_setup_entity_template(hass, config, async_add_entities, async def async_setup_entity_template(hass, config, async_add_entities,
discovery_hash): discovery_hash):
"""Set up a MQTT Template light.""" """Set up a MQTT Template light."""
async_add_entities([MqttTemplate( async_add_entities([MqttTemplate(config, discovery_hash)])
hass,
config.get(CONF_NAME),
config.get(CONF_EFFECT_LIST), class MqttTemplate(MqttAvailability, MqttDiscoveryUpdate, Light,
{ RestoreEntity):
"""Representation of a MQTT Template light."""
def __init__(self, config, discovery_hash):
"""Initialize a MQTT Template light."""
self._state = False
self._sub_state = None
self._name = None
self._effect_list = None
self._topics = None
self._templates = None
self._optimistic = False
self._qos = None
self._retain = None
# features
self._brightness = None
self._color_temp = None
self._white_value = None
self._hs = None
self._effect = None
# Load config
self._setup_from_config(config)
availability_topic = config.get(CONF_AVAILABILITY_TOPIC)
payload_available = config.get(CONF_PAYLOAD_AVAILABLE)
payload_not_available = config.get(CONF_PAYLOAD_NOT_AVAILABLE)
MqttAvailability.__init__(self, availability_topic, self._qos,
payload_available, payload_not_available)
MqttDiscoveryUpdate.__init__(self, discovery_hash,
self.discovery_update)
async def async_added_to_hass(self):
"""Subscribe to MQTT events."""
await super().async_added_to_hass()
await self._subscribe_topics()
async def discovery_update(self, discovery_payload):
"""Handle updated discovery message."""
config = PLATFORM_SCHEMA_TEMPLATE(discovery_payload)
self._setup_from_config(config)
await self.availability_discovery_update(config)
await self._subscribe_topics()
self.async_schedule_update_ha_state()
def _setup_from_config(self, config):
"""(Re)Setup the entity."""
self._name = config.get(CONF_NAME)
self._effect_list = config.get(CONF_EFFECT_LIST)
self._topics = {
key: config.get(key) for key in ( key: config.get(key) for key in (
CONF_STATE_TOPIC, CONF_STATE_TOPIC,
CONF_COMMAND_TOPIC CONF_COMMAND_TOPIC
) )
}, }
{ self._templates = {
key: config.get(key) for key in ( key: config.get(key) for key in (
CONF_BLUE_TEMPLATE, CONF_BLUE_TEMPLATE,
CONF_BRIGHTNESS_TEMPLATE, CONF_BRIGHTNESS_TEMPLATE,
@ -92,36 +144,15 @@ async def async_setup_entity_template(hass, config, async_add_entities,
CONF_STATE_TEMPLATE, CONF_STATE_TEMPLATE,
CONF_WHITE_VALUE_TEMPLATE, CONF_WHITE_VALUE_TEMPLATE,
) )
}, }
config.get(CONF_OPTIMISTIC), optimistic = config.get(CONF_OPTIMISTIC)
config.get(CONF_QOS), self._optimistic = optimistic \
config.get(CONF_RETAIN), or self._topics[CONF_STATE_TOPIC] is None \
config.get(CONF_AVAILABILITY_TOPIC), or self._templates[CONF_STATE_TEMPLATE] is None
config.get(CONF_PAYLOAD_AVAILABLE), self._qos = config.get(CONF_QOS)
config.get(CONF_PAYLOAD_NOT_AVAILABLE), self._retain = config.get(CONF_RETAIN)
)])
class MqttTemplate(MqttAvailability, Light, RestoreEntity):
"""Representation of a MQTT Template light."""
def __init__(self, hass, name, effect_list, topics, templates, optimistic,
qos, retain, availability_topic, payload_available,
payload_not_available):
"""Initialize a MQTT Template light."""
super().__init__(availability_topic, qos, payload_available,
payload_not_available)
self._name = name
self._effect_list = effect_list
self._topics = topics
self._templates = templates
self._optimistic = optimistic or topics[CONF_STATE_TOPIC] is None \
or templates[CONF_STATE_TEMPLATE] is None
self._qos = qos
self._retain = retain
# features # features
self._state = False
if self._templates[CONF_BRIGHTNESS_TEMPLATE] is not None: if self._templates[CONF_BRIGHTNESS_TEMPLATE] is not None:
self._brightness = 255 self._brightness = 255
else: else:
@ -145,13 +176,11 @@ class MqttTemplate(MqttAvailability, Light, RestoreEntity):
self._hs = None self._hs = None
self._effect = None self._effect = None
async def _subscribe_topics(self):
"""(Re)Subscribe to topics."""
for tpl in self._templates.values(): for tpl in self._templates.values():
if tpl is not None: if tpl is not None:
tpl.hass = hass tpl.hass = self.hass
async def async_added_to_hass(self):
"""Subscribe to MQTT events."""
await super().async_added_to_hass()
last_state = await self.async_get_last_state() last_state = await self.async_get_last_state()
@ -221,9 +250,11 @@ class MqttTemplate(MqttAvailability, Light, RestoreEntity):
self.async_schedule_update_ha_state() self.async_schedule_update_ha_state()
if self._topics[CONF_STATE_TOPIC] is not None: if self._topics[CONF_STATE_TOPIC] is not None:
await mqtt.async_subscribe( self._sub_state = await subscription.async_subscribe_topics(
self.hass, self._topics[CONF_STATE_TOPIC], state_received, self.hass, self._sub_state,
self._qos) {'state_topic': {'topic': self._topics[CONF_STATE_TOPIC],
'msg_callback': state_received,
'qos': self._qos}})
if self._optimistic and last_state: if self._optimistic and last_state:
self._state = last_state.state == STATE_ON self._state = last_state.state == STATE_ON
@ -238,6 +269,11 @@ class MqttTemplate(MqttAvailability, Light, RestoreEntity):
if last_state.attributes.get(ATTR_WHITE_VALUE): if last_state.attributes.get(ATTR_WHITE_VALUE):
self._white_value = last_state.attributes.get(ATTR_WHITE_VALUE) self._white_value = last_state.attributes.get(ATTR_WHITE_VALUE)
async def async_will_remove_from_hass(self):
"""Unsubscribe when removed."""
await subscription.async_unsubscribe_topics(self.hass, self._sub_state)
await MqttAvailability.async_will_remove_from_hass(self)
@property @property
def brightness(self): def brightness(self):
"""Return the brightness of this light between 0..255.""" """Return the brightness of this light between 0..255."""

38
tests/components/light/test_mqtt.py
View File

@ -1067,7 +1067,7 @@ async def test_discovery_removal_light(hass, mqtt_mock, caplog):
async def test_discovery_deprecated(hass, mqtt_mock, caplog): async def test_discovery_deprecated(hass, mqtt_mock, caplog):
"""Test removal of discovered mqtt_json lights.""" """Test discovery of mqtt light with deprecated platform option."""
entry = MockConfigEntry(domain=mqtt.DOMAIN) entry = MockConfigEntry(domain=mqtt.DOMAIN)
await async_start(hass, 'homeassistant', {'mqtt': {}}, entry) await async_start(hass, 'homeassistant', {'mqtt': {}}, entry)
data = ( data = (
@ -1081,3 +1081,39 @@ async def test_discovery_deprecated(hass, mqtt_mock, caplog):
state = hass.states.get('light.beer') state = hass.states.get('light.beer')
assert state is not None assert state is not None
assert state.name == 'Beer' assert state.name == 'Beer'
async def test_discovery_update_light(hass, mqtt_mock, caplog):
"""Test removal of discovered light."""
entry = MockConfigEntry(domain=mqtt.DOMAIN)
await async_start(hass, 'homeassistant', {}, entry)
data1 = (
'{ "name": "Beer",'
' "status_topic": "test_topic",'
' "command_topic": "test_topic" }'
)
data2 = (
'{ "name": "Milk",'
' "status_topic": "test_topic",'
' "command_topic": "test_topic" }'
)
async_fire_mqtt_message(hass, 'homeassistant/light/bla/config',
data1)
await hass.async_block_till_done()
state = hass.states.get('light.beer')
assert state is not None
assert state.name == 'Beer'
async_fire_mqtt_message(hass, 'homeassistant/light/bla/config',
data2)
await hass.async_block_till_done()
await hass.async_block_till_done()
state = hass.states.get('light.beer')
assert state is not None
assert state.name == 'Milk'
state = hass.states.get('light.milk')
assert state is None

40
tests/components/light/test_mqtt_json.py
View File

@ -557,7 +557,7 @@ async def test_discovery_removal(hass, mqtt_mock, caplog):
async def test_discovery_deprecated(hass, mqtt_mock, caplog): async def test_discovery_deprecated(hass, mqtt_mock, caplog):
"""Test removal of discovered mqtt_json lights.""" """Test discovery of mqtt_json light with deprecated platform option."""
entry = MockConfigEntry(domain=mqtt.DOMAIN) entry = MockConfigEntry(domain=mqtt.DOMAIN)
await async_start(hass, 'homeassistant', {'mqtt': {}}, entry) await async_start(hass, 'homeassistant', {'mqtt': {}}, entry)
data = ( data = (
@ -571,3 +571,41 @@ async def test_discovery_deprecated(hass, mqtt_mock, caplog):
state = hass.states.get('light.beer') state = hass.states.get('light.beer')
assert state is not None assert state is not None
assert state.name == 'Beer' assert state.name == 'Beer'
async def test_discovery_update_light(hass, mqtt_mock, caplog):
"""Test removal of discovered light."""
entry = MockConfigEntry(domain=mqtt.DOMAIN)
await async_start(hass, 'homeassistant', {}, entry)
data1 = (
'{ "name": "Beer",'
' "schema": "json",'
' "status_topic": "test_topic",'
' "command_topic": "test_topic" }'
)
data2 = (
'{ "name": "Milk",'
' "schema": "json",'
' "status_topic": "test_topic",'
' "command_topic": "test_topic" }'
)
async_fire_mqtt_message(hass, 'homeassistant/light/bla/config',
data1)
await hass.async_block_till_done()
state = hass.states.get('light.beer')
assert state is not None
assert state.name == 'Beer'
async_fire_mqtt_message(hass, 'homeassistant/light/bla/config',
data2)
await hass.async_block_till_done()
await hass.async_block_till_done()
state = hass.states.get('light.beer')
assert state is not None
assert state.name == 'Milk'
state = hass.states.get('light.milk')
assert state is None

44
tests/components/light/test_mqtt_template.py
View File

@ -504,7 +504,7 @@ async def test_discovery(hass, mqtt_mock, caplog):
async def test_discovery_deprecated(hass, mqtt_mock, caplog): async def test_discovery_deprecated(hass, mqtt_mock, caplog):
"""Test removal of discovered mqtt_json lights.""" """Test discovery of mqtt template light with deprecated option."""
entry = MockConfigEntry(domain=mqtt.DOMAIN) entry = MockConfigEntry(domain=mqtt.DOMAIN)
await async_start(hass, 'homeassistant', {'mqtt': {}}, entry) await async_start(hass, 'homeassistant', {'mqtt': {}}, entry)
data = ( data = (
@ -520,3 +520,45 @@ async def test_discovery_deprecated(hass, mqtt_mock, caplog):
state = hass.states.get('light.beer') state = hass.states.get('light.beer')
assert state is not None assert state is not None
assert state.name == 'Beer' assert state.name == 'Beer'
async def test_discovery_update_light(hass, mqtt_mock, caplog):
"""Test removal of discovered light."""
entry = MockConfigEntry(domain=mqtt.DOMAIN)
await async_start(hass, 'homeassistant', {}, entry)
data1 = (
'{ "name": "Beer",'
' "schema": "template",'
' "status_topic": "test_topic",'
' "command_topic": "test_topic",'
' "command_on_template": "on",'
' "command_off_template": "off"}'
)
data2 = (
'{ "name": "Milk",'
' "schema": "template",'
' "status_topic": "test_topic",'
' "command_topic": "test_topic",'
' "command_on_template": "on",'
' "command_off_template": "off"}'
)
async_fire_mqtt_message(hass, 'homeassistant/light/bla/config',
data1)
await hass.async_block_till_done()
state = hass.states.get('light.beer')
assert state is not None
assert state.name == 'Beer'
async_fire_mqtt_message(hass, 'homeassistant/light/bla/config',
data2)
await hass.async_block_till_done()
await hass.async_block_till_done()
state = hass.states.get('light.beer')
assert state is not None
assert state.name == 'Milk'
state = hass.states.get('light.milk')
assert state is None