MQTT Binary Sensor - Add availability_topic for online/offline status (#9507)

* MQTT Binary Sensor - Add availability_topic for online/offline status

Added topic, configurable payloads, and tests.

* Relocated state subscribe function

Moved state subscribe function to follow the state listener function.

homeassistant/components/binary_sensor/mqtt.py

@@ -16,14 +16,21 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.const import (
     CONF_NAME, CONF_VALUE_TEMPLATE, CONF_PAYLOAD_ON, CONF_PAYLOAD_OFF,
     CONF_DEVICE_CLASS)
-from homeassistant.components.mqtt import (CONF_STATE_TOPIC, CONF_QOS)
+from homeassistant.components.mqtt import (
+    CONF_STATE_TOPIC, CONF_AVAILABILITY_TOPIC, CONF_QOS, valid_subscribe_topic)
 import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
 
+CONF_PAYLOAD_AVAILABLE = 'payload_available'
+CONF_PAYLOAD_NOT_AVAILABLE = 'payload_not_available'
+
 DEFAULT_NAME = 'MQTT Binary sensor'
 DEFAULT_PAYLOAD_OFF = 'OFF'
 DEFAULT_PAYLOAD_ON = 'ON'
+DEFAULT_PAYLOAD_AVAILABLE = 'online'
+DEFAULT_PAYLOAD_NOT_AVAILABLE = 'offline'
+
 DEPENDENCIES = ['mqtt']
 
 PLATFORM_SCHEMA = mqtt.MQTT_RO_PLATFORM_SCHEMA.extend({
@@ -31,6 +38,11 @@ PLATFORM_SCHEMA = mqtt.MQTT_RO_PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_PAYLOAD_OFF, default=DEFAULT_PAYLOAD_OFF): cv.string,
     vol.Optional(CONF_PAYLOAD_ON, default=DEFAULT_PAYLOAD_ON): cv.string,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+    vol.Optional(CONF_AVAILABILITY_TOPIC): valid_subscribe_topic,
+    vol.Optional(CONF_PAYLOAD_AVAILABLE,
+                 default=DEFAULT_PAYLOAD_AVAILABLE): cv.string,
+    vol.Optional(CONF_PAYLOAD_NOT_AVAILABLE,
+                 default=DEFAULT_PAYLOAD_NOT_AVAILABLE): cv.string,
 })
 
 
@@ -47,10 +59,13 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     async_add_devices([MqttBinarySensor(
         config.get(CONF_NAME),
         config.get(CONF_STATE_TOPIC),
+        config.get(CONF_AVAILABILITY_TOPIC),
         config.get(CONF_DEVICE_CLASS),
         config.get(CONF_QOS),
         config.get(CONF_PAYLOAD_ON),
         config.get(CONF_PAYLOAD_OFF),
+        config.get(CONF_PAYLOAD_AVAILABLE),
+        config.get(CONF_PAYLOAD_NOT_AVAILABLE),
         value_template
     )])
 
@@ -58,15 +73,20 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
 class MqttBinarySensor(BinarySensorDevice):
     """Representation a binary sensor that is updated by MQTT."""
 
-    def __init__(self, name, state_topic, device_class, qos, payload_on,
+    def __init__(self, name, state_topic, availability_topic, device_class,
-                 payload_off, value_template):
+                 qos, payload_on, payload_off, payload_available,
+                 payload_not_available, value_template):
         """Initialize the MQTT binary sensor."""
         self._name = name
-        self._state = False
+        self._state = None
         self._state_topic = state_topic
+        self._availability_topic = availability_topic
+        self._available = True if availability_topic is None else False
         self._device_class = device_class
         self._payload_on = payload_on
         self._payload_off = payload_off
+        self._payload_available = payload_available
+        self._payload_not_available = payload_not_available
         self._qos = qos
         self._template = value_template
 
