Checking Xiaomi Aqara devices unavailability states

homeassistant/components/binary_sensor/xiaomi_aqara.py

@@ -28,13 +28,13 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             if model in ['motion', 'sensor_motion.aq2']:
                 devices.append(XiaomiMotionSensor(device, hass, gateway))
             elif model in ['magnet', 'sensor_magnet.aq2']:
-                devices.append(XiaomiDoorSensor(device, gateway))
+                devices.append(XiaomiDoorSensor(device, hass, gateway))
             elif model == 'sensor_wleak.aq1':
-                devices.append(XiaomiWaterLeakSensor(device, gateway))
+                devices.append(XiaomiWaterLeakSensor(device, hass, gateway))
             elif model == 'smoke':
-                devices.append(XiaomiSmokeSensor(device, gateway))
+                devices.append(XiaomiSmokeSensor(device, hass, gateway))
             elif model == 'natgas':
-                devices.append(XiaomiNatgasSensor(device, gateway))
+                devices.append(XiaomiNatgasSensor(device, hass, gateway))
             elif model in ['switch', 'sensor_switch.aq2', 'sensor_switch.aq3']:
                 devices.append(XiaomiButton(device, 'Switch', 'status',
                                             hass, gateway))
@@ -56,13 +56,13 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class XiaomiBinarySensor(XiaomiDevice, BinarySensorDevice):
     """Representation of a base XiaomiBinarySensor."""
 
-    def __init__(self, device, name, xiaomi_hub, data_key, device_class):
+    def __init__(self, device, name, hass, xiaomi_hub, data_key, device_class):
         """Initialize the XiaomiSmokeSensor."""
         self._data_key = data_key
         self._device_class = device_class
         self._should_poll = False
         self._density = 0
-        XiaomiDevice.__init__(self, device, name, xiaomi_hub)
+        XiaomiDevice.__init__(self, device, name, hass, xiaomi_hub)
 
     @property
     def should_poll(self):
@@ -88,11 +88,11 @@ def update(self):
 class XiaomiNatgasSensor(XiaomiBinarySensor):
     """Representation of a XiaomiNatgasSensor."""
 
-    def __init__(self, device, xiaomi_hub):
+    def __init__(self, device, hass, xiaomi_hub):
         """Initialize the XiaomiSmokeSensor."""
         self._density = None
-        XiaomiBinarySensor.__init__(self, device, 'Natgas Sensor', xiaomi_hub,
-                                    'alarm', 'gas')
+        XiaomiBinarySensor.__init__(self, device, 'Natgas Sensor', hass,
+                                    xiaomi_hub, 'alarm', 'gas')
 
     @property
     def device_state_attributes(self):
@@ -101,7 +101,7 @@ def device_state_attributes(self):
         attrs.update(super().device_state_attributes)
         return attrs
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
         if DENSITY in data:
             self._density = int(data.get(DENSITY))
@@ -129,8 +129,8 @@ def __init__(self, device, hass, xiaomi_hub):
         """Initialize the XiaomiMotionSensor."""
         self._hass = hass
         self._no_motion_since = 0
-        XiaomiBinarySensor.__init__(self, device, 'Motion Sensor', xiaomi_hub,
-                                    'status', 'motion')
+        XiaomiBinarySensor.__init__(self, device, 'Motion Sensor', hass,
+                                    xiaomi_hub, 'status', 'motion')
 
     @property
     def device_state_attributes(self):
@@ -139,8 +139,16 @@ def device_state_attributes(self):
         attrs.update(super().device_state_attributes)
         return attrs
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
+        if raw_data['cmd'] == 'heartbeat':
+            _LOGGER.debug(
+                'Skipping heartbeat of the motion sensor. '
+                'It can introduce an incorrect state because of a firmware '
+                'bug (https://github.com/home-assistant/home-assistant/pull/'
+                '11631#issuecomment-357507744).')
+            return
+
         self._should_poll = False
         if NO_MOTION in data:  # handle push from the hub
             self._no_motion_since = data[NO_MOTION]
@@ -173,11 +181,11 @@ def parse_data(self, data):
 class XiaomiDoorSensor(XiaomiBinarySensor):
     """Representation of a XiaomiDoorSensor."""
 
-    def __init__(self, device, xiaomi_hub):
+    def __init__(self, device, hass, xiaomi_hub):
         """Initialize the XiaomiDoorSensor."""
         self._open_since = 0
         XiaomiBinarySensor.__init__(self, device, 'Door Window Sensor',
-                                    xiaomi_hub, 'status', 'opening')
+                                    hass, xiaomi_hub, 'status', 'opening')
 
     @property
     def device_state_attributes(self):
@@ -186,7 +194,7 @@ def device_state_attributes(self):
         attrs.update(super().device_state_attributes)
         return attrs
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
         self._should_poll = False
         if NO_CLOSE in data:  # handle push from the hub
