Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

pull/18937/head
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 (
CONF_AVAILABILITY_TOPIC, CONF_COMMAND_TOPIC, CONF_PAYLOAD_AVAILABLE,
CONF_PAYLOAD_NOT_AVAILABLE, CONF_QOS, CONF_RETAIN, CONF_STATE_TOPIC,
MqttAvailability, MqttDiscoveryUpdate)
MqttAvailability, MqttDiscoveryUpdate, subscription)
from homeassistant.helpers.restore_state import RestoreEntity
import homeassistant.helpers.config_validation as cv
import homeassistant.util.color as color_util
@ -114,11 +114,73 @@ async def async_setup_entity_basic(hass, config, async_add_entities,
config.setdefault(
CONF_STATE_VALUE_TEMPLATE, config.get(CONF_VALUE_TEMPLATE))
async_add_entities([MqttLight(
config.get(CONF_NAME),
config.get(CONF_UNIQUE_ID),
config.get(CONF_EFFECT_LIST),
{
async_add_entities([MqttLight(config, discovery_hash)])
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 (
CONF_BRIGHTNESS_COMMAND_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_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_COLOR_TEMP: config.get(CONF_COLOR_TEMP_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_WHITE_VALUE: config.get(CONF_WHITE_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,
)])
}
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
optimistic = config.get(CONF_OPTIMISTIC)
self._optimistic = optimistic or topic[CONF_STATE_TOPIC] is None
self._optimistic_rgb = \
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)
self._optimistic_xy = \
optimistic or topic[CONF_XY_STATE_TOPIC] is None
self._brightness_scale = brightness_scale
self._white_value_scale = white_value_scale
self._on_command_type = on_command_type
self._state = False
self._brightness = None
self._hs = None
self._color_temp = None
self._effect = None
self._white_value = None
self._brightness_scale = config.get(CONF_BRIGHTNESS_SCALE)
self._white_value_scale = config.get(CONF_WHITE_VALUE_SCALE)
self._on_command_type = config.get(CONF_ON_COMMAND_TYPE)
self._supported_features = 0
self._supported_features |= (
topic[CONF_RGB_COMMAND_TOPIC] is not None and
@ -233,12 +264,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
SUPPORT_WHITE_VALUE)
self._supported_features |= (
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 = {}
for key, tpl in list(self._templates.items()):
if tpl is None:
@ -264,9 +293,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state()
if self._topic[CONF_STATE_TOPIC] is not None:
await mqtt.async_subscribe(
self.hass, self._topic[CONF_STATE_TOPIC], state_received,
self._qos)
topics[CONF_STATE_TOPIC] = {
'topic': self._topic[CONF_STATE_TOPIC],
'msg_callback': state_received,
'qos': self._qos}
elif self._optimistic and last_state:
self._state = last_state.state == STATE_ON
@ -285,9 +315,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state()
if self._topic[CONF_BRIGHTNESS_STATE_TOPIC] is not None:
await mqtt.async_subscribe(
self.hass, self._topic[CONF_BRIGHTNESS_STATE_TOPIC],
brightness_received, self._qos)
topics[CONF_BRIGHTNESS_STATE_TOPIC] = {
'topic': self._topic[CONF_BRIGHTNESS_STATE_TOPIC],
'msg_callback': brightness_received,
'qos': self._qos}
self._brightness = 255
elif self._optimistic_brightness and last_state\
and last_state.attributes.get(ATTR_BRIGHTNESS):
@ -314,9 +345,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state()
if self._topic[CONF_RGB_STATE_TOPIC] is not None:
await mqtt.async_subscribe(
self.hass, self._topic[CONF_RGB_STATE_TOPIC], rgb_received,
self._qos)
topics[CONF_RGB_STATE_TOPIC] = {
'topic': self._topic[CONF_RGB_STATE_TOPIC],
'msg_callback': rgb_received,
'qos': self._qos}
self._hs = (0, 0)
if self._optimistic_rgb and last_state\
and last_state.attributes.get(ATTR_HS_COLOR):
@ -337,9 +369,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state()
if self._topic[CONF_COLOR_TEMP_STATE_TOPIC] is not None:
await mqtt.async_subscribe(
self.hass, self._topic[CONF_COLOR_TEMP_STATE_TOPIC],
color_temp_received, self._qos)
topics[CONF_COLOR_TEMP_STATE_TOPIC] = {
'topic': self._topic[CONF_COLOR_TEMP_STATE_TOPIC],
'msg_callback': color_temp_received,
'qos': self._qos}
self._color_temp = 150
if self._optimistic_color_temp and last_state\
and last_state.attributes.get(ATTR_COLOR_TEMP):
@ -361,9 +394,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state()
if self._topic[CONF_EFFECT_STATE_TOPIC] is not None:
await mqtt.async_subscribe(
self.hass, self._topic[CONF_EFFECT_STATE_TOPIC],
effect_received, self._qos)
topics[CONF_EFFECT_STATE_TOPIC] = {
'topic': self._topic[CONF_EFFECT_STATE_TOPIC],
'msg_callback': effect_received,
'qos': self._qos}
self._effect = 'none'
if self._optimistic_effect and last_state\
and last_state.attributes.get(ATTR_EFFECT):
@ -390,9 +424,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
payload)
if self._topic[CONF_HS_STATE_TOPIC] is not None:
await mqtt.async_subscribe(
self.hass, self._topic[CONF_HS_STATE_TOPIC], hs_received,
self._qos)
topics[CONF_HS_STATE_TOPIC] = {
'topic': self._topic[CONF_HS_STATE_TOPIC],
'msg_callback': hs_received,
'qos': self._qos}
self._hs = (0, 0)
if self._optimistic_hs and last_state\
and last_state.attributes.get(ATTR_HS_COLOR):
@ -415,9 +450,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state()
if self._topic[CONF_WHITE_VALUE_STATE_TOPIC] is not None:
await mqtt.async_subscribe(
self.hass, self._topic[CONF_WHITE_VALUE_STATE_TOPIC],
white_value_received, self._qos)
topics[CONF_WHITE_VALUE_STATE_TOPIC] = {
'topic': self._topic[CONF_WHITE_VALUE_STATE_TOPIC],
'msg_callback': white_value_received,
'qos': self._qos}
self._white_value = 255
elif self._optimistic_white_value and last_state\
and last_state.attributes.get(ATTR_WHITE_VALUE):
@ -441,9 +477,10 @@ class MqttLight(MqttAvailability, MqttDiscoveryUpdate, Light, RestoreEntity):
self.async_schedule_update_ha_state()
if self._topic[CONF_XY_STATE_TOPIC] is not None:
await mqtt.async_subscribe(
self.hass, self._topic[CONF_XY_STATE_TOPIC], xy_received,
self._qos)
topics[CONF_XY_STATE_TOPIC] = {
'topic': self._topic[CONF_XY_STATE_TOPIC],
'msg_callback': xy_received,
'qos': self._qos}
self._hs = (0, 0)
if self._optimistic_xy and last_state\
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:
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
def brightness(self):
"""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 logging
from typing import Optional
import voluptuous as vol
@ -19,7 +18,7 @@ from homeassistant.components.light import (
from homeassistant.components.mqtt import (
CONF_AVAILABILITY_TOPIC, CONF_COMMAND_TOPIC, CONF_PAYLOAD_AVAILABLE,
CONF_PAYLOAD_NOT_AVAILABLE, CONF_QOS, CONF_RETAIN, CONF_STATE_TOPIC,
MqttAvailability, MqttDiscoveryUpdate)
MqttAvailability, MqttDiscoveryUpdate, subscription)
from homeassistant.const import (
CONF_BRIGHTNESS, CONF_COLOR_TEMP, CONF_EFFECT, CONF_NAME, CONF_OPTIMISTIC,
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_add_entities, discovery_hash):
"""Set up a MQTT JSON Light."""
async_add_entities([MqttLightJson(
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,
)])
async_add_entities([MqttLightJson(config, discovery_hash)])
class MqttLightJson(MqttAvailability, MqttDiscoveryUpdate, Light,
RestoreEntity):
"""Representation of a MQTT JSON light."""
def __init__(self, name, unique_id, effect_list, topic, qos, retain,
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]):
def __init__(self, config, discovery_hash):
"""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._rgb = rgb
self._xy = xy
self._hs_support = hs
self._sub_state = None
self._supported_features = 0
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:
self._brightness = 255
else:
self._brightness = None
color_temp = config.get(CONF_COLOR_TEMP)
if color_temp:
self._color_temp = 150
else:
self._color_temp = None
effect = config.get(CONF_EFFECT)
if effect:
self._effect = 'none'
else:
self._effect = None
if hs or rgb or xy:
self._hs = [0, 0]
else:
self._hs = None
white_value = config.get(CONF_WHITE_VALUE)
if white_value:
self._white_value = 255
else:
self._white_value = None
self._flash_times = flash_times
self._brightness_scale = brightness_scale
self._rgb = config.get(CONF_RGB)
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 |= (rgb and SUPPORT_COLOR)
self._supported_features |= (self._rgb and SUPPORT_COLOR)
self._supported_features |= (brightness and SUPPORT_BRIGHTNESS)
self._supported_features |= (color_temp and SUPPORT_COLOR_TEMP)
self._supported_features |= (effect and SUPPORT_EFFECT)
self._supported_features |= (white_value and SUPPORT_WHITE_VALUE)
self._supported_features |= (xy and SUPPORT_COLOR)
self._supported_features |= (hs and SUPPORT_COLOR)
async def async_added_to_hass(self):
"""Subscribe to MQTT events."""
await super().async_added_to_hass()
self._supported_features |= (self._xy and SUPPORT_COLOR)
self._supported_features |= (self._hs_support and SUPPORT_COLOR)
async def _subscribe_topics(self):
"""(Re)Subscribe to topics."""
last_state = await self.async_get_last_state()
@callback
@ -267,9 +290,11 @@ class MqttLightJson(MqttAvailability, MqttDiscoveryUpdate, Light,
self.async_schedule_update_ha_state()
if self._topic[CONF_STATE_TOPIC] is not None:
await mqtt.async_subscribe(
self.hass, self._topic[CONF_STATE_TOPIC], state_received,
self._qos)
self._sub_state = await subscription.async_subscribe_topics(
self.hass, self._sub_state,
{'state_topic': {'topic': self._topic[CONF_STATE_TOPIC],
'msg_callback': state_received,
'qos': self._qos}})
if self._optimistic and last_state:
self._state = last_state.state == STATE_ON
@ -284,6 +309,11 @@ class MqttLightJson(MqttAvailability, MqttDiscoveryUpdate, Light,
if 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
def brightness(self):
"""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 (
CONF_AVAILABILITY_TOPIC, CONF_STATE_TOPIC, CONF_COMMAND_TOPIC,
CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_QOS, CONF_RETAIN,
MqttAvailability)
MqttAvailability, MqttDiscoveryUpdate, subscription)
import homeassistant.helpers.config_validation as cv
import homeassistant.util.color as color_util
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,
discovery_hash):
"""Set up a MQTT Template light."""
async_add_entities([MqttTemplate(
hass,
config.get(CONF_NAME),
config.get(CONF_EFFECT_LIST),
{
async_add_entities([MqttTemplate(config, discovery_hash)])
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 (
CONF_STATE_TOPIC,
CONF_COMMAND_TOPIC
)
},
{
}
self._templates = {
key: config.get(key) for key in (
CONF_BLUE_TEMPLATE,
CONF_BRIGHTNESS_TEMPLATE,
@ -92,36 +144,15 @@ async def async_setup_entity_template(hass, config, async_add_entities,
CONF_STATE_TEMPLATE,
CONF_WHITE_VALUE_TEMPLATE,
)
},
config.get(CONF_OPTIMISTIC),
config.get(CONF_QOS),
config.get(CONF_RETAIN),
config.get(CONF_AVAILABILITY_TOPIC),
config.get(CONF_PAYLOAD_AVAILABLE),
config.get(CONF_PAYLOAD_NOT_AVAILABLE),
)])
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
}
optimistic = config.get(CONF_OPTIMISTIC)
self._optimistic = optimistic \
or self._topics[CONF_STATE_TOPIC] is None \
or self._templates[CONF_STATE_TEMPLATE] is None
self._qos = config.get(CONF_QOS)
self._retain = config.get(CONF_RETAIN)
# features
self._state = False
if self._templates[CONF_BRIGHTNESS_TEMPLATE] is not None:
self._brightness = 255
else:
@ -145,13 +176,11 @@ class MqttTemplate(MqttAvailability, Light, RestoreEntity):
self._hs = None
self._effect = None
async def _subscribe_topics(self):
"""(Re)Subscribe to topics."""
for tpl in self._templates.values():
if tpl is not None:
tpl.hass = hass
async def async_added_to_hass(self):
"""Subscribe to MQTT events."""
await super().async_added_to_hass()
tpl.hass = self.hass
last_state = await self.async_get_last_state()
@ -221,9 +250,11 @@ class MqttTemplate(MqttAvailability, Light, RestoreEntity):
self.async_schedule_update_ha_state()
if self._topics[CONF_STATE_TOPIC] is not None:
await mqtt.async_subscribe(
self.hass, self._topics[CONF_STATE_TOPIC], state_received,
self._qos)
self._sub_state = await subscription.async_subscribe_topics(
self.hass, self._sub_state,
{'state_topic': {'topic': self._topics[CONF_STATE_TOPIC],
'msg_callback': state_received,
'qos': self._qos}})
if self._optimistic and last_state:
self._state = last_state.state == STATE_ON
@ -238,6 +269,11 @@ class MqttTemplate(MqttAvailability, Light, RestoreEntity):
if 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
def brightness(self):
"""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):
"""Test removal of discovered mqtt_json lights."""
"""Test discovery of mqtt light with deprecated platform option."""
entry = MockConfigEntry(domain=mqtt.DOMAIN)
await async_start(hass, 'homeassistant', {'mqtt': {}}, entry)
data = (
@ -1081,3 +1081,39 @@ async def test_discovery_deprecated(hass, mqtt_mock, caplog):
state = hass.states.get('light.beer')
assert state is not None
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):
"""Test removal of discovered mqtt_json lights."""
"""Test discovery of mqtt_json light with deprecated platform option."""
entry = MockConfigEntry(domain=mqtt.DOMAIN)
await async_start(hass, 'homeassistant', {'mqtt': {}}, entry)
data = (
@ -571,3 +571,41 @@ async def test_discovery_deprecated(hass, mqtt_mock, caplog):
state = hass.states.get('light.beer')
assert state is not None
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):
"""Test removal of discovered mqtt_json lights."""
"""Test discovery of mqtt template light with deprecated option."""
entry = MockConfigEntry(domain=mqtt.DOMAIN)
await async_start(hass, 'homeassistant', {'mqtt': {}}, entry)
data = (
@ -520,3 +520,45 @@ async def test_discovery_deprecated(hass, mqtt_mock, caplog):
state = hass.states.get('light.beer')
assert state is not None
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