diff --git a/homeassistant/components/light/mqtt/schema_basic.py b/homeassistant/components/light/mqtt/schema_basic.py index 6a151092ef0..4c648b5ddae 100644 --- a/homeassistant/components/light/mqtt/schema_basic.py +++ b/homeassistant/components/light/mqtt/schema_basic.py @@ -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.""" diff --git a/homeassistant/components/light/mqtt/schema_json.py b/homeassistant/components/light/mqtt/schema_json.py index 55df6cbfd5e..dd3c896532f 100644 --- a/homeassistant/components/light/mqtt/schema_json.py +++ b/homeassistant/components/light/mqtt/schema_json.py @@ -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.""" diff --git a/homeassistant/components/light/mqtt/schema_template.py b/homeassistant/components/light/mqtt/schema_template.py index 81ef3e901dd..e14e8e32be7 100644 --- a/homeassistant/components/light/mqtt/schema_template.py +++ b/homeassistant/components/light/mqtt/schema_template.py @@ -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.""" diff --git a/tests/components/light/test_mqtt.py b/tests/components/light/test_mqtt.py index 3b4ff586c94..9e4fa3ebc79 100644 --- a/tests/components/light/test_mqtt.py +++ b/tests/components/light/test_mqtt.py @@ -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 diff --git a/tests/components/light/test_mqtt_json.py b/tests/components/light/test_mqtt_json.py index ae34cb6d827..8567dfd7921 100644 --- a/tests/components/light/test_mqtt_json.py +++ b/tests/components/light/test_mqtt_json.py @@ -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 diff --git a/tests/components/light/test_mqtt_template.py b/tests/components/light/test_mqtt_template.py index 56030da43f2..ce4a5f5a2e6 100644 --- a/tests/components/light/test_mqtt_template.py +++ b/tests/components/light/test_mqtt_template.py @@ -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