@@ -214,12 +222,12 @@ def parse_data(self, data):
 class XiaomiWaterLeakSensor(XiaomiBinarySensor):
     """Representation of a XiaomiWaterLeakSensor."""
 
-    def __init__(self, device, xiaomi_hub):
+    def __init__(self, device, hass, xiaomi_hub):
         """Initialize the XiaomiWaterLeakSensor."""
         XiaomiBinarySensor.__init__(self, device, 'Water Leak Sensor',
-                                    xiaomi_hub, 'status', 'moisture')
+                                    hass, xiaomi_hub, 'status', 'moisture')
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
         self._should_poll = False
 
@@ -243,11 +251,11 @@ def parse_data(self, data):
 class XiaomiSmokeSensor(XiaomiBinarySensor):
     """Representation of a XiaomiSmokeSensor."""
 
-    def __init__(self, device, xiaomi_hub):
+    def __init__(self, device, hass, xiaomi_hub):
         """Initialize the XiaomiSmokeSensor."""
         self._density = 0
-        XiaomiBinarySensor.__init__(self, device, 'Smoke Sensor', xiaomi_hub,
-                                    'alarm', 'smoke')
+        XiaomiBinarySensor.__init__(self, device, 'Smoke Sensor', hass,
+                                    xiaomi_hub, 'alarm', 'smoke')
 
     @property
     def device_state_attributes(self):
@@ -256,7 +264,7 @@ def device_state_attributes(self):
         attrs.update(super().device_state_attributes)
         return attrs
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
         if DENSITY in data:
             self._density = int(data.get(DENSITY))
@@ -283,8 +291,8 @@ def __init__(self, device, name, data_key, hass, xiaomi_hub):
         """Initialize the XiaomiButton."""
         self._hass = hass
         self._last_action = None
-        XiaomiBinarySensor.__init__(self, device, name, xiaomi_hub,
-                                    data_key, None)
+        XiaomiBinarySensor.__init__(self, device, name, hass,
+                                    xiaomi_hub, data_key, None)
 
     @property
     def device_state_attributes(self):
@@ -293,7 +301,7 @@ def device_state_attributes(self):
         attrs.update(super().device_state_attributes)
         return attrs
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
         value = data.get(self._data_key)
         if value is None:
@@ -333,8 +341,8 @@ def __init__(self, device, hass, xiaomi_hub):
         self._hass = hass
         self._last_action = None
         self._state = False
-        XiaomiBinarySensor.__init__(self, device, 'Cube', xiaomi_hub,
-                                    None, None)
+        XiaomiBinarySensor.__init__(self, device, 'Cube', hass,
+                                    xiaomi_hub, None, None)
 
     @property
     def device_state_attributes(self):
@@ -343,7 +351,7 @@ def device_state_attributes(self):
         attrs.update(super().device_state_attributes)
         return attrs
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
         if 'status' in data:
             self._hass.bus.fire('cube_action', {

homeassistant/components/cover/xiaomi_aqara.py

@@ -20,18 +20,18 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                 devices.append(XiaomiGenericCover(device, "Curtain",
                                                   {'status': 'status',
                                                    'pos': 'curtain_level'},
-                                                  gateway))
+                                                  hass, gateway))
     add_devices(devices)
 
 
 class XiaomiGenericCover(XiaomiDevice, CoverDevice):
     """Representation of a XiaomiGenericCover."""
 
-    def __init__(self, device, name, data_key, xiaomi_hub):
+    def __init__(self, device, name, data_key, hass, xiaomi_hub):
         """Initialize the XiaomiGenericCover."""
         self._data_key = data_key
         self._pos = 0
-        XiaomiDevice.__init__(self, device, name, xiaomi_hub)
+        XiaomiDevice.__init__(self, device, name, hass, xiaomi_hub)
 
     @property
     def current_cover_position(self):
@@ -59,7 +59,7 @@ def set_cover_position(self, position, **kwargs):
         """Move the cover to a specific position."""
         self._write_to_hub(self._sid, **{self._data_key['pos']: str(position)})
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
         if ATTR_CURTAIN_LEVEL in data:
             self._pos = int(data[ATTR_CURTAIN_LEVEL])

homeassistant/components/light/xiaomi_aqara.py

@@ -19,27 +19,27 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             model = device['model']
             if model == 'gateway':
                 devices.append(XiaomiGatewayLight(device, 'Gateway Light',
-                                                  gateway))
+                                                  hass, gateway))
     add_devices(devices)
 
 
 class XiaomiGatewayLight(XiaomiDevice, Light):
     """Representation of a XiaomiGatewayLight."""
 
-    def __init__(self, device, name, xiaomi_hub):
+    def __init__(self, device, name, hass, xiaomi_hub):
         """Initialize the XiaomiGatewayLight."""
         self._data_key = 'rgb'
         self._rgb = (255, 255, 255)
         self._brightness = 180
 
-        XiaomiDevice.__init__(self, device, name, xiaomi_hub)
+        XiaomiDevice.__init__(self, device, name, hass, xiaomi_hub)
 
     @property
     def is_on(self):
         """Return true if it is on."""
         return self._state
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
         value = data.get(self._data_key)
         if value is None:

homeassistant/components/sensor/xiaomi_aqara.py

@@ -15,32 +15,32 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         for device in gateway.devices['sensor']:
             if device['model'] == 'sensor_ht':
                 devices.append(XiaomiSensor(device, 'Temperature',
-                                            'temperature', gateway))
+                                            'temperature', hass, gateway))
                 devices.append(XiaomiSensor(device, 'Humidity',
-                                            'humidity', gateway))
+                                            'humidity', hass, gateway))
             elif device['model'] == 'weather.v1':
                 devices.append(XiaomiSensor(device, 'Temperature',
-                                            'temperature', gateway))
+                                            'temperature', hass, gateway))
                 devices.append(XiaomiSensor(device, 'Humidity',
-                                            'humidity', gateway))
+                                            'humidity', hass, gateway))
                 devices.append(XiaomiSensor(device, 'Pressure',
-                                            'pressure', gateway))
+                                            'pressure', hass, gateway))
             elif device['model'] == 'sensor_motion.aq2':
                 devices.append(XiaomiSensor(device, 'Illumination',
-                                            'lux', gateway))
+                                            'lux', hass, gateway))
             elif device['model'] == 'gateway':
                 devices.append(XiaomiSensor(device, 'Illumination',
-                                            'illumination', gateway))
+                                            'illumination', hass, gateway))
     add_devices(devices)
 
 
 class XiaomiSensor(XiaomiDevice):
     """Representation of a XiaomiSensor."""
 
-    def __init__(self, device, name, data_key, xiaomi_hub):
+    def __init__(self, device, name, data_key, hass, xiaomi_hub):
         """Initialize the XiaomiSensor."""
         self._data_key = data_key
-        XiaomiDevice.__init__(self, device, name, xiaomi_hub)
+        XiaomiDevice.__init__(self, device, name, hass, xiaomi_hub)
 
     @property
     def unit_of_measurement(self):
@@ -61,7 +61,7 @@ def state(self):
         """Return the state of the sensor."""
         return self._state
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
         value = data.get(self._data_key)
         if value is None:

homeassistant/components/switch/xiaomi_aqara.py

@@ -27,49 +27,50 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             model = device['model']
             if model == 'plug':
                 devices.append(XiaomiGenericSwitch(device, "Plug", 'status',
-                                                   True, gateway))
+                                                   True, hass, gateway))
             elif model == 'ctrl_neutral1':
                 devices.append(XiaomiGenericSwitch(device, 'Wall Switch',
                                                    'channel_0',
-                                                   False, gateway))
+                                                   False, hass, gateway))
             elif model == 'ctrl_ln1':
                 devices.append(XiaomiGenericSwitch(device, 'Wall Switch LN',
                                                    'channel_0',
-                                                   False, gateway))
+                                                   False, hass, gateway))
             elif model == 'ctrl_neutral2':
                 devices.append(XiaomiGenericSwitch(device, 'Wall Switch Left',
                                                    'channel_0',
-                                                   False, gateway))
+                                                   False, hass, gateway))
                 devices.append(XiaomiGenericSwitch(device, 'Wall Switch Right',
                                                    'channel_1',
-                                                   False, gateway))
+                                                   False, hass, gateway))
             elif model == 'ctrl_ln2':
                 devices.append(XiaomiGenericSwitch(device,
                                                    'Wall Switch LN Left',
                                                    'channel_0',
-                                                   False, gateway))
+                                                   False, hass, gateway))
                 devices.append(XiaomiGenericSwitch(device,
                                                    'Wall Switch LN Right',
                                                    'channel_1',
-                                                   False, gateway))
+                                                   False, hass, gateway))
             elif model == '86plug':
                 devices.append(XiaomiGenericSwitch(device, 'Wall Plug',
-                                                   'status', True, gateway))
+                                                   'status', True, hass,
+                                                   gateway))
     add_devices(devices)
 
 
 class XiaomiGenericSwitch(XiaomiDevice, SwitchDevice):
     """Representation of a XiaomiPlug."""
 
     def __init__(self, device, name, data_key, supports_power_consumption,
-                 xiaomi_hub):
+                 hass, xiaomi_hub):
         """Initialize the XiaomiPlug."""
         self._data_key = data_key
         self._in_use = None
         self._load_power = None
         self._power_consumed = None
         self._supports_power_consumption = supports_power_consumption
-        XiaomiDevice.__init__(self, device, name, xiaomi_hub)
+        XiaomiDevice.__init__(self, device, name, hass, xiaomi_hub)
 
     @property
     def icon(self):
@@ -107,7 +108,7 @@ def turn_off(self):
             self._state = False
             self.schedule_update_ha_state()
 
-    def parse_data(self, data):
+    def parse_data(self, data, raw_data):
         """Parse data sent by gateway."""
         if IN_USE in data:
             self._in_use = int(data[IN_USE])