def __init__(self, hass, name, state_topic, command_topic, qos,
payload_on, payload_off, optimistic):
self._state = False
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._payload_on = payload_on
self._payload_off = payload_off
self._optimistic = optimistic
def message_received(topic, payload, qos):
""" A new MQTT message has been received. """
if payload == self._payload_on:
self._state = True
self.update_ha_state()
elif payload == self._payload_off:
self._state = False
self.update_ha_state()
if self._state_topic is None:
# force optimistic mode
self._optimistic = True
else:
# subscribe the state_topic
mqtt.subscribe(hass, self._state_topic, message_received,
self._qos)
def __init__(self, hass, name, state_topic, command_topic, qos,
payload_disarm, payload_arm_home, payload_arm_away, code):
"""Initalize the MQTT alarm panel."""
self._state = STATE_UNKNOWN
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._payload_disarm = payload_disarm
self._payload_arm_home = payload_arm_home
self._payload_arm_away = payload_arm_away
self._code = str(code) if code else None
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
if payload not in (STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME,
STATE_ALARM_ARMED_AWAY, STATE_ALARM_PENDING,
STATE_ALARM_TRIGGERED):
_LOGGER.warning('Received unexpected payload: %s', payload)
return
self._state = payload
self.update_ha_state()
mqtt.subscribe(hass, self._state_topic, message_received, self._qos)
def test_subscribe_topic_subtree_wildcard_no_match(self):
mqtt.subscribe(self.hass, 'test-topic/#', self.record_calls)
fire_mqtt_message(self.hass, 'another-test-topic', 'test-payload')
self.hass.pool.block_till_done()
self.assertEqual(0, len(self.calls))
def setup_scanner(hass, config, see):
""" Set up a OwnTracksks tracker. """
def owntracks_location_update(topic, payload, qos):
""" MQTT message received. """
# Docs on available data:
# http://owntracks.org/booklet/tech/json/#_typelocation
try:
data = json.loads(payload)
except ValueError:
# If invalid JSON
logging.getLogger(__name__).error(
'Unable to parse payload as JSON: %s', payload)
return
if not isinstance(data, dict) or data.get('_type') != 'location':
return
parts = topic.split('/')
kwargs = {
'dev_id': '{}_{}'.format(parts[1], parts[2]),
'host_name': parts[1],
'gps': (data['lat'], data['lon']),
}
if 'acc' in data:
kwargs['gps_accuracy'] = data['acc']
if 'batt' in data:
kwargs['battery'] = data['batt']
see(**kwargs)
mqtt.subscribe(hass, LOCATION_TOPIC, owntracks_location_update, 1)
return True
def __init__(self, hass, name, state_topic, command_topic, qos,
payload_up, payload_down, payload_stop, value_template):
"""Initialize the roller shutter."""
self._state = None
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._payload_up = payload_up
self._payload_down = payload_down
self._payload_stop = payload_stop
if self._state_topic is None:
return
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
if value_template is not None:
payload = value_template.render_with_possible_json_value(
payload)
if payload.isnumeric() and 0 <= int(payload) <= 100:
self._state = int(payload)
self.update_ha_state()
else:
_LOGGER.warning(
"Payload is expected to be an integer between 0 and 100")
mqtt.subscribe(hass, self._state_topic, message_received, self._qos)
def __init__(self, hass, name, state_topic, command_topic, qos,
payload_up, payload_down, payload_stop, state_format):
self._state = None
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._payload_up = payload_up
self._payload_down = payload_down
self._payload_stop = payload_stop
self._parse = mqtt.FmtParser(state_format)
if self._state_topic is None:
return
def message_received(topic, payload, qos):
""" A new MQTT message has been received. """
value = self._parse(payload)
if value.isnumeric() and 0 <= int(value) <= 100:
self._state = int(value)
self.update_ha_state()
else:
_LOGGER.warning(
"Payload is expected to be an integer between 0 and 100")
mqtt.subscribe(hass, self._state_topic, message_received, self._qos)
def __init__(self, hass, name, state_topic, sensor_class, qos, payload_on,
payload_off, value_template):
"""Initialize the MQTT binary sensor."""
self._hass = hass
self._name = name
self._state = False
self._state_topic = state_topic
self._sensor_class = sensor_class
self._payload_on = payload_on
self._payload_off = payload_off
self._qos = qos
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
if value_template is not None:
payload = template.render_with_possible_json_value(
hass, value_template, payload)
if payload == self._payload_on:
self._state = True
self.update_ha_state()
elif payload == self._payload_off:
self._state = False
self.update_ha_state()
mqtt.subscribe(hass, self._state_topic, message_received, self._qos)
def __init__(self, hass, name, state_topic, command_topic, qos, retain,
payload_lock, payload_unlock, optimistic, value_template):
"""Initialize the lock."""
self._state = False
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._retain = retain
self._payload_lock = payload_lock
self._payload_unlock = payload_unlock
self._optimistic = optimistic
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
if value_template is not None:
payload = value_template.render_with_possible_json_value(
payload)
if payload == self._payload_lock:
self._state = True
self.schedule_update_ha_state()
elif payload == self._payload_unlock:
self._state = False
self.schedule_update_ha_state()
if self._state_topic is None:
# Force into optimistic mode.
self._optimistic = True
else:
mqtt.subscribe(
hass, self._state_topic, message_received, self._qos)
def __init__(self, hass, name, state_topic, command_topic, qos, retain,
payload_on, payload_off, optimistic, value_template):
"""Initialize the MQTT switch."""
self._state = False
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._retain = retain
self._payload_on = payload_on
self._payload_off = payload_off
self._optimistic = optimistic
@callback
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
if value_template is not None:
payload = value_template.async_render_with_possible_json_value(
payload)
if payload == self._payload_on:
self._state = True
hass.async_add_job(self.async_update_ha_state())
elif payload == self._payload_off:
self._state = False
hass.async_add_job(self.async_update_ha_state())
if self._state_topic is None:
# Force into optimistic mode.
self._optimistic = True
else:
mqtt.subscribe(
hass, self._state_topic, message_received, self._qos)
def test_restore_all_active_subscriptions_on_reconnect(self):
"""Test active subscriptions are restored correctly on reconnect."""
self.hass.data['mqtt']._mqttc.subscribe.side_effect = (
(0, 1), (0, 2), (0, 3), (0, 4)
)
unsub = mqtt.subscribe(self.hass, 'test/state', None, qos=2)
mqtt.subscribe(self.hass, 'test/state', None)
mqtt.subscribe(self.hass, 'test/state', None, qos=1)
self.hass.block_till_done()
expected = [
mock.call('test/state', 2),
mock.call('test/state', 0),
mock.call('test/state', 1)
]
assert self.hass.data['mqtt']._mqttc.subscribe.mock_calls == \
expected
unsub()
self.hass.block_till_done()
assert self.hass.data['mqtt']._mqttc.unsubscribe.call_count == \
0
self.hass.data['mqtt']._mqtt_on_disconnect(None, None, 0)
self.hass.data['mqtt']._mqtt_on_connect(None, None, None, 0)
self.hass.block_till_done()
expected.append(mock.call('test/state', 1))
assert self.hass.data['mqtt']._mqttc.subscribe.mock_calls == \
expected
def __init__(self, hass, name, state_topic, command_topic, qos, retain,
state_open, state_closed, service_open, service_close,
optimistic, value_template):
"""Initialize the garage door."""
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._retain = retain
self._state_open = state_open
self._state_closed = state_closed
self._service_open = service_open
self._service_close = service_close
self._optimistic = optimistic or state_topic is None
self._state = False
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
if value_template is not None:
payload = template.render_with_possible_json_value(
hass, value_template, payload)
if payload == self._state_open:
self._state = True
self.update_ha_state()
elif payload == self._state_closed:
self._state = False
self.update_ha_state()
if self._state_topic is None:
# Force into optimistic mode.
self._optimistic = True
else:
mqtt.subscribe(hass, self._state_topic, message_received,
self._qos)
def __init__(self, hass, name, state_topic, command_topic, qos, retain,
payload_on, payload_off, optimistic, value_template):
self._state = False
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._retain = retain
self._payload_on = payload_on
self._payload_off = payload_off
self._optimistic = optimistic
def message_received(topic, payload, qos):
""" A new MQTT message has been received. """
if value_template is not None:
payload = template.render_with_possible_json_value(
hass, value_template, payload)
if payload == self._payload_on:
self._state = True
self.update_ha_state()
elif payload == self._payload_off:
self._state = False
self.update_ha_state()
if self._state_topic is None:
# force optimistic mode
self._optimistic = True
else:
# subscribe the state_topic
mqtt.subscribe(hass, self._state_topic, message_received,
self._qos)
def test_subscribe_topic_level_wildcard_and_wildcard_level_no_match(self):
"""Test the subscription of wildcard topics."""
mqtt.subscribe(self.hass, '+/test-topic/#', self.record_calls)
fire_mqtt_message(self.hass, 'hi/here-iam/test-topic', 'test-payload')
self.hass.block_till_done()
self.assertEqual(0, len(self.calls))
def test_subscribe_topic_not_match(self):
"""Test if subscribed topic is not a match."""
mqtt.subscribe(self.hass, 'test-topic', self.record_calls)
fire_mqtt_message(self.hass, 'another-test-topic', 'test-payload')
self.hass.block_till_done()
self.assertEqual(0, len(self.calls))
def test_subscribe_topic_level_wildcard_no_subtree_match(self):
"""Test the subscription of wildcard topics."""
mqtt.subscribe(self.hass, 'test-topic/+/on', self.record_calls)
fire_mqtt_message(self.hass, 'test-topic/bier', 'test-payload')
self.hass.block_till_done()
self.assertEqual(0, len(self.calls))
def test_subscribe_topic_subtree_wildcard_no_match(self):
"""Test the subscription of wildcard topics."""
mqtt.subscribe(self.hass, 'test-topic/#', self.record_calls)
fire_mqtt_message(self.hass, 'another-test-topic', 'test-payload')
self.hass.block_till_done()
assert 0 == len(self.calls)
def test_subscribe_topic_subtree_wildcard_no_match(self):
"""Test the subscription of wildcard topics."""
mqtt.subscribe(self.hass, "test-topic/#", self.record_calls)
fire_mqtt_message(self.hass, "another-test-topic", "test-payload")
self.hass.block_till_done()
self.assertEqual(0, len(self.calls))
def test_subscribe_topic_subtree_wildcard_root_topic(self):
mqtt.subscribe(self.hass, 'test-topic/#', self.record_calls)
fire_mqtt_message(self.hass, 'test-topic', 'test-payload')
self.hass.pool.block_till_done()
self.assertEqual(1, len(self.calls))
self.assertEqual('test-topic', self.calls[0][0])
self.assertEqual('test-payload', self.calls[0][1])
def test_subscribe_topic_level_wildcard(self):
mqtt.subscribe(self.hass, 'test-topic/+/on', self.record_calls)
fire_mqtt_message(self.hass, 'test-topic/bier/on', 'test-payload')
self.hass.pool.block_till_done()
self.assertEqual(1, len(self.calls))
self.assertEqual('test-topic/bier/on', self.calls[0][0])
self.assertEqual('test-payload', self.calls[0][1])
def __init__(self, hass, name, topic, qos, retain,
optimistic, brightness, rgb, flash_times):
"""Initialize MQTT JSON light."""
self._hass = hass
self._name = name
self._topic = topic
self._qos = qos
self._retain = retain
self._optimistic = optimistic or topic[CONF_STATE_TOPIC] is None
self._state = False
if brightness:
self._brightness = 255
else:
self._brightness = None
if rgb:
self._rgb = [0, 0, 0]
else:
self._rgb = None
self._flash_times = flash_times
def state_received(topic, payload, qos):
"""A new MQTT message has been received."""
values = json.loads(payload)
if values['state'] == 'ON':
self._state = True
elif values['state'] == 'OFF':
self._state = False
if self._rgb is not None:
try:
red = int(values['color']['r'])
green = int(values['color']['g'])
blue = int(values['color']['b'])
self._rgb = [red, green, blue]
except KeyError:
pass
except ValueError:
_LOGGER.warning("Invalid color value received")
if self._brightness is not None:
try:
self._brightness = int(values['brightness'])
except KeyError:
pass
except ValueError:
_LOGGER.warning('Invalid brightness value received')
self.update_ha_state()
if self._topic[CONF_STATE_TOPIC] is not None:
mqtt.subscribe(self._hass, self._topic[CONF_STATE_TOPIC],
state_received, self._qos)
def test_subscribe_topic_sys_root(self):
"""Test the subscription of $ root topics."""
mqtt.subscribe(self.hass, '$test-topic/subtree/on', self.record_calls)
fire_mqtt_message(self.hass, '$test-topic/subtree/on', 'test-payload')
self.hass.block_till_done()
assert 1 == len(self.calls)
assert '$test-topic/subtree/on' == self.calls[0][0].topic
assert 'test-payload' == self.calls[0][0].payload
def test_subscribe_topic_subtree_wildcard_subtree_topic(self):
"""Test the subscription of wildcard topics."""
mqtt.subscribe(self.hass, 'test-topic/#', self.record_calls)
fire_mqtt_message(self.hass, 'test-topic/bier/on', 'test-payload')
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
self.assertEqual('test-topic/bier/on', self.calls[0][0])
self.assertEqual('test-payload', self.calls[0][1])
def test_not_calling_unsubscribe_with_active_subscribers(self):
"""Test not calling unsubscribe() when other subscribers are active."""
unsub = mqtt.subscribe(self.hass, 'test/state', None)
mqtt.subscribe(self.hass, 'test/state', None)
self.hass.block_till_done()
assert self.hass.data['mqtt']._mqttc.subscribe.called
unsub()
self.hass.block_till_done()
assert not self.hass.data['mqtt']._mqttc.unsubscribe.called
def test_restore_subscriptions_on_reconnect(self):
"""Test subscriptions are restored on reconnect."""
mqtt.subscribe(self.hass, 'test/state', None)
self.hass.block_till_done()
assert self.hass.data['mqtt']._mqttc.subscribe.call_count == 1
self.hass.data['mqtt']._mqtt_on_disconnect(None, None, 0)
self.hass.data['mqtt']._mqtt_on_connect(None, None, None, 0)
self.hass.block_till_done()
assert self.hass.data['mqtt']._mqttc.subscribe.call_count == 2
def test_subscribe_topic_subtree_wildcard_root_topic(self):
"""Test the subscription of wildcard topics."""
mqtt.subscribe(self.hass, 'test-topic/#', self.record_calls)
fire_mqtt_message(self.hass, 'test-topic', 'test-payload')
self.hass.block_till_done()
assert 1 == len(self.calls)
assert 'test-topic' == self.calls[0][0]
assert 'test-payload' == self.calls[0][1]
def test_subscribe_topic(self):
"""Test the subscription of a topic."""
mqtt.subscribe(self.hass, 'test-topic', self.record_calls)
fire_mqtt_message(self.hass, 'test-topic', 'test-payload')
self.hass.pool.block_till_done()
self.assertEqual(1, len(self.calls))
self.assertEqual('test-topic', self.calls[0][0])
self.assertEqual('test-payload', self.calls[0][1])
def test_subscribe_topic_level_wildcard_and_wildcard_subtree_topic(self):
"""Test the subscription of wildcard topics."""
mqtt.subscribe(self.hass, '+/test-topic/#', self.record_calls)
fire_mqtt_message(self.hass, 'hi/test-topic/here-iam', 'test-payload')
self.hass.block_till_done()
assert 1 == len(self.calls)
assert 'hi/test-topic/here-iam' == self.calls[0][0].topic
assert 'test-payload' == self.calls[0][0].payload
def test_subscribe_topic_sys_root_and_wildcard_topic(self):
"""Test the subscription of $ root and wildcard topics."""
mqtt.subscribe(self.hass, '$test-topic/#', self.record_calls)
fire_mqtt_message(self.hass, '$test-topic/some-topic', 'test-payload')
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
self.assertEqual('$test-topic/some-topic', self.calls[0][0])
self.assertEqual('test-payload', self.calls[0][1])
def test_subscribe_topic_level_wildcard(self):
"""Test the subscription of wildcard topics."""
mqtt.subscribe(self.hass, 'test-topic/+/on', self.record_calls)
fire_mqtt_message(self.hass, 'test-topic/bier/on', 'test-payload')
self.hass.block_till_done()
assert 1 == len(self.calls)
assert 'test-topic/bier/on' == self.calls[0][0].topic
assert 'test-payload' == self.calls[0][0].payload
def test_all_subscriptions_run_when_decode_fails(self):
"""Test all other subscriptions still run when decode fails for one."""
mqtt.subscribe(self.hass, 'test-topic', self.record_calls,
encoding='ascii')
mqtt.subscribe(self.hass, 'test-topic', self.record_calls)
fire_mqtt_message(self.hass, 'test-topic', '°C')
self.hass.block_till_done()
assert 1 == len(self.calls)
def test_subscribe_topic_sys_root_and_wildcard_subtree_topic(self):
"""Test the subscription of $ root and wildcard subtree topics."""
mqtt.subscribe(self.hass, "$test-topic/subtree/#", self.record_calls)
fire_mqtt_message(self.hass, "$test-topic/subtree/some-topic",
"test-payload")
self.hass.block_till_done()
assert len(self.calls) == 1
assert self.calls[0][0].topic == "$test-topic/subtree/some-topic"
assert self.calls[0][0].payload == "test-payload"
def test_subscribe_topic_sys_root_and_wildcard_subtree_topic(self):
"""Test the subscription of $ root and wildcard subtree topics."""
mqtt.subscribe(self.hass, '$test-topic/subtree/#', self.record_calls)
fire_mqtt_message(self.hass, '$test-topic/subtree/some-topic',
'test-payload')
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
self.assertEqual('$test-topic/subtree/some-topic', self.calls[0][0])
self.assertEqual('test-payload', self.calls[0][1])
def test_all_subscriptions_run_when_decode_fails(self):
"""Test all other subscriptions still run when decode fails for one."""
mqtt.subscribe(self.hass,
"test-topic",
self.record_calls,
encoding="ascii")
mqtt.subscribe(self.hass, "test-topic", self.record_calls)
fire_mqtt_message(self.hass, "test-topic", "°C")
self.hass.block_till_done()
assert len(self.calls) == 1
def test_subscribe_special_characters(self):
"""Test the subscription to topics with special characters."""
topic = "/test-topic/$(.)[^]{-}"
payload = "p4y.l[]a|> ?"
mqtt.subscribe(self.hass, topic, self.record_calls)
fire_mqtt_message(self.hass, topic, payload)
self.hass.block_till_done()
assert len(self.calls) == 1
assert self.calls[0][0].topic == topic
assert self.calls[0][0].payload == payload
def test_receiving_non_utf8_message_gets_logged(self):
"""Test receiving a non utf8 encoded message."""
mqtt.subscribe(self.hass, 'test-topic', self.record_calls)
with self.assertLogs(level='WARNING') as test_handle:
fire_mqtt_message(self.hass, 'test-topic', b'\x9a')
self.hass.block_till_done()
self.assertIn(
"WARNING:homeassistant.components.mqtt:Can't decode payload "
"b'\\x9a' on test-topic with encoding utf-8",
test_handle.output[0])
def test_all_subscriptions_run_when_decode_fails(self):
"""Test all other subscriptions still run when decode fails for one."""
mqtt.subscribe(self.hass,
'test-topic',
self.record_calls,
encoding='ascii')
mqtt.subscribe(self.hass, 'test-topic', self.record_calls)
fire_mqtt_message(self.hass, 'test-topic', '°C')
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
def test_subscribe_special_characters(self):
"""Test the subscription to topics with special characters."""
topic = '/test-topic/$(.)[^]{-}'
payload = 'p4y.l[]a|> ?'
mqtt.subscribe(self.hass, topic, self.record_calls)
fire_mqtt_message(self.hass, topic, payload)
self.hass.block_till_done()
self.assertEqual(1, len(self.calls))
self.assertEqual(topic, self.calls[0][0])
self.assertEqual(payload, self.calls[0][1])
def __init__(self, hass, name, state_topic, unit_of_measurement):
self._state = "-"
self._hass = hass
self._name = name
self._state_topic = state_topic
self._unit_of_measurement = unit_of_measurement
def message_received(topic, payload, qos):
""" A new MQTT message has been received. """
self._state = payload
self.update_ha_state()
mqtt.subscribe(hass, self._state_topic, message_received)
def test_not_calling_unsubscribe_with_active_subscribers(self):
"""Test not calling unsubscribe() when other subscribers are active."""
# Fake that the client is connected
self.hass.data["mqtt"].connected = True
unsub = mqtt.subscribe(self.hass, "test/state", None)
mqtt.subscribe(self.hass, "test/state", None)
self.hass.block_till_done()
assert self.hass.data["mqtt"]._mqttc.subscribe.called
unsub()
self.hass.block_till_done()
assert not self.hass.data["mqtt"]._mqttc.unsubscribe.called
def test_restore_subscriptions_on_reconnect(self):
"""Test subscriptions are restored on reconnect."""
# Fake that the client is connected
self.hass.data["mqtt"].connected = True
mqtt.subscribe(self.hass, "test/state", None)
self.hass.block_till_done()
assert self.hass.data["mqtt"]._mqttc.subscribe.call_count == 1
self.hass.data["mqtt"]._mqtt_on_disconnect(None, None, 0)
self.hass.data["mqtt"]._mqtt_on_connect(None, None, None, 0)
self.hass.block_till_done()
assert self.hass.data["mqtt"]._mqttc.subscribe.call_count == 2
def trigger(hass, config, action):
"""Listen for state changes based on configuration."""
topic = config[CONF_TOPIC]
payload = config.get(CONF_PAYLOAD)
def mqtt_automation_listener(msg_topic, msg_payload, qos):
"""Listen for MQTT messages."""
if payload is None or payload == msg_payload:
action()
mqtt.subscribe(hass, topic, mqtt_automation_listener)
return True
def __init__(self, hass, name, min_volume, max_volume, power_dict,
vol_dict, mute_dict, source_dict):
"""Initialize the MQTT_MEDIA Receiver device."""
self._name = name
self._min_volume = min_volume
self._max_volume = max_volume
self._source_dict = source_dict
self._power_dict = power_dict
self._vol_dict = vol_dict
self._mute_dict = mute_dict
self._volume = 0
self._state = STATE_UNKNOWN
self._mute = STATE_OFF
self._source = None
self._payload_off = "OFF"
self._payload_on = "ON"
self._retain = False
self._qos = 0
mqtt.subscribe(hass, self._source_dict["status_topic"],
self.message_source_selected, self._qos)
mqtt.subscribe(hass, self._power_dict["status_topic"],
self.message_power_changed, self._qos)
mqtt.subscribe(hass, self._vol_dict["status_topic"],
self.message_volume_changed, self._qos)
mqtt.subscribe(hass, self._mute_dict["status_topic"],
self.message_mute_changed, self._qos)
def __init__(self, hass, name, state_topic, device_id, timeout,
consider_home):
"""Initialize the sensor."""
self._state = STATE_AWAY
self._hass = hass
self._name = name
self._state_topic = '{}{}'.format(state_topic, '/+')
self._device_id = slugify(device_id).upper()
self._timeout = timeout
self._consider_home = \
timedelta(seconds=consider_home) if consider_home \
else None
self._distance = None
self._updated = None
def update_state(device_id, room, distance):
"""Update the sensor state."""
self._state = room
self._distance = distance
self._updated = dt.utcnow()
self.update_ha_state()
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
try:
data = MQTT_PAYLOAD(payload)
except vol.MultipleInvalid as error:
_LOGGER.debug(
'skipping update because of malformatted '
'data: %s', error)
return
device = _parse_update_data(topic, data)
if device.get(CONF_DEVICE_ID) == self._device_id:
if self._distance is None or self._updated is None:
update_state(**device)
else:
# update if:
# device is in the same room OR
# device is closer to another room OR
# last update from other room was too long ago
timediff = dt.utcnow() - self._updated
if device.get(ATTR_ROOM) == self._state \
or device.get(ATTR_DISTANCE) < self._distance \
or timediff.seconds >= self._timeout:
update_state(**device)
mqtt.subscribe(hass, self._state_topic, message_received, 1)
def __init__(self, hass, name, state_topic, temperature_state_topic,
command_topic, qos, retain):
"""Initialize the MQTT Heatpump."""
# self._state = False
self._state = STATE_UNKNOWN
self._hass = hass
self._name = name
self._state_topic = state_topic
self._temperature_state_topic = temperature_state_topic
self._command_topic = command_topic
self._qos = qos
self._retain = retain
self._current_temperature = None
self._target_temperature = None
self._fan_list = ["AUTO", "QUIET", "1", "2", "3", "4"]
self._current_fan_mode = None
self._operation_list = ["OFF", "HEAT", "DRY", "COOL", "FAN", "AUTO"]
self._current_operation = None
self._current_power = None
self._swing_list = ["AUTO", "1", "2", "3", "4", "5", "SWING"]
self._current_swing_mode = None
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
parsed = json.loads(payload)
if topic == self._state_topic:
self._target_temperature = float(parsed['temperature'])
self._current_fan_mode = parsed['fan']
self._current_swing_mode = parsed['vane']
if parsed['power'] == "OFF":
_LOGGER.debug("Power Off")
self._current_operation = "OFF"
self._current_power = "OFF"
else:
_LOGGER.debug("Power On")
self._current_operation = parsed['mode']
self._current_power = "ON"
elif topic == self._temperature_state_topic:
_LOGGER.debug('Room Temp: {0}'.format(
parsed['roomTemperature']))
self._current_temperature = float(parsed['roomTemperature'])
else:
print("unknown topic")
self.schedule_update_ha_state()
_LOGGER.debug("Power=%s, Operation=%s", self._current_power,
self._current_operation)
for topic in [self._state_topic, self._temperature_state_topic]:
mqtt.subscribe(hass, topic, message_received, self._qos)
def __init__(self, hass, name, state_topic, command_topic, qos, retain,
state_open, state_closed, payload_open, payload_close,
payload_stop, optimistic, value_template):
"""Initialize the cover."""
self._position = None
self._state = None
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._payload_open = payload_open
self._payload_close = payload_close
self._payload_stop = payload_stop
self._state_open = state_open
self._state_closed = state_closed
self._retain = retain
self._optimistic = optimistic or state_topic is None
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
if value_template is not None:
payload = value_template.render_with_possible_json_value(
payload)
if payload == self._state_open:
self._state = False
_LOGGER.warning("state=%s", int(self._state))
self.update_ha_state()
elif payload == self._state_closed:
self._state = True
self.update_ha_state()
elif payload.isnumeric() and 0 <= int(payload) <= 100:
if int(payload) > 0:
self._state = False
else:
self._state = True
self._position = int(payload)
self.update_ha_state()
else:
_LOGGER.warning(
"Payload is not True, False, or integer (0-100): %s",
payload)
if self._state_topic is None:
# Force into optimistic mode.
self._optimistic = True
else:
mqtt.subscribe(hass, self._state_topic, message_received,
self._qos)
def test_message_callback_exception_gets_logged(self):
"""Test exception raised by message handler."""
@callback
def bad_handler(*args):
"""Record calls."""
raise Exception('This is a bad message callback')
mqtt.subscribe(self.hass, 'test-topic', bad_handler)
with self.assertLogs(level='WARNING') as test_handle:
fire_mqtt_message(self.hass, 'test-topic', 'test')
self.hass.block_till_done()
assert \
"Exception in bad_handler when handling msg on 'test-topic':" \
" 'test'" in \
test_handle.output[0]
def setup_scanner(hass, config, see, discovery_info=None):
"""Setup the MQTT tracker."""
devices = config[CONF_DEVICES]
qos = config[CONF_QOS]
dev_id_lookup = {}
def device_tracker_message_received(topic, payload, qos):
"""MQTT message received."""
see(dev_id=dev_id_lookup[topic], location_name=payload)
for dev_id, topic in devices.items():
dev_id_lookup[topic] = dev_id
mqtt.subscribe(hass, topic, device_tracker_message_received, qos)
return True
def test_retained_message_on_subscribe_received(self):
"""Test every subscriber receives retained message on subscribe."""
def side_effect(*args):
async_fire_mqtt_message(self.hass, 'test/state', 'online')
return 0, 0
self.hass.data['mqtt']._mqttc.subscribe.side_effect = side_effect
calls_a = mock.MagicMock()
mqtt.subscribe(self.hass, 'test/state', calls_a)
self.hass.block_till_done()
self.assertTrue(calls_a.called)
calls_b = mock.MagicMock()
mqtt.subscribe(self.hass, 'test/state', calls_b)
self.hass.block_till_done()
self.assertTrue(calls_b.called)
def update_battery_level(self, now=None):
payload = '85,3,1,16'
sub_topic = self._mac_address + self._topic
pub_topic = sub_topic + self._set_suffix
mqtt.publish(self._hass, pub_topic, payload)
@callback
def msg_callback(msg):
"""Receive events published by and fire them on this hass instance."""
results = msg.payload.split(',')
# 返回数据5位是电量信息
if len(results) == 5:
battery_level = round(int(results[4]) / 10, 1)
self._temperature_sensor.update_battery(battery_level)
self._humidity_sensor.update_battery(battery_level)
mqtt.subscribe(self._hass, sub_topic, msg_callback)
def __init__(self, hass, name, state_topic, qos, unit_of_measurement,
value_template):
self._state = STATE_UNKNOWN
self._hass = hass
self._name = name
self._state_topic = state_topic
self._qos = qos
self._unit_of_measurement = unit_of_measurement
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
if value_template is not None:
payload = template.render_with_possible_json_value(
hass, value_template, payload)
self._state = payload
self.update_ha_state()
mqtt.subscribe(hass, self._state_topic, message_received, self._qos)
def register(hass, config, action):
""" Listen for state changes based on `config`. """
topic = config.get(CONF_TOPIC)
payload = config.get(CONF_PAYLOAD)
if topic is None:
logging.getLogger(__name__).error("Missing configuration key %s",
CONF_TOPIC)
return False
def mqtt_automation_listener(msg_topic, msg_payload, qos):
""" Listens for MQTT messages. """
if payload is None or payload == msg_payload:
action()
mqtt.subscribe(hass, topic, mqtt_automation_listener)
return True
def __init__(self, hass, name, state_topic, command_topic, qos,
payload_disarm, payload_arm_home, payload_arm_away, code):
self._state = STATE_UNKNOWN
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._payload_disarm = payload_disarm
self._payload_arm_home = payload_arm_home
self._payload_arm_away = payload_arm_away
self._code = code
def message_received(topic, payload, qos):
""" A new MQTT message has been received. """
self._state = payload
self.update_ha_state()
mqtt.subscribe(hass, self._state_topic, message_received, self._qos)
def test_retained_message_on_subscribe_received(self):
"""Test every subscriber receives retained message on subscribe."""
def side_effect(*args):
async_fire_mqtt_message(self.hass, "test/state", "online")
return 0, 0
self.hass.data["mqtt"]._mqttc.subscribe.side_effect = side_effect
# Fake that the client is connected
self.hass.data["mqtt"].connected = True
calls_a = mock.MagicMock()
mqtt.subscribe(self.hass, "test/state", calls_a)
self.hass.block_till_done()
assert calls_a.called
calls_b = mock.MagicMock()
mqtt.subscribe(self.hass, "test/state", calls_b)
self.hass.block_till_done()
assert calls_b.called
def __init__(self, hass, name, state_topic, qos, unit_of_measurement,
value_template):
"""Initialize the sensor."""
self._state = STATE_UNKNOWN
self._hass = hass
self._name = name
self._state_topic = state_topic
self._qos = qos
self._unit_of_measurement = unit_of_measurement
@callback
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
if value_template is not None:
payload = value_template.async_render_with_possible_json_value(
payload, self._state)
self._state = payload
hass.async_add_job(self.async_update_ha_state())
mqtt.subscribe(hass, self._state_topic, message_received, self._qos)
def setup_scanner(hass, config, see):
""" Set up a MQTT tracker. """
devices = config.get(CONF_DEVICES)
qos = util.convert(config.get(CONF_QOS), int, DEFAULT_QOS)
if not isinstance(devices, dict):
_LOGGER.error('Expected %s to be a dict, found %s', CONF_DEVICES,
devices)
return False
dev_id_lookup = {}
def device_tracker_message_received(topic, payload, qos):
""" MQTT message received. """
see(dev_id=dev_id_lookup[topic], location_name=payload)
for dev_id, topic in devices.items():
dev_id_lookup[topic] = dev_id
mqtt.subscribe(hass, topic, device_tracker_message_received, qos)
return True
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the ARWN platform."""
def sensor_event_received(topic, payload, qos):
"""Process events as sensors.
When a new event on our topic (arwn/#) is received we map it
into a known kind of sensor based on topic name. If we've
never seen this before, we keep this sensor around in a global
cache. If we have seen it before, we update the values of the
existing sensor. Either way, we push an ha state update at the
end for the new event we've seen.
This lets us dynamically incorporate sensors without any
configuration on our side.
"""
event = json.loads(payload)
sensors = discover_sensors(topic, event)
if not sensors:
return
if isinstance(sensors, ArwnSensor):
sensors = (sensors, )
if 'timestamp' in event:
del event['timestamp']
for sensor in sensors:
if sensor.name not in SENSORS:
sensor.hass = hass
sensor.set_event(event)
SENSORS[sensor.name] = sensor
_LOGGER.debug("Registering new sensor %(name)s => %(event)s",
dict(name=sensor.name, event=event))
add_devices((sensor, ))
else:
SENSORS[sensor.name].set_event(event)
SENSORS[sensor.name].update_ha_state()
mqtt.subscribe(hass, TOPIC, sensor_event_received, 0)
return True
def update_temperature_humidity(self, now=None):
#check if battery level out of date
if not (self._temperature_sensor.device_state_attributes[ATTR_BATTERY] and self._humidity_sensor.device_state_attributes[ATTR_BATTERY]):
_LOGGER.info("update meizu battery because it's out of date")
self.update_battery_level()
payload = '85,3,8,17'
sub_topic = self._mac_address + self._topic
pub_topic = sub_topic + self._set_suffix
mqtt.publish(self._hass, pub_topic, payload)
@callback
def msg_callback(msg):
"""Receive events published by and fire them on this hass instance."""
results = msg.payload.split(',')
# 返回数据8位是温湿度信息, 45位温度，67位是湿度
if len(results) == 8:
temperature = round((int(results[4]) + int(results[5]) * 16 * 16) / 100, 1)
humidity = round((int(results[6]) + int(results[7]) * 16 * 16) / 100, 1)
self._temperature_sensor.update_state(temperature)
self._humidity_sensor.update_state(humidity)
mqtt.subscribe(self._hass, sub_topic, msg_callback)
def __init__(self, hass, name, state_topic, qos, payload_on, payload_off,
value_template):
self._hass = hass
self._name = name
self._state = False
self._state_topic = state_topic
self._payload_on = payload_on
self._payload_off = payload_off
self._qos = qos
def message_received(topic, payload, qos):
""" A new MQTT message has been received. """
if value_template is not None:
payload = template.render_with_possible_json_value(
hass, value_template, payload)
if payload == self._payload_on:
self._state = True
self.update_ha_state()
elif payload == self._payload_off:
self._state = False
self.update_ha_state()
mqtt.subscribe(hass, self._state_topic, message_received, self._qos)
def __init__(self, hass, name, topic, rgb, qos, payload, brightness,
optimistic):
self._hass = hass
self._name = name
self._topic = topic
self._rgb = rgb
self._qos = qos
self._payload = payload
self._brightness = brightness
self._optimistic = optimistic
self._state = False
self._xy = None
def message_received(topic, payload, qos):
""" A new MQTT message has been received. """
if payload == self._payload["on"]:
self._state = True
elif payload == self._payload["off"]:
self._state = False
self.update_ha_state()
if self._topic["state_topic"] is None:
# force optimistic mode
self._optimistic = True
else:
# Subscribe the state_topic
mqtt.subscribe(self._hass, self._topic["state_topic"],
message_received, self._qos)
def brightness_received(topic, payload, qos):
""" A new MQTT message for the brightness has been received. """
self._brightness = int(payload)
self.update_ha_state()
def rgb_received(topic, payload, qos):
""" A new MQTT message has been received. """
self._rgb = [int(val) for val in payload.split(',')]
self._xy = color_util.color_RGB_to_xy(int(self._rgb[0]),
int(self._rgb[1]),
int(self._rgb[2]))
self.update_ha_state()
if self._topic["brightness_state_topic"] is not None:
mqtt.subscribe(self._hass, self._topic["brightness_state_topic"],
brightness_received, self._qos)
self._brightness = 255
else:
self._brightness = None
if self._topic["rgb_state_topic"] is not None:
mqtt.subscribe(self._hass, self._topic["rgb_state_topic"],
rgb_received, self._qos)
self._xy = [0, 0]
else:
self._xy = None
def setup(hass, config):
"""Setup the MQTT example component."""
topic = config[DOMAIN][CONF_TOPIC]
entity_id = 'mqtt_example.last_message'
# Listen to a message on MQTT.
def message_received(topic, payload, qos):
"""A new MQTT message has been received."""
hass.states.set(entity_id, payload)
mqtt.subscribe(hass, topic, message_received)
hass.states.set(entity_id, 'No messages')
# Service to publish a message on MQTT.
def set_state_service(call):
"""Service to send a message."""
mqtt.publish(hass, topic, call.data.get('new_state'))
# Register our service with Home Assistant.
hass.services.register(DOMAIN, 'set_state', set_state_service)
# Return boolean to indicate that initialization was successfully.
return True