@@ -76,8 +96,8 @@ class MqttBinarySensor(BinarySensorDevice):
         This method must be run in the event loop and returns a coroutine.
         """
         @callback
-        def message_received(topic, payload, qos):
+        def state_message_received(topic, payload, qos):
-            """Handle a new received MQTT message."""
+            """Handle a new received MQTT state message."""
             if self._template is not None:
                 payload = self._template.async_render_with_possible_json_value(
                     payload)
@@ -88,8 +108,23 @@ class MqttBinarySensor(BinarySensorDevice):
 
             self.async_schedule_update_ha_state()
 
-        return mqtt.async_subscribe(
+        yield from mqtt.async_subscribe(
-            self.hass, self._state_topic, message_received, self._qos)
+            self.hass, self._state_topic, state_message_received, self._qos)
+
+        @callback
+        def availability_message_received(topic, payload, qos):
+            """Handle a new received MQTT availability message."""
+            if payload == self._payload_available:
+                self._available = True
+            elif payload == self._payload_not_available:
+                self._available = False
+
+            self.async_schedule_update_ha_state()
+
+        if self._availability_topic is not None:
+            yield from mqtt.async_subscribe(
+                self.hass, self._availability_topic,
+                availability_message_received, self._qos)
 
     @property
     def should_poll(self):
@@ -101,6 +136,11 @@ class MqttBinarySensor(BinarySensorDevice):
         """Return the name of the binary sensor."""
         return self._name
 
+    @property
+    def available(self) -> bool:
+        """Return if the binary sensor is available."""
+        return self._available
+
     @property
     def is_on(self):
         """Return true if the binary sensor is on."""

tests/components/binary_sensor/test_mqtt.py

@@ -3,7 +3,8 @@ import unittest
 
 from homeassistant.setup import setup_component
 import homeassistant.components.binary_sensor as binary_sensor
-from homeassistant.const import (STATE_OFF, STATE_ON)
+from homeassistant.const import (STATE_OFF, STATE_ON,
+                                 STATE_UNAVAILABLE)
 
 from tests.common import (
     get_test_home_assistant, mock_mqtt_component, fire_mqtt_message)
@@ -73,3 +74,70 @@ class TestSensorMQTT(unittest.TestCase):
 
         state = self.hass.states.get('binary_sensor.test')
         self.assertIsNone(state)
+
+    def test_availability_without_topic(self):
+        """Test availability without defined availability topic."""
+        self.assertTrue(setup_component(self.hass, binary_sensor.DOMAIN, {
+            binary_sensor.DOMAIN: {
+                'platform': 'mqtt',
+                'name': 'test',
+                'state_topic': 'state-topic',
+            }
+        }))
+
+        state = self.hass.states.get('binary_sensor.test')
+        self.assertNotEqual(STATE_UNAVAILABLE, state.state)
+
+    def test_availability_by_defaults(self):
+        """Test availability by defaults with defined topic."""
+        self.assertTrue(setup_component(self.hass, binary_sensor.DOMAIN, {
+            binary_sensor.DOMAIN: {
+                'platform': 'mqtt',
+                'name': 'test',
+                'state_topic': 'state-topic',
+                'availability_topic': 'availability-topic'
+            }
+        }))
+
+        state = self.hass.states.get('binary_sensor.test')
+        self.assertEqual(STATE_UNAVAILABLE, state.state)
+
+        fire_mqtt_message(self.hass, 'availability-topic', 'online')
+        self.hass.block_till_done()
+
+        state = self.hass.states.get('binary_sensor.test')
+        self.assertNotEqual(STATE_UNAVAILABLE, state.state)
+
+        fire_mqtt_message(self.hass, 'availability-topic', 'offline')
+        self.hass.block_till_done()
+
+        state = self.hass.states.get('binary_sensor.test')
+        self.assertEqual(STATE_UNAVAILABLE, state.state)
+
+    def test_availability_by_custom_payload(self):
+        """Test availability by custom payload with defined topic."""
+        self.assertTrue(setup_component(self.hass, binary_sensor.DOMAIN, {
+            binary_sensor.DOMAIN: {
+                'platform': 'mqtt',
+                'name': 'test',
+                'state_topic': 'state-topic',
+                'availability_topic': 'availability-topic',
+                'payload_available': 'good',
+                'payload_not_available': 'nogood'
+            }
+        }))
+
+        state = self.hass.states.get('binary_sensor.test')
+        self.assertEqual(STATE_UNAVAILABLE, state.state)
+
+        fire_mqtt_message(self.hass, 'availability-topic', 'good')
+        self.hass.block_till_done()
+
+        state = self.hass.states.get('binary_sensor.test')
+        self.assertNotEqual(STATE_UNAVAILABLE, state.state)
+
+        fire_mqtt_message(self.hass, 'availability-topic', 'nogood')
+        self.hass.block_till_done()
+
+        state = self.hass.states.get('binary_sensor.test')
+        self.assertEqual(STATE_UNAVAILABLE, state.state